@distrohelena/canton-typescript-sdk 0.1.6 → 0.1.8

package/dist/core/signing/command-signer.interface.d.ts

@@ -3,3 +3,5 @@ import { SignCommandResult } from "./sign-command-result.js";
 export interface ICommandSigner {
     signAsync(request: SignCommandRequest): Promise<SignCommandResult>;
 }
+/** One signer for each party that acts in an interactively signed command. */
+export type CommandSigners = Readonly<Record<string, ICommandSigner>>;

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

@@ -185,7 +185,9 @@ import { CompletionObserver } from "../../services/command-completion/completion
 import { CommitmentChunkObserver } from "../../services/participant-inspection/commitment-chunk-observer.interface.js";
 import { ContractObserver } from "../../services/contracts/contract-observer.interface.js";
 import { TransactionObserver } from "../../services/events/transaction-observer.interface.js";
-import { ICommandSigner } from "../signing/command-signer.interface.js";
+import { CommandSigners, ICommandSigner } from "../signing/command-signer.interface.js";
+import { SignCommandResult } from "../signing/sign-command-result.js";
+import { PreparedCommandSubmission } from "../types/prepared-command-submission.js";
 import { RequestOptions } from "../types/request-options.js";
 import { SubmitCommandRequest } from "../types/requests/submit-command-request.js";
 export interface ITransport {
@@ -380,5 +382,7 @@ export interface ITransport {
      * Submits a command.
      * Supported on JSON and gRPC. External signing is gRPC-only.
      */
-    submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner | CommandSigners, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    prepareCommandAsync?(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
+    executePreparedCommandAndWaitAsync?(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

package/dist/core/types/disclosed-contract.d.ts

@@ -0,0 +1,13 @@
+import { TemplateId } from "../../query/model-types.js";
+export declare class DisclosedContract {
+    readonly createdEventBlob: Uint8Array;
+    readonly templateId?: TemplateId;
+    readonly contractId?: string;
+    readonly synchronizerId?: string;
+    constructor(init: {
+        createdEventBlob: Uint8Array;
+        templateId?: TemplateId;
+        contractId?: string;
+        synchronizerId?: string;
+    });
+}

package/dist/core/types/disclosed-contract.js

@@ -0,0 +1,15 @@
+import { ValidationError } from "../errors/validation-error.js";
+export class DisclosedContract {
+    createdEventBlob;
+    templateId;
+    contractId;
+    synchronizerId;
+    constructor(init) {
+        if (init.createdEventBlob.length === 0)
+            throw new ValidationError("disclosed contracts require a createdEventBlob");
+        this.createdEventBlob = init.createdEventBlob;
+        this.templateId = init.templateId;
+        this.contractId = init.contractId;
+        this.synchronizerId = init.synchronizerId;
+    }
+}

package/dist/core/types/prepared-command-submission.d.ts

@@ -0,0 +1,9 @@
+import { SubmitCommandRequest } from "./requests/submit-command-request.js";
+/** Opaque result of interactive command preparation, suitable for detached signing. */
+export declare class PreparedCommandSubmission {
+    readonly request: SubmitCommandRequest;
+    readonly transaction: unknown;
+    readonly transactionHash: Uint8Array;
+    readonly hashingSchemeVersion: number;
+    constructor(request: SubmitCommandRequest, transaction: unknown, transactionHash: Uint8Array, hashingSchemeVersion: number);
+}

package/dist/core/types/prepared-command-submission.js

@@ -0,0 +1,13 @@
+/** Opaque result of interactive command preparation, suitable for detached signing. */
+export class PreparedCommandSubmission {
+    request;
+    transaction;
+    transactionHash;
+    hashingSchemeVersion;
+    constructor(request, transaction, transactionHash, hashingSchemeVersion) {
+        this.request = request;
+        this.transaction = transaction;
+        this.transactionHash = transactionHash;
+        this.hashingSchemeVersion = hashingSchemeVersion;
+    }
+}

package/dist/core/types/requests/submit-command-request.d.ts

@@ -1,15 +1,20 @@
 import { LedgerCommand } from "../commands/ledger-command.js";
+import { DisclosedContract } from "../disclosed-contract.js";
 export declare class SubmitCommandRequest {
     readonly applicationId: string;
     readonly userId?: string;
     readonly actAs: readonly string[];
     readonly readAs: readonly string[];
     readonly command: LedgerCommand;
+    readonly disclosedContracts: readonly DisclosedContract[];
+    readonly synchronizerId?: string;
     constructor(init: {
         applicationId: string;
         userId?: string;
         actAs: readonly string[];
         readAs?: readonly string[];
         command: LedgerCommand;
+        disclosedContracts?: readonly DisclosedContract[];
+        synchronizerId?: string;
     });
 }

package/dist/core/types/requests/submit-command-request.js

@@ -5,6 +5,8 @@ export class SubmitCommandRequest {
     actAs;
     readAs;
     command;
+    disclosedContracts;
+    synchronizerId;
     constructor(init) {
         if (init.actAs.length === 0) {
             throw new ValidationError("submit requests require at least one actAs party");
@@ -14,5 +16,7 @@ export class SubmitCommandRequest {
         this.actAs = init.actAs;
         this.readAs = init.readAs ?? [];
         this.command = init.command;
+        this.disclosedContracts = init.disclosedContracts ?? [];
+        this.synchronizerId = init.synchronizerId;
     }
 }

package/dist/index.d.ts

@@ -206,6 +206,8 @@ export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-ext
 export { CreateExternalPartyRequest, } from "./core/types/requests/create-external-party-request.js";
 export type { ExternalPartySigner, ExternalPartySigningRequest, ExternalPartySigningResult, ExternalPartySigningPayloadKind, } from "./core/types/requests/create-external-party-request.js";
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";
+export { DisclosedContract } from "./core/types/disclosed-contract.js";
+export { PreparedCommandSubmission } from "./core/types/prepared-command-submission.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
 export { AssembleSignedTopologyTransactionsRequest } from "./core/types/requests/assemble-signed-topology-transactions-request.js";

package/dist/index.js

@@ -193,6 +193,8 @@ export { FinalizeDecentralizedPartyRequest, PreparedDecentralizedParty } from ".
 export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-external-party-request.js";
 export { CreateExternalPartyRequest, } from "./core/types/requests/create-external-party-request.js";
 export { AllocatePartyRequest } from "./core/types/requests/allocate-party-request.js";
+export { DisclosedContract } from "./core/types/disclosed-contract.js";
+export { PreparedCommandSubmission } from "./core/types/prepared-command-submission.js";
 export { AddPartyAsyncArguments } from "./core/types/requests/add-party-async-request.js";
 export { AddPartyAsyncRequest } from "./core/types/requests/add-party-async-request.js";
 export { AssembleSignedTopologyTransactionsRequest } from "./core/types/requests/assemble-signed-topology-transactions-request.js";

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

@@ -1,11 +1,15 @@
-import { ICommandSigner } from "../../core/signing/command-signer.interface.js";
+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 { SubmitCommandResponse } from "../../core/types/responses/submit-command-response.js";
+import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
+import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 export declare class CommandServiceClient {
     private readonly pipeline;
-    constructor(transport: ITransport, signer?: ICommandSigner);
+    constructor(transport: ITransport, signer?: ICommandSigner | CommandSigners);
     /** 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>;
+    executeAndWaitAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

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

@@ -11,4 +11,6 @@ export class CommandServiceClient {
     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); }
 }

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

@@ -1,13 +1,17 @@
-import { ICommandSigner } from "../../core/signing/command-signer.interface.js";
+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 { SubmitCommandResponse } from "../../core/types/responses/submit-command-response.js";
+import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
+import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 export declare class CommandSubmissionPipeline {
     private readonly dependencies;
     constructor(dependencies: {
         transport: ITransport;
-        signer?: ICommandSigner;
+        signer?: ICommandSigner | CommandSigners;
     });
     submitAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    prepareAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
+    executeAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

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

@@ -12,4 +12,8 @@ export class CommandSubmissionPipeline {
         }
         return this.dependencies.transport.submitCommandAsync(request, this.dependencies.signer, 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/transports/grpc/grpc-transport.d.ts

@@ -84,7 +84,9 @@ 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 { SignCommandResult } from "../../core/signing/sign-command-result.js";
+import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.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 +277,9 @@ 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>;
+    prepareCommandAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
+    executePreparedCommandAndWaitAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;
     private throwPartyTopologyReadCompatibilityError;
     private isProtobufDeserializationFailure;

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

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { ValidationError } from "../../core/errors/validation-error.js";
 import { SignCommandRequest } from "../../core/signing/sign-command-request.js";
+import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
 import { AllocatePartyResponse as SdkAllocatePartyResponse } from "../../core/types/responses/allocate-party-response.js";
 import { GetActiveContractsPageResponse } from "../../core/types/responses/get-active-contracts-page-response.js";
 import { GetLedgerApiVersionResponse as SdkGetLedgerApiVersionResponse } from "../../core/types/responses/get-ledger-api-version-response.js";
@@ -583,7 +584,7 @@ export class GrpcTransport {
             const payload = await this.operations.submitCommandAsync(mapGrpcSubmitCommandRequest(request), options);
             return mapGrpcSubmitCommand(payload);
         }
-        else 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");
         }
         else if (!this.operations.prepareSubmissionAsync) {
@@ -601,20 +602,37 @@ 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);
     }
+    async prepareCommandAsync(request, options) {
+        if (!this.operations.prepareSubmissionAsync)
+            throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
+        const prepared = await this.operations.prepareSubmissionAsync(mapGrpcPrepareSubmissionRequest(request, randomUUID()), options);
+        if (!prepared.preparedTransaction || prepared.preparedTransactionHash.length === 0)
+            throw new ValidationError("interactive prepare submission returned an incomplete result");
+        return new PreparedCommandSubmission(request, prepared.preparedTransaction, prepared.preparedTransactionHash, prepared.hashingSchemeVersion);
+    }
+    async executePreparedCommandAndWaitAsync(prepared, signatures, options) {
+        if (!this.operations.executeSubmissionAndWaitAsync)
+            throw new NotSupportedError("interactive gRPC command signing is not available on this transport");
+        const signerResults = prepared.request.actAs.map((party) => { const result = signatures[party]; if (!result)
+            throw new ValidationError(`interactive command signing requires a signature for ${party}`); return { party, result }; });
+        const result = await this.operations.executeSubmissionAndWaitAsync(mapGrpcExecuteSubmissionAndWaitRequest({ request: prepared.request, preparedTransaction: prepared.transaction, hashingSchemeVersion: prepared.hashingSchemeVersion, submissionId: randomUUID(), signerResults }), options);
+        return mapGrpcInteractiveSubmitCommand(result);
+    }
     throwIfDisposed() {
         if (this.disposed) {
             throw new ObjectDisposedError("The client or transport has been disposed.");

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

@@ -20,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,

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,

package/package.json

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