Merge pull request #7175 from BitGo/COIN-5917

feat(sdk-coin-canton): added wallet initialization builder class

Author: ravibitgo

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

@@ -9,3 +9,6 @@ export const SigningKeySpec = {
 export const SigningAlgorithmSpec = {
   ED25519: 1,
 };
+
+export const PUBLIC_KEY_FORMAT = 'CRYPTO_KEY_FORMAT_RAW';
+export const PUBLIC_KEY_SPEC = 'SIGNING_KEY_SPEC_EC_CURVE25519';

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

@@ -17,9 +17,10 @@ export interface PreparedTxnParsedInfo {
   amount: string;
 }
 
-export interface WalletInitializationDataTxData {
+export interface WalletInitTxData {
   id: string;
   type: TransactionType;
+  preparedParty: PreparedParty;
 }
 
 export interface CantonPrepareCommandResponse {
@@ -30,14 +31,29 @@ export interface CantonPrepareCommandResponse {
 }
 
 export interface PreparedParty {
-  partyTransactions: Uint8Array<ArrayBufferLike>[];
-  combinedHash: string;
-  txHashes: Buffer<ArrayBuffer>[];
-  namespace: string;
   partyId: string;
+  publicKeyFingerprint: string;
+  topologyTransactions: string[];
+  multiHash: string;
 }
 
 export interface PreparedTransaction {
   transaction?: DamlTransaction;
   metadata?: Metadata;
 }
+
+export interface IPublicKey {
+  format: string;
+  keyData: string;
+  keySpec: string;
+}
+
+export interface WalletInitRequest {
+  synchronizer: string;
+  partyHint: string;
+  publicKey: IPublicKey;
+  localParticipantObservationOnly: boolean;
+  otherConfirmingParticipantUids: string[];
+  confirmationThreshold: number;
+  observingParticipantUids: string[];
+}

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

@@ -2,7 +2,7 @@ import * as Utils from './utils';
 import * as Interface from './iface';
 
 export { KeyPair } from './keyPair';
-export { Transaction } from './transaction';
+export { Transaction } from './transaction/transaction';
 export { TransactionBuilder } from './transactionBuilder';
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
 

…s/sdk-coin-canton/src/lib/transaction.ts …anton/src/lib/transaction/transaction.tsmodules/sdk-coin-canton/src/lib/transaction.ts renamed to modules/sdk-coin-canton/src/lib/transaction/transaction.ts modules/sdk-coin-canton/src/lib/transaction.ts renamed to modules/sdk-coin-canton/src/lib/transaction/transaction.ts

@@ -1,7 +1,7 @@
 import { BaseKey, BaseTransaction, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { CantonPrepareCommandResponse, PreparedTxnParsedInfo, TxData } from './iface';
-import utils from './utils';
+import { CantonPrepareCommandResponse, PreparedTxnParsedInfo, TxData } from '../iface';
+import utils from '../utils';
 
 export class Transaction extends BaseTransaction {
   private _transaction: CantonPrepareCommandResponse;

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

@@ -9,7 +9,7 @@ import {
   TransactionType,
 } from '@bitgo/sdk-core';
 import BigNumber from 'bignumber.js';
-import { Transaction } from './transaction';
+import { Transaction } from './transaction/transaction';
 import utils from './utils';
 
 export abstract class TransactionBuilder extends BaseTransactionBuilder {

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

@@ -112,6 +112,35 @@ export class Utils implements BaseUtils {
     };
   }
 
+  /**
+   * Computes the topology hash from the API response of the 'create party' endpoint.
+   *
+   * @param topologyTransactions - List of base64-encoded topology transactions from the Canton API.
+   * @returns The final base64-encoded topology transaction hash.
+   */
+  computeHashFromCreatePartyResponse(topologyTransactions: string[]): string {
+    const txBuffers = topologyTransactions.map((tx) => Buffer.from(tx, 'base64'));
+    return this.computeHashFromTopologyTransaction(txBuffers);
+  }
+
+  /**
+   * Computes the final topology transaction hash for a list of prepared Canton transactions.
+   *
+   * Each transaction is first hashed with purpose `11`, then all hashes are combined and
+   * hashed again with purpose `55`, following the Canton topology hash rules.
+   *
+   * The resulting hash is encoded as a base64 string.
+   *
+   * @param {Buffer[]} preparedTransactions - An array of Canton transaction buffers.
+   * @returns {string} The final topology hash, base64-encoded.
+   */
+  private computeHashFromTopologyTransaction(preparedTransactions: Buffer[]): string {
+    const rawHashes = preparedTransactions.map((tx) => this.computeSha256CantonHash(11, tx));
+    const combinedHashes = this.computeMultiHashForTopology(rawHashes);
+    const computedHash = this.computeSha256CantonHash(55, combinedHashes);
+    return Buffer.from(computedHash, 'hex').toString('base64');
+  }
+
   /**
    * Converts a base64-encoded Ed25519 public key string into a structured signing public key object.
    * @param {String} publicKey The base64-encoded Ed25519 public key
@@ -184,6 +213,43 @@ export class Utils implements BaseUtils {
     const bytes = this.fromBase64(base64);
     return PreparedTransaction.fromBinary(bytes);
   }
+
+  /**
+   * Computes a deterministic combined hash from an array of individual Canton-style SHA-256 hashes
+   *
+   * Each hash is decoded from hex, sorted lexicographically (by hex), and prefixed with its length
+   * The final buffer includes the number of hashes followed by each (length-prefixed) hash
+   *
+   * @param {string[]} hashes - An array of Canton-prefixed SHA-256 hashes in hexadecimal string format
+   * @returns {Buffer} A binary buffer representing the combined hash input
+   */
+  private computeMultiHashForTopology(hashes: string[]): Buffer {
+    const sortedHashes = hashes
+      .map((hex) => Buffer.from(hex, 'hex'))
+      .sort((a, b) => a.toString('hex').localeCompare(b.toString('hex')));
+
+    const numHashesBytes = this.encodeInt32(sortedHashes.length);
+    const parts: Buffer[] = [numHashesBytes];
+
+    for (const h of sortedHashes) {
+      const lengthBytes = this.encodeInt32(h.length);
+      parts.push(lengthBytes, h);
+    }
+
+    return Buffer.concat(parts);
+  }
+
+  /**
+   * Encodes a 32-bit signed integer into a 4-byte big-endian Buffer
+   *
+   * @param {number} value - The integer to encode
+   * @returns {Buffer} A 4-byte buffer representing the integer in big-endian format
+   */
+  private encodeInt32(value: number): Buffer {
+    const buf = Buffer.alloc(4);
+    buf.writeInt32BE(value, 0);
+    return buf;
+  }
 }
 
 const utils = new Utils();