feat(sdk-coin-canton): added message signing builders for canton

Ticket: CHALO-545

Author: ravibitgo

modules/account-lib/src/index.ts

@@ -347,6 +347,8 @@ const coinMessageBuilderFactoryMap = {
   tada: Ada.MessageBuilderFactory,
   sol: Sol.MessageBuilderFactory,
   tsol: Sol.MessageBuilderFactory,
+  canton: Canton.MessageBuilderFactory,
+  tcanton: Canton.MessageBuilderFactory,
 };
 
 coins

modules/sdk-coin-canton/src/canton.ts

@@ -93,6 +93,11 @@ export class Canton extends BaseCoin {
     return true;
   }
 
+  /** @inheritDoc */
+  supportsMessageSigning(): boolean {
+    return true;
+  }
+
   /** inherited doc */
   getDefaultMultisigType(): MultisigType {
     return multisigTypes.tss;

modules/sdk-coin-canton/src/lib/clearSigning.ts

@@ -0,0 +1,86 @@
+import { MessageStandardType } from '@bitgo/sdk-core';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore – JS resource with hand-written .d.ts
+import { PreparedTransaction } from '../../resources/proto/preparedTransaction.js';
+import utils from './utils';
+
+/**
+ * Clear signing and payload-type detection for Canton message signing requests.
+ *
+ * The Canton Signing Driver receives raw `tx` bytes and a `txHash` from the
+ * Canton Gateway's signTransaction() call. It does not know whether `tx` is a
+ * Daml prepared transaction or a topology transaction. This module owns that
+ * detection, keeping Canton-specific proto knowledge inside sdk-coin-canton.
+ *
+ * Usage in wallet-platform (buildUnsignedMsgWithIntent):
+ *   1. Call detectCantonSigningPayloadType(tx) → MessageStandardType
+ *   2. Use that type as messageStandardType in the msgrequest
+ *   3. In getHsmPayload, key off the type to choose Format 1 vs Format 2
+ */
+
+export interface DecodedCantonTransaction {
+  /** 'CreateCommand' or 'ExerciseCommand' */
+  kind: string;
+  /** Fully-qualified Daml template identifier */
+  templateId: {
+    packageId: string;
+    moduleName: string;
+    entityName: string;
+  };
+  /** Decoded Daml arguments (create arguments or choice arguments) */
+  argument: unknown;
+  /** Choice name — present for ExerciseCommand only */
+  choice?: string;
+  /** Contract ID being exercised — present for ExerciseCommand only */
+  contractId?: string;
+  /** Parties acting on this command — present for ExerciseCommand only */
+  actingParties?: string[];
+}
+
+/**
+ * Detect whether a Canton `tx` payload (base64) is a Daml prepared transaction
+ * or a topology transaction, by attempting to parse as PreparedTransaction proto.
+ *
+ * - PreparedTransaction → has `transaction.nodes` populated → CANTON_SIGN_TRANSACTION
+ * - Topology bytes     → parsing fails or nodes empty      → CANTON_SIGN_TOPOLOGY
+ *
+ * wallet-platform calls this on the raw `tx` bytes from the Canton Gateway to
+ * determine which MessageStandardType to use and which HSM payload format to apply.
+ *
+ * @param txBase64 - base64-encoded `tx` bytes from Canton's signTransaction request
+ * @returns The appropriate MessageStandardType for this payload
+ */
+export function detectCantonSigningPayloadType(txBase64: string): MessageStandardType {
+  try {
+    const bytes = Buffer.from(txBase64, 'base64');
+    const decoded = PreparedTransaction.fromBinary(bytes);
+    if (decoded.transaction && Array.isArray(decoded.transaction.nodes) && decoded.transaction.nodes.length > 0) {
+      return MessageStandardType.CANTON_SIGN_TRANSACTION;
+    }
+  } catch {
+    // bytes did not parse as a PreparedTransaction proto
+  }
+  return MessageStandardType.CANTON_SIGN_TOPOLOGY;
+}
+
+/**
+ * Decode a Canton prepared transaction into a human-readable structure
+ * suitable for storage as a clearSigningPayload on the txRequest message.
+ *
+ * Only meaningful when detectCantonSigningPayloadType() returns CANTON_SIGN_TRANSACTION.
+ * For topology transactions, there is no Daml command structure to decode.
+ *
+ * @param preparedTransactionBase64 - base64-encoded protobuf bytes from the Canton signTransaction request
+ * @returns Decoded command info describing the Daml operation being signed
+ */
+export function decodePreparedTransaction(preparedTransactionBase64: string): DecodedCantonTransaction {
+  const info = utils.extractCantonCommandInfo(preparedTransactionBase64);
+  return {
+    kind: info.kind,
+    templateId: info.templateId,
+    argument: info.argument,
+    ...(info.choice !== undefined && { choice: info.choice }),
+    ...(info.contractId !== undefined && { contractId: info.contractId }),
+    ...(info.actingParties !== undefined && { actingParties: info.actingParties }),
+  };
+}

modules/sdk-coin-canton/src/lib/index.ts

@@ -20,3 +20,5 @@ export { WalletInitBuilder } from './walletInitBuilder';
 export { WalletInitTransaction } from './walletInitialization/walletInitTransaction';
 
 export { Utils, Interface };
+export * from './messages';
+export * from './clearSigning';

modules/sdk-coin-canton/src/lib/messages/cantonSignTopology/cantonSignTopologyMessage.ts

@@ -0,0 +1,37 @@
+import { BaseMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
+
+/**
+ * Implementation of Canton sign-topology message.
+ *
+ * Used when the Canton Gateway requests signing of a topology transaction —
+ * for example, when a party is being hosted on an external validator and
+ * delegates signing to BitGo (party hosting / onboarding flow).
+ *
+ * The payload is the base64-encoded txHash. The signable payload is the
+ * decoded raw bytes of that hash, which is what the TSS signer signs.
+ *
+ * The CANTON_SIGN_TOPOLOGY type is the discriminator wallet-platform uses to
+ * apply the topology HSM payload format (Format 1):
+ *   [txnType (4B LE)] || itemCount (4B LE) || [len || topoTxBytes]... || signableHex
+ *
+ * This differs from CANTON_SIGN_TRANSACTION which uses the prepared-transaction
+ * format (Format 2):
+ *   itemCount=2 (4B LE) || len (4B LE) || preparedTxBinary || signableHex
+ */
+export class CantonSignTopologyMessage extends BaseMessage {
+  constructor(options: MessageOptions) {
+    super({
+      ...options,
+      type: MessageStandardType.CANTON_SIGN_TOPOLOGY,
+    });
+  }
+
+  async getSignablePayload(): Promise<string | Buffer> {
+    if (!this.payload) {
+      throw new Error('Message payload is missing');
+    }
+    // txHash arrives as a base64 string; decode to raw bytes for signing
+    this.signablePayload = Buffer.from(this.payload, 'base64');
+    return this.signablePayload;
+  }
+}

modules/sdk-coin-canton/src/lib/messages/cantonSignTopology/cantonSignTopologyMessageBuilder.ts

@@ -0,0 +1,23 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
+import { CantonSignTopologyMessage } from './cantonSignTopologyMessage';
+
+/**
+ * Builder for Canton sign-topology messages.
+ *
+ * The payload should be the base64-encoded txHash from Canton's signTransaction
+ * call when it is requesting a topology transaction to be signed (e.g. party
+ * hosting on an external validator).
+ *
+ * wallet-platform uses the CANTON_SIGN_TOPOLOGY type to apply HSM payload
+ * Format 1 (topology framing) rather than Format 2 (prepared-transaction framing).
+ */
+export class CantonSignTopologyMessageBuilder extends BaseMessageBuilder {
+  public constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig, MessageStandardType.CANTON_SIGN_TOPOLOGY);
+  }
+
+  public async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new CantonSignTopologyMessage(options);
+  }
+}

