@layerzerolabs/common-canton 0.2.78 → 0.2.80

package/dist/transaction.d.ts

@@ -0,0 +1,318 @@
+import { z } from 'zod';
+import type { PartialBy } from '@layerzerolabs/typescript-utils';
+export declare const cantonCommandSchema: z.ZodUnion<readonly [z.ZodObject<{
+    createCommand: z.ZodObject<{
+        templateId: z.ZodString;
+        createArguments: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    exerciseCommand: z.ZodObject<{
+        templateId: z.ZodString;
+        contractId: z.ZodString;
+        choice: z.ZodString;
+        choiceArgument: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    createAndExerciseCommand: z.ZodObject<{
+        templateId: z.ZodString;
+        createArguments: z.ZodAny;
+        choice: z.ZodString;
+        choiceArgument: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    exerciseByKeyCommand: z.ZodObject<{
+        templateId: z.ZodString;
+        contractKey: z.ZodAny;
+        choice: z.ZodString;
+        choiceArgument: z.ZodAny;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+export declare const cantonDisclosedContractSchema: z.ZodObject<{
+    templateId: z.ZodOptional<z.ZodString>;
+    contractId: z.ZodString;
+    createdEventBlob: z.ZodString;
+    synchronizerId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Canton transaction schema for Daml Ledger API commands.
+ *
+ * Canton uses an interactive submission (prepare-sign-submit) flow for external party signing.
+ * The populatedTransaction contains the commands to send to prepareForSigning.
+ */
+export declare const cantonTransactionSchema: z.ZodObject<{
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    chainName: z.ZodString;
+    timestamps: z.ZodObject<{
+        created: z.ZodNumber;
+        nonceAcquired: z.ZodOptional<z.ZodNumber>;
+        signed: z.ZodOptional<z.ZodNumber>;
+        sent: z.ZodOptional<z.ZodNumber>;
+        confirmed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodOptional<z.ZodString>;
+    parallelizingKey: z.ZodOptional<z.ZodString>;
+    populatedTransaction: z.ZodObject<{
+        actAs: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            createCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractId: z.ZodString;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            createAndExerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseByKeyCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractKey: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
+        disclosedContracts: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodOptional<z.ZodString>;
+            contractId: z.ZodString;
+            createdEventBlob: z.ZodString;
+            synchronizerId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Assigned transaction includes the inflight transaction data.
+ */
+export declare const cantonAssignedTransactionSchema: z.ZodObject<{
+    senderEntityName: z.ZodString;
+    nonce: z.ZodNumber;
+    inflightTransaction: z.ZodOptional<z.ZodObject<{
+        preparedTransaction: z.ZodString;
+        preparedTransactionHash: z.ZodString;
+        hashingSchemeVersion: z.ZodEnum<{
+            HASHING_SCHEME_VERSION_UNSPECIFIED: "HASHING_SCHEME_VERSION_UNSPECIFIED";
+            HASHING_SCHEME_VERSION_V2: "HASHING_SCHEME_VERSION_V2";
+        }>;
+        commandId: z.ZodString;
+    }, z.core.$strip>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    chainName: z.ZodString;
+    timestamps: z.ZodObject<{
+        created: z.ZodNumber;
+        nonceAcquired: z.ZodOptional<z.ZodNumber>;
+        signed: z.ZodOptional<z.ZodNumber>;
+        sent: z.ZodOptional<z.ZodNumber>;
+        confirmed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodOptional<z.ZodString>;
+    parallelizingKey: z.ZodOptional<z.ZodString>;
+    populatedTransaction: z.ZodObject<{
+        actAs: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            createCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractId: z.ZodString;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            createAndExerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseByKeyCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractKey: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
+        disclosedContracts: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodOptional<z.ZodString>;
+            contractId: z.ZodString;
+            createdEventBlob: z.ZodString;
+            synchronizerId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Signed transaction includes the DER-encoded ECDSA signature.
+ */
+export declare const cantonSignedTransactionSchema: z.ZodObject<{
+    signedTransaction: z.ZodObject<{
+        signatures: z.ZodArray<z.ZodObject<{
+            party: z.ZodString;
+            signatures: z.ZodArray<z.ZodObject<{
+                format: z.ZodString;
+                signature: z.ZodString;
+                signedBy: z.ZodString;
+                signingAlgorithmSpec: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    senderEntityName: z.ZodString;
+    nonce: z.ZodNumber;
+    inflightTransaction: z.ZodOptional<z.ZodObject<{
+        preparedTransaction: z.ZodString;
+        preparedTransactionHash: z.ZodString;
+        hashingSchemeVersion: z.ZodEnum<{
+            HASHING_SCHEME_VERSION_UNSPECIFIED: "HASHING_SCHEME_VERSION_UNSPECIFIED";
+            HASHING_SCHEME_VERSION_V2: "HASHING_SCHEME_VERSION_V2";
+        }>;
+        commandId: z.ZodString;
+    }, z.core.$strip>>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    chainName: z.ZodString;
+    timestamps: z.ZodObject<{
+        created: z.ZodNumber;
+        nonceAcquired: z.ZodOptional<z.ZodNumber>;
+        signed: z.ZodOptional<z.ZodNumber>;
+        sent: z.ZodOptional<z.ZodNumber>;
+        confirmed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodOptional<z.ZodString>;
+    parallelizingKey: z.ZodOptional<z.ZodString>;
+    populatedTransaction: z.ZodObject<{
+        actAs: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            createCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractId: z.ZodString;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            createAndExerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseByKeyCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractKey: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
+        disclosedContracts: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodOptional<z.ZodString>;
+            contractId: z.ZodString;
+            createdEventBlob: z.ZodString;
+            synchronizerId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Mined transaction with confirmation result.
+ */
+export declare const cantonMinedTransactionSchema: z.ZodObject<{
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"success">;
+        minedTxHash: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        error: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"indeterminate">;
+        meta: z.ZodAny;
+    }, z.core.$strip>], "type">;
+    inflightTransaction: z.ZodObject<{
+        preparedTransaction: z.ZodString;
+        preparedTransactionHash: z.ZodString;
+        hashingSchemeVersion: z.ZodEnum<{
+            HASHING_SCHEME_VERSION_UNSPECIFIED: "HASHING_SCHEME_VERSION_UNSPECIFIED";
+            HASHING_SCHEME_VERSION_V2: "HASHING_SCHEME_VERSION_V2";
+        }>;
+        commandId: z.ZodString;
+    }, z.core.$strip>;
+    signedTransaction: z.ZodObject<{
+        signatures: z.ZodArray<z.ZodObject<{
+            party: z.ZodString;
+            signatures: z.ZodArray<z.ZodObject<{
+                format: z.ZodString;
+                signature: z.ZodString;
+                signedBy: z.ZodString;
+                signingAlgorithmSpec: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    senderEntityName: z.ZodString;
+    nonce: z.ZodNumber;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    chainName: z.ZodString;
+    timestamps: z.ZodObject<{
+        created: z.ZodNumber;
+        nonceAcquired: z.ZodOptional<z.ZodNumber>;
+        signed: z.ZodOptional<z.ZodNumber>;
+        sent: z.ZodOptional<z.ZodNumber>;
+        confirmed: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    type: z.ZodOptional<z.ZodString>;
+    parallelizingKey: z.ZodOptional<z.ZodString>;
+    populatedTransaction: z.ZodObject<{
+        actAs: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            createCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractId: z.ZodString;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            createAndExerciseCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                createArguments: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            exerciseByKeyCommand: z.ZodObject<{
+                templateId: z.ZodString;
+                contractKey: z.ZodAny;
+                choice: z.ZodString;
+                choiceArgument: z.ZodAny;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
+        disclosedContracts: z.ZodArray<z.ZodObject<{
+            templateId: z.ZodOptional<z.ZodString>;
+            contractId: z.ZodString;
+            createdEventBlob: z.ZodString;
+            synchronizerId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CantonTx = z.infer<typeof cantonTransactionSchema>;
+export type CantonAssignedTx = z.infer<typeof cantonAssignedTransactionSchema>;
+export type CantonSignedTx = z.infer<typeof cantonSignedTransactionSchema>;
+export type CantonMinedTx = z.infer<typeof cantonMinedTransactionSchema>;
+export type BuildCantonTransactionInput = PartialBy<CantonTx, 'chainName' | 'timestamps'>;
+export declare const buildCantonTransaction: (chainName: string, tx: BuildCantonTransactionInput) => Promise<CantonTx>;
+//# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"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"}

package/dist/transaction.js

@@ -0,0 +1,4 @@
+export { buildCantonTransaction, cantonAssignedTransactionSchema, cantonCommandSchema, cantonDisclosedContractSchema, cantonMinedTransactionSchema, cantonSignedTransactionSchema, cantonTransactionSchema } from './TCJIRBMX.js';
+import './VUOMXK5T.js';
+//# sourceMappingURL=transaction.js.map
+//# sourceMappingURL=transaction.js.map

package/dist/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"transaction.js"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-canton",
-  "version": "0.2.78",
+  "version": "0.2.80",
   "private": false,
   "description": "Canton VM client and utilities",
   "license": "MIT",
@@ -20,7 +20,10 @@
     "@grpc/grpc-js": "^1.12.0",
     "@mojotech/json-type-validation": "^3.1.0",
     "@protobuf-ts/grpc-transport": "^2.9.4",
-    "es-toolkit": "^1.39.10"
+    "es-toolkit": "^1.39.10",
+    "zod": "4.3.5",
+    "@layerzerolabs/common-chain-model": "0.2.80",
+    "@layerzerolabs/typescript-utils": "0.2.80"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.28.2",
@@ -30,12 +33,12 @@
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
     "vitest": "^3.2.3",
-    "@layerzerolabs/eslint-configuration": "^0.2.78",
-    "@layerzerolabs/tsup-configuration": "0.2.78",
-    "@layerzerolabs/typescript-configuration": "0.2.78",
-    "@layerzerolabs/ver-tsup-configuration": "0.2.78",
-    "@layerzerolabs/ver-signer-adapter": "0.2.78",
-    "@layerzerolabs/ver-typescript-configuration": "0.2.78"
+    "@layerzerolabs/tsup-configuration": "0.2.80",
+    "@layerzerolabs/eslint-configuration": "^0.2.80",
+    "@layerzerolabs/typescript-configuration": "0.2.80",
+    "@layerzerolabs/ver-signer-adapter": "0.2.80",
+    "@layerzerolabs/ver-typescript-configuration": "0.2.80",
+    "@layerzerolabs/ver-tsup-configuration": "0.2.80"
   },
   "publishConfig": {
     "access": "restricted",

package/src/events.ts

@@ -0,0 +1,81 @@
+import { buildTransactionWithResultSchema } from '@layerzerolabs/common-chain-model';
+
+import type { ICantonClient } from './client';
+import type { CreatedEvent } from './open-api/models';
+import { cantonTransactionSchema } from './transaction';
+
+const cantonTxWithResultSchema = buildTransactionWithResultSchema(cantonTransactionSchema);
+
+/**
+ * Fetches a transaction by updateId and returns all CreatedEvents.
+ */
+export const fetchCreatedEvents = async (
+    client: ICantonClient,
+    updateId: string,
+    parties: string[],
+): Promise<CreatedEvent[]> => {
+    const cantonTx = await client.fetchTransactionByUpdateId(updateId, parties);
+    return (
+        cantonTx.events
+            ?.filter((event): event is { CreatedEvent: CreatedEvent } => 'CreatedEvent' in event)
+            .map((event) => event.CreatedEvent) ?? []
+    );
+};
+
+/**
+ * Finds a CreatedEvent matching the expected templateId whose signatories
+ * are a subset of the provided actAs parties.
+ */
+export const findMatchingCreatedEvent = (
+    createdEvents: CreatedEvent[],
+    expectedTemplateId: string,
+    expectedSignatories: string[],
+): CreatedEvent | undefined => {
+    const expectedSet = new Set(expectedSignatories);
+    return createdEvents.find((event) => {
+        if (event.templateId !== expectedTemplateId) return false;
+        const signatories = event.signatories ?? [];
+        return signatories.length > 0 && signatories.every((s) => expectedSet.has(s));
+    });
+};
+
+/**
+ * Parses a Canton transaction-with-result, fetches the created events from the ledger,
+ * and returns the first CreatedEvent matching the submitted command's templateId and actAs
+ * signatories. Returns null if the transaction is falsy, not successful, or has no match.
+ */
+export const findMatchingCreatedEventFromTx = async (
+    client: ICantonClient,
+    tx: unknown,
+): Promise<CreatedEvent | null> => {
+    if (!tx) return null;
+
+    const parsed = cantonTxWithResultSchema.safeParse(tx);
+    if (!parsed.success) return null;
+    if (parsed.data.result.type !== 'success') return null;
+
+    const { commands, actAs } = parsed.data.populatedTransaction;
+    const updateId = parsed.data.result.minedTxHash;
+
+    if (!updateId || !actAs.length) return null;
+
+    const createCommand = commands[0];
+    if (!createCommand || !('createCommand' in createCommand)) return null;
+
+    const createdEvents = await fetchCreatedEvents(client, updateId, actAs);
+    return (
+        findMatchingCreatedEvent(createdEvents, createCommand.createCommand.templateId, actAs) ??
+        null
+    );
+};
+
+/**
+ * Checks that a Canton deploy transaction resulted in a CreatedEvent
+ * matching the submitted command's templateId and actAs signatories.
+ */
+export const cantonDeploymentSucceeded = async (
+    client: ICantonClient,
+    txWithResult: unknown,
+): Promise<boolean> => {
+    return (await findMatchingCreatedEventFromTx(client, txWithResult)) != null;
+};

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './auth';
+export * from './events';
 export * from './provider';
+export * from './transaction';
 
 // Core types
 export {

package/src/transaction.ts

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+
+import {
+    assignedTransactionSchema,
+    minedTransactionSchema,
+    signedTransactionSchema,
+    transactionSchema,
+} from '@layerzerolabs/common-chain-model';
+import type { PartialBy } from '@layerzerolabs/typescript-utils';
+
+// ─── Daml Command Schemas ────────────────────────────────────────────────────
+// Mirrors the OpenAPI-generated Command union (Command = CommandOneOf | ... | CommandOneOf3).
+// Payload fields (createArguments, choiceArgument, contractKey) are z.any() because
+// they carry arbitrary Daml values whose shape depends on the template.
+
+const createCommandSchema = z.object({
+    templateId: z.string(),
+    createArguments: z.any(),
+});
+
+const exerciseCommandSchema = z.object({
+    templateId: z.string(),
+    contractId: z.string(),
+    choice: z.string(),
+    choiceArgument: z.any(),
+});
+
+const createAndExerciseCommandSchema = z.object({
+    templateId: z.string(),
+    createArguments: z.any(),
+    choice: z.string(),
+    choiceArgument: z.any(),
+});
+
+const exerciseByKeyCommandSchema = z.object({
+    templateId: z.string(),
+    contractKey: z.any(),
+    choice: z.string(),
+    choiceArgument: z.any(),
+});
+
+export const cantonCommandSchema = z.union([
+    z.object({ createCommand: createCommandSchema }),
+    z.object({ exerciseCommand: exerciseCommandSchema }),
+    z.object({ createAndExerciseCommand: createAndExerciseCommandSchema }),
+    z.object({ exerciseByKeyCommand: exerciseByKeyCommandSchema }),
+]);
+
+// ─── Disclosed Contract Schema ───────────────────────────────────────────────
+
+export const cantonDisclosedContractSchema = z.object({
+    templateId: z.string().optional(),
+    contractId: z.string(),
+    createdEventBlob: z.string(),
+    synchronizerId: z.string(),
+});
+
+// ─── Transaction Schemas ─────────────────────────────────────────────────────
+
+/**
+ * Canton transaction schema for Daml Ledger API commands.
+ *
+ * Canton uses an interactive submission (prepare-sign-submit) flow for external party signing.
+ * The populatedTransaction contains the commands to send to prepareForSigning.
+ */
+export const cantonTransactionSchema = transactionSchema.extend({
+    populatedTransaction: z.object({
+        /** Parties submitting the command (actAs) */
+        actAs: z.array(z.string()),
+        /** Daml commands to send to prepareForSigning */
+        commands: z.array(cantonCommandSchema),
+        /** Disclosed contracts for contract/key lookups */
+        disclosedContracts: z.array(cantonDisclosedContractSchema),
+    }),
+});
+
+/** Output of prepareForSigning — needed by submitSigned to execute the transaction. */
+const _cantonInflightTransactionSchema = z.object({
+    /** The prepared transaction blob */
+    preparedTransaction: z.string(),
+    /** Hash of the prepared transaction (what was signed) */
+    preparedTransactionHash: z.string(),
+    /** Hashing scheme version used */
+    hashingSchemeVersion: z.enum([
+        'HASHING_SCHEME_VERSION_UNSPECIFIED',
+        'HASHING_SCHEME_VERSION_V2',
+    ]),
+    /** Command ID for tracking */
+    commandId: z.string(),
+});
+
+/**
+ * Assigned transaction includes the inflight transaction data.
+ */
+export const cantonAssignedTransactionSchema = assignedTransactionSchema.extend({
+    ...cantonTransactionSchema.shape,
+    inflightTransaction: _cantonInflightTransactionSchema.optional(),
+});
+
+/**
+ * Signed transaction includes the DER-encoded ECDSA signature.
+ */
+export const cantonSignedTransactionSchema = signedTransactionSchema.extend({
+    ...cantonAssignedTransactionSchema.shape,
+    signedTransaction: z.object({
+        /** Per-party signatures in the format expected by Canton's submitSigned */
+        signatures: z.array(
+            z.object({
+                party: z.string(),
+                signatures: z.array(
+                    z.object({
+                        format: z.string(),
+                        signature: z.string(),
+                        signedBy: z.string(),
+                        signingAlgorithmSpec: z.string(),
+                    }),
+                ),
+            }),
+        ),
+    }),
+});
+
+/**
+ * Mined transaction with confirmation result.
+ */
+export const cantonMinedTransactionSchema = minedTransactionSchema.extend({
+    ...cantonSignedTransactionSchema.shape,
+    inflightTransaction: _cantonInflightTransactionSchema,
+});
+
+export type CantonTx = z.infer<typeof cantonTransactionSchema>;
+export type CantonAssignedTx = z.infer<typeof cantonAssignedTransactionSchema>;
+export type CantonSignedTx = z.infer<typeof cantonSignedTransactionSchema>;
+export type CantonMinedTx = z.infer<typeof cantonMinedTransactionSchema>;
+
+export type BuildCantonTransactionInput = PartialBy<CantonTx, 'chainName' | 'timestamps'>;
+
+export const buildCantonTransaction = async (
+    chainName: string,
+    tx: BuildCantonTransactionInput,
+): Promise<CantonTx> => {
+    return {
+        ...tx,
+        chainName,
+        timestamps: {
+            created: tx.timestamps?.created ?? Date.now(),
+        },
+    };
+};