@distrohelena/canton-typescript-sdk 0.1.9 → 0.1.12

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

@@ -188,6 +188,7 @@ import { TransactionObserver } from "../../services/events/transaction-observer.
 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 { SubmitCommandTransactionResponse } from "../types/responses/submit-command-transaction-response.js";
 import { RequestOptions } from "../types/request-options.js";
 import { SubmitCommandRequest } from "../types/requests/submit-command-request.js";
 export interface ITransport {
@@ -383,6 +384,7 @@ export interface ITransport {
      * Supported on JSON and gRPC. External signing is gRPC-only.
      */
     submitCommandAsync(request: SubmitCommandRequest, signer?: ICommandSigner | CommandSigners, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitCommandForTransactionAsync?(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
     prepareCommandAsync?(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executePreparedCommandAndWaitAsync?(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
 }

package/dist/core/types/daml-contract-id.d.ts

@@ -0,0 +1,5 @@
+/** Explicit DAML contract-id value, distinguished from ordinary text. */
+export declare class DamlContractId {
+    readonly value: string;
+    constructor(value: string);
+}

package/dist/core/types/daml-contract-id.js

@@ -0,0 +1,11 @@
+import { ValidationError } from "../errors/validation-error.js";
+/** Explicit DAML contract-id value, distinguished from ordinary text. */
+export class DamlContractId {
+    value;
+    constructor(value) {
+        if (value.length === 0) {
+            throw new ValidationError("DAML contract ids must not be empty");
+        }
+        this.value = value;
+    }
+}

package/dist/core/types/daml-values.d.ts

@@ -0,0 +1,35 @@
+import { TemplateId } from "../../query/model-types.js";
+export declare class DamlUnit {
+}
+export declare class DamlDate {
+    readonly daysSinceEpoch: number;
+    constructor(daysSinceEpoch: number);
+}
+export declare class DamlTimestamp {
+    readonly microsecondsSinceEpoch: string;
+    constructor(microsecondsSinceEpoch: string);
+}
+export declare class DamlTextMap {
+    readonly entries: readonly (readonly [string, unknown])[];
+    constructor(entries: readonly (readonly [string, unknown])[]);
+}
+export declare class DamlGenMap {
+    readonly entries: readonly (readonly [unknown, unknown])[];
+    constructor(entries: readonly (readonly [unknown, unknown])[]);
+}
+export declare class DamlVariant {
+    readonly constructorName: string;
+    readonly value: unknown;
+    readonly variantId?: TemplateId | undefined;
+    constructor(constructorName: string, value: unknown, variantId?: TemplateId | undefined);
+}
+export declare class DamlEnum {
+    readonly constructorName: string;
+    readonly enumId?: TemplateId | undefined;
+    constructor(constructorName: string, enumId?: TemplateId | undefined);
+}
+export declare class DamlRecord {
+    readonly fields: Readonly<Record<string, unknown>>;
+    readonly recordId?: TemplateId | undefined;
+    constructor(fields: Readonly<Record<string, unknown>>, recordId?: TemplateId | undefined);
+}

package/dist/core/types/daml-values.js

@@ -0,0 +1,52 @@
+export class DamlUnit {
+}
+export class DamlDate {
+    daysSinceEpoch;
+    constructor(daysSinceEpoch) {
+        this.daysSinceEpoch = daysSinceEpoch;
+    }
+}
+export class DamlTimestamp {
+    microsecondsSinceEpoch;
+    constructor(microsecondsSinceEpoch) {
+        this.microsecondsSinceEpoch = microsecondsSinceEpoch;
+    }
+}
+export class DamlTextMap {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+}
+export class DamlGenMap {
+    entries;
+    constructor(entries) {
+        this.entries = entries;
+    }
+}
+export class DamlVariant {
+    constructorName;
+    value;
+    variantId;
+    constructor(constructorName, value, variantId) {
+        this.constructorName = constructorName;
+        this.value = value;
+        this.variantId = variantId;
+    }
+}
+export class DamlEnum {
+    constructorName;
+    enumId;
+    constructor(constructorName, enumId) {
+        this.constructorName = constructorName;
+        this.enumId = enumId;
+    }
+}
+export class DamlRecord {
+    fields;
+    recordId;
+    constructor(fields, recordId) {
+        this.fields = fields;
+        this.recordId = recordId;
+    }
+}

package/dist/core/types/responses/submit-command-transaction-response.d.ts

@@ -0,0 +1,7 @@
+/** Result of a gRPC command submission that waited for its transaction. */
+export declare class SubmitCommandTransactionResponse {
+    readonly transactionId: string;
+    readonly events: readonly unknown[];
+    readonly transaction: unknown;
+    constructor(transactionId: string, events: readonly unknown[], transaction: unknown);
+}

package/dist/core/types/responses/submit-command-transaction-response.js

@@ -0,0 +1,11 @@
+/** Result of a gRPC command submission that waited for its transaction. */
+export class SubmitCommandTransactionResponse {
+    transactionId;
+    events;
+    transaction;
+    constructor(transactionId, events, transaction) {
+        this.transactionId = transactionId;
+        this.events = events;
+        this.transaction = transaction;
+    }
+}

package/dist/index.d.ts

@@ -208,6 +208,9 @@ export type { ExternalPartySigner, ExternalPartySigningRequest, ExternalPartySig
 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 { DamlContractId } from "./core/types/daml-contract-id.js";
+export { DamlUnit, DamlDate, DamlTimestamp, DamlTextMap, DamlGenMap, DamlVariant, DamlEnum, DamlRecord } from "./core/types/daml-values.js";
+export { SubmitCommandTransactionResponse } from "./core/types/responses/submit-command-transaction-response.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

@@ -195,6 +195,9 @@ export { CreateExternalPartyRequest, } from "./core/types/requests/create-extern
 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 { DamlContractId } from "./core/types/daml-contract-id.js";
+export { DamlUnit, DamlDate, DamlTimestamp, DamlTextMap, DamlGenMap, DamlVariant, DamlEnum, DamlRecord } from "./core/types/daml-values.js";
+export { SubmitCommandTransactionResponse } from "./core/types/responses/submit-command-transaction-response.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 && typeof args.where.templateId.equals !== "string")) {
+            args.where?.templateId !== undefined) {
             throw new QueryCapabilityError(QuerySource.grpc, "contracts.findMany");
         }
         const findArgs = args;
@@ -57,9 +57,6 @@ export class GrpcContractQueryClient {
             : 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) {

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

@@ -109,9 +109,7 @@ type PayloadValueFilter = {
 export type PayloadMatch = {
     readonly [field: string]: PayloadMatch | PayloadValueFilter;
 };
-export type ContractPayloadFilter = ({
-    readonly path: string;
-} & PayloadValueFilter) | {
+export type ContractPayloadFilter = {
     readonly match: PayloadMatch;
 };
 type ContractWhereFields = {

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

@@ -78,24 +78,13 @@ function compileWhere(where, addValue) {
                 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);
-            }
+            if (payload.match === undefined)
+                throw new Error("payload requires match");
+            compilePayload([], payload.match);
             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,11 +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 { SubmitCommandTransactionResponse } from "../../core/types/responses/submit-command-transaction-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);
+    submitAndWaitForTransactionAsync(request: SubmitCommandRequest, 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>;

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

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

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

@@ -3,6 +3,7 @@ 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 { SubmitCommandTransactionResponse } from "../../core/types/responses/submit-command-transaction-response.js";
 import { PreparedCommandSubmission } from "../../core/types/prepared-command-submission.js";
 import { SignCommandResult } from "../../core/signing/sign-command-result.js";
 export declare class CommandSubmissionPipeline {
@@ -12,6 +13,7 @@ export declare class CommandSubmissionPipeline {
         signer?: ICommandSigner | CommandSigners;
     });
     submitAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandResponse>;
+    submitForTransactionAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<SubmitCommandTransactionResponse>;
     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,6 +12,8 @@ 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)

package/dist/transports/grpc/grpc-channel-factory.d.ts

@@ -125,6 +125,7 @@ export interface GrpcOperations {
     prepareSubmissionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     executeSubmissionAndWaitAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
     submitCommandAsync(request: unknown, options?: RequestOptions): Promise<unknown>;
+    submitCommandForTransactionAsync?(request: unknown, options?: RequestOptions): Promise<unknown>;
 }
 export interface GrpcOperationDependencies {
     versionServiceClient?: Pick<IVersionServiceClient, "getLedgerApiVersion">;
@@ -154,6 +155,6 @@ export interface GrpcOperationDependencies {
     updateServiceClient?: Pick<IUpdateServiceClient, "getUpdates" | "getUpdateByOffset" | "getUpdateById" | "getUpdateByHash" | "getUpdatesPage">;
     commandCompletionServiceClient?: Pick<ICommandCompletionServiceClient, "getCompletions">;
     interactiveSubmissionServiceClient?: Pick<IInteractiveSubmissionServiceClient, "prepareSubmission" | "executeSubmissionAndWait">;
-    commandServiceClient?: Pick<ICommandServiceClient, "submitAndWait">;
+    commandServiceClient?: Pick<ICommandServiceClient, "submitAndWait" | "submitAndWaitForTransaction">;
 }
 export declare function createGrpcOperations(options: CantonClientOptions, endpoint: string, grpcChannelSecurity: GrpcChannelSecurity, dependencies?: GrpcOperationDependencies): GrpcOperations;

package/dist/transports/grpc/grpc-channel-factory.js

@@ -463,6 +463,10 @@ export function createGrpcOperations(options, endpoint, grpcChannelSecurity, dep
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(commandServiceClient.submitAndWait(request, callOptions));
         },
+        async submitCommandForTransactionAsync(request, requestOptions) {
+            const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
+            return await unwrapUnaryResponse(commandServiceClient.submitAndWaitForTransaction(request, callOptions));
+        },
         async prepareSubmissionAsync(request, requestOptions) {
             const callOptions = await buildCallOptionsForLedgerSurfaceAsync(options, requestOptions);
             return await unwrapUnaryResponse(interactiveSubmissionServiceClient.prepareSubmission(request, callOptions));

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

@@ -278,6 +278,7 @@ 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>;
+    submitCommandForTransactionAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<import("../../core/types/responses/submit-command-transaction-response.js").SubmitCommandTransactionResponse>;
     prepareCommandAsync(request: SubmitCommandRequest, options?: RequestOptions): Promise<PreparedCommandSubmission>;
     executePreparedCommandAndWaitAsync(prepared: PreparedCommandSubmission, signatures: Readonly<Record<string, SignCommandResult>>, options?: RequestOptions): Promise<SubmitCommandResponse>;
     private throwIfDisposed;

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

@@ -11,7 +11,7 @@ import { NotSupportedError } from "../../core/errors/not-supported-error.js";
 import { TransportError } from "../../core/errors/transport-error.js";
 import { PackageFormat } from "../../core/types/package-format.js";
 import { createGrpcOperations, } from "./grpc-channel-factory.js";
-import { mapGrpcSubmitCommand, mapGrpcSubmitCommandRequest, } from "./mappers/commands-mapper.js";
+import { mapGrpcSubmitCommand, mapGrpcSubmitCommandForTransactionRequest, mapGrpcSubmitCommandTransaction, mapGrpcSubmitCommandRequest, } from "./mappers/commands-mapper.js";
 import { mapGrpcExecuteSubmissionAndWaitRequest, mapGrpcInteractiveSubmitCommand, mapGrpcPrepareSubmissionRequest, } from "./mappers/interactive-command-mapper.js";
 import { mapGrpcGetContract, mapGrpcGetContractRequest, mapGrpcQueryContracts, mapGrpcQueryContractsRequest, } from "./mappers/contracts-mapper.js";
 import { mapGrpcCompletionStreamResponse, mapGrpcGetCompletionsRequest, } from "./mappers/command-completion-mapper.js";
@@ -617,6 +617,12 @@ export class GrpcTransport {
         }), options);
         return mapGrpcInteractiveSubmitCommand(executed);
     }
+    async submitCommandForTransactionAsync(request, options) {
+        this.throwIfDisposed();
+        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));
+    }
     async prepareCommandAsync(request, options) {
         if (!this.operations.prepareSubmissionAsync)
             throw new NotSupportedError("interactive gRPC command signing is not available on this transport");

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

@@ -2,10 +2,13 @@ import { CreateCommand } from "../../../core/types/commands/create-command.js";
 import { LedgerCommand } from "../../../core/types/commands/ledger-command.js";
 import { SubmitCommandRequest } from "../../../core/types/requests/submit-command-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 } from "../generated/canton/com/daml/ledger/api/v2/command_service.js";
+import { SubmitAndWaitRequest, SubmitAndWaitResponse, SubmitAndWaitForTransactionRequest, SubmitAndWaitForTransactionResponse } from "../generated/canton/com/daml/ledger/api/v2/command_service.js";
 import { Identifier, 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 mapGrpcSubmitCommandTransaction(payload: SubmitAndWaitForTransactionResponse): SubmitCommandTransactionResponse;
 export declare function mapGrpcSubmitCommand(payload: {
     commandId?: string;
     transactionId?: string;

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

@@ -4,9 +4,12 @@ import { CreateAndExerciseCommand } from "../../../core/types/commands/create-an
 import { CreateCommand } from "../../../core/types/commands/create-command.js";
 import { DamlNumeric } from "../../../core/types/daml-numeric.js";
 import { DamlParty } from "../../../core/types/daml-party.js";
+import { DamlContractId } from "../../../core/types/daml-contract-id.js";
+import { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant } 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";
+import { SubmitCommandTransactionResponse } from "../../../core/types/responses/submit-command-transaction-response.js";
 export function mapGrpcSubmitCommandRequest(request) {
     return {
         commands: {
@@ -27,6 +30,8 @@ export function mapGrpcSubmitCommandRequest(request) {
         },
     };
 }
+export function mapGrpcSubmitCommandForTransactionRequest(request) { return { commands: mapGrpcSubmitCommandRequest(request).commands }; }
+export function mapGrpcSubmitCommandTransaction(payload) { const transaction = payload.transaction; return new SubmitCommandTransactionResponse(transaction?.updateId ?? "", transaction?.events ?? [], transaction); }
 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 } };
 }
@@ -103,6 +108,23 @@ export function mapRecord(payload) {
     };
 }
 export function mapValue(value) {
+    const identifier = (value) => ({ packageId: value.packageId, moduleName: value.moduleName, entityName: value.entityName });
+    if (value instanceof DamlUnit)
+        return { sum: { oneofKind: "unit", unit: {} } };
+    if (value instanceof DamlDate)
+        return { sum: { oneofKind: "date", date: value.daysSinceEpoch } };
+    if (value instanceof DamlTimestamp)
+        return { sum: { oneofKind: "timestamp", timestamp: value.microsecondsSinceEpoch } };
+    if (value instanceof DamlTextMap)
+        return { sum: { oneofKind: "textMap", textMap: { entries: value.entries.map(([key, item]) => ({ key, value: mapValue(item) })) } } };
+    if (value instanceof DamlGenMap)
+        return { sum: { oneofKind: "genMap", genMap: { entries: value.entries.map(([key, item]) => ({ key: mapValue(key), value: mapValue(item) })) } } };
+    if (value instanceof DamlVariant)
+        return { sum: { oneofKind: "variant", variant: { variantId: value.variantId && identifier(value.variantId), constructor: value.constructorName, value: mapValue(value.value) } } };
+    if (value instanceof DamlEnum)
+        return { sum: { oneofKind: "enum", enum: { enumId: value.enumId && identifier(value.enumId), constructor: value.constructorName } } };
+    if (value instanceof DamlRecord)
+        return { sum: { oneofKind: "record", record: { recordId: value.recordId && identifier(value.recordId), fields: mapRecord(value.fields).fields } } };
     if (value === null || value === undefined) {
         return {
             sum: {
@@ -119,6 +141,9 @@ export function mapValue(value) {
             },
         };
     }
+    else if (value instanceof DamlContractId) {
+        return { sum: { oneofKind: "contractId", contractId: value.value } };
+    }
     else if (value instanceof DamlNumeric) {
         return {
             sum: {

package/package.json

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