modules/sdk-coin-canton/src/lib/messages/cantonSignTopology/index.ts

@@ -0,0 +1,2 @@
+export * from './cantonSignTopologyMessage';
+export * from './cantonSignTopologyMessageBuilder';

modules/sdk-coin-canton/src/lib/messages/cantonSignTransaction/cantonSignTransactionMessage.ts

@@ -0,0 +1,26 @@
+import { BaseMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
+
+/**
+ * Implementation of Canton sign-transaction message.
+ *
+ * The payload is the base64-encoded txHash sent by the Canton network's
+ * signTransaction RPC. The signable payload is the decoded raw bytes of
+ * that hash — i.e. what the TSS signer actually signs.
+ */
+export class CantonSignTransactionMessage extends BaseMessage {
+  constructor(options: MessageOptions) {
+    super({
+      ...options,
+      type: MessageStandardType.CANTON_SIGN_TRANSACTION,
+    });
+  }
+
+  async getSignablePayload(): Promise<string | Buffer> {
+    if (!this.payload) {
+      throw new Error('Message payload is missing');
+    }
+    // txHash arrives as a base64 string; decode to raw bytes for signing
+    this.signablePayload = Buffer.from(this.payload, 'base64');
+    return this.signablePayload;
+  }
+}

modules/sdk-coin-canton/src/lib/messages/cantonSignTransaction/cantonSignTransactionMessageBuilder.ts

@@ -0,0 +1,20 @@
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseMessageBuilder, IMessage, MessageOptions, MessageStandardType } from '@bitgo/sdk-core';
+import { CantonSignTransactionMessage } from './cantonSignTransactionMessage';
+
+/**
+ * Builder for Canton sign-transaction messages.
+ *
+ * The payload should be the base64-encoded txHash from Canton's
+ * signTransaction RPC call. The builder produces a CantonSignTransactionMessage
+ * whose signable payload is the decoded raw bytes of that hash.
+ */
+export class CantonSignTransactionMessageBuilder extends BaseMessageBuilder {
+  public constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig, MessageStandardType.CANTON_SIGN_TRANSACTION);
+  }
+
+  public async buildMessage(options: MessageOptions): Promise<IMessage> {
+    return new CantonSignTransactionMessage(options);
+  }
+}

modules/sdk-coin-canton/src/lib/messages/cantonSignTransaction/index.ts

@@ -0,0 +1,2 @@
+export * from './cantonSignTransactionMessage';
+export * from './cantonSignTransactionMessageBuilder';