@distrohelena/canton-typescript-sdk 0.1.7 → 0.1.9

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

@@ -186,6 +186,8 @@ import { CommitmentChunkObserver } from "../../services/participant-inspection/c
 import { ContractObserver } from "../../services/contracts/contract-observer.interface.js";
 import { TransactionObserver } from "../../services/events/transaction-observer.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 {
@@ -381,4 +383,6 @@ export interface ITransport {
      * Supported on JSON and gRPC. External signing is gRPC-only.
      */
     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/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/index.d.ts

@@ -207,6 +207,7 @@ export { CreateExternalPartyRequest, } from "./core/types/requests/create-extern
 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

@@ -194,6 +194,7 @@ export { AllocateExternalPartyRequest } from "./core/types/requests/allocate-ext
 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/query/grpc/grpc-contract-query-client.js

@@ -44,7 +44,7 @@ export class GrpcContractQueryClient {
             args.where?.contractId?.in !== undefined ||
             args.where?.contractId?.is !== undefined ||
             args.where?.contractId?.isNot !== undefined ||
-            args.where?.templateId !== undefined) {
+            (args.where?.templateId !== undefined && typeof args.where.templateId.equals !== "string")) {
             throw new QueryCapabilityError(QuerySource.grpc, "contracts.findMany");
         }
         const findArgs = args;
@@ -55,6 +55,11 @@ export class GrpcContractQueryClient {
         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));
+        const legacyTemplate = args.where?.templateId;
+        if (legacyTemplate?.equals !== undefined)
+            rows = rows.filter((row) => `${row.templateId.packageId}:${row.templateId.moduleName}:${row.templateId.entityName}` === legacyTemplate.equals);
         return rows;
     }
     unsupported(operation) {
@@ -99,7 +104,7 @@ export class GrpcContractQueryClient {
 function hasUnsupportedFilter(where) {
     if (where === undefined)
         return false;
-    if ("and" in where || "or" in where || "not" in where || "payload" in where || "createdEventOffset" in where || "createdAt" in where || "archivedEventOffset" in where || "archivedAt" in where)
+    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];
@@ -115,7 +120,7 @@ function mapGrpcContract(value) {
         contractId: row.contractId ?? "",
         templateId: { packageId: template?.packageId ?? "", moduleName: template?.moduleName ?? "", entityName: template?.entityName ?? "" },
         packageId: null,
-        payload: undefined,
+        payload: row.payload,
         witnesses: [],
         createdEventOffset: "",
         createdAt: null,
@@ -124,3 +129,24 @@ function mapGrpcContract(value) {
         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; 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);
+} if (filter.lt !== undefined)
+    return value < String(filter.lt); if (filter.lte !== undefined)
+    return value <= String(filter.lte); if (filter.gt !== undefined)
+    return value > String(filter.gt); return value >= String(filter.gte); }

package/dist/query/model-types.d.ts

@@ -106,9 +106,14 @@ type PayloadValueFilter = {
     readonly gte?: never;
     readonly like?: never;
 };
-export type ContractPayloadFilter = {
+export type PayloadMatch = {
+    readonly [field: string]: PayloadMatch | PayloadValueFilter;
+};
+export type ContractPayloadFilter = ({
     readonly path: string;
-} & PayloadValueFilter;
+} & PayloadValueFilter) | {
+    readonly match: PayloadMatch;
+};
 type ContractWhereFields = {
     readonly contractId?: StringFilter;
     readonly templateId?: Partial<{

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

@@ -72,18 +72,30 @@ function compileWhere(where, addValue) {
         }
         if (key === "payload") {
             const payload = value;
-            const path = payload.path;
-            if (typeof path !== "string" || path.split(".").some((x) => x.length === 0))
-                throw new Error("payload path must contain non-empty segments");
-            const ops = ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].filter((op) => payload[op] !== undefined);
-            if (ops.length !== 1 || typeof payload[ops[0]] !== "string")
-                throw new Error("payload requires exactly one string predicate");
-            const op = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[ops[0]];
-            parts.push(`contract_row.payload #>> ${addValue(path.split("."))}::text[] ${op} ${addValue(payload[ops[0]])}`);
+            const compilePayload = (path, filter) => { const ops = ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].filter((op) => filter[op] !== undefined); if (ops.length === 1) {
+                const op = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[ops[0]];
+                parts.push(`contract_row.payload #>> ${addValue(path)}::text[] ${op} ${addValue(filter[ops[0]])}`);
+                return;
+            } for (const [name, child] of Object.entries(filter))
+                compilePayload([...path, name], child); };
+            if (payload.match !== undefined) {
+                compilePayload([], payload.match);
+            }
+            else {
+                const path = payload.path;
+                if (typeof path !== "string" || path.split(".").some((x) => x.length === 0))
+                    throw new Error("payload path must contain non-empty segments");
+                compilePayload(path.split("."), payload);
+            }
             continue;
         }
         if (key === "templateId") {
             const fields = { packageId: "contract_row.creation_package_id", moduleName: "contract_tpe_row.module_name", entityName: "contract_tpe_row.entity_name" };
+            const legacy = value;
+            if (typeof legacy.equals === "string") {
+                parts.push(`(contract_row.creation_package_id || ':' || contract_tpe_row.module_name || ':' || contract_tpe_row.entity_name) = ${addValue(legacy.equals)}`);
+                continue;
+            }
             for (const [name, filter] of Object.entries(value))
                 for (const [op, operand] of Object.entries(filter)) {
                     const sql = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[op];

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

@@ -3,9 +3,13 @@ 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 | 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

@@ -3,6 +3,8 @@ 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: {
@@ -10,4 +12,6 @@ export declare class CommandSubmissionPipeline {
         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

@@ -85,6 +85,8 @@ import { TopologyListVettedPackagesRequest } from "../../core/types/requests/top
 import { TrafficControlStateRequest } from "../../core/types/requests/traffic-control-state-request.js";
 import { UploadDarFileRequest } from "../../core/types/requests/upload-dar-file-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";
 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";
@@ -276,6 +278,8 @@ export declare class GrpcTransport implements ITransport {
     getUpdatesPageAsync(request: GetUpdatesPageRequest, options?: RequestOptions): Promise<GetUpdatesPageResponse>;
     getCompletionsAsync(request: GetCompletionsRequest, observer: CompletionObserver, options?: RequestOptions): Promise<void>;
     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";
@@ -616,6 +617,22 @@ export class GrpcTransport {
         }), 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/package.json

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