@bitgo/sdk-coin-canton 1.1.0 → 1.3.0

package/dist/src/lib/utils.d.ts

@@ -1,4 +1,5 @@
 import { BaseUtils } from '@bitgo/sdk-core';
+import { PreparedTxnParsedInfo } from './iface';
 export declare class Utils implements BaseUtils {
     /** @inheritdoc */
     isValidAddress(address: string): boolean;
@@ -12,6 +13,37 @@ export declare class Utils implements BaseUtils {
     isValidSignature(signature: string): boolean;
     /** @inheritdoc */
     isValidTransactionId(txId: string): boolean;
+    /**
+     * Method to create fingerprint (part of the canton partyId) from public key
+     * @param {String} publicKey the public key
+     * @returns {String}
+     */
+    getAddressFromPublicKey(publicKey: string): string;
+    /**
+     * Method to parse raw canton transaction & get required data
+     * @param {String} rawData base64 encoded string
+     * @returns {PreparedTxnParsedInfo}
+     */
+    parseRawCantonTransactionData(rawData: string): PreparedTxnParsedInfo;
+    /**
+     * 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;
+    /**
+     * 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;
     /**
      * Converts a base64-encoded Ed25519 public key string into a structured signing public key object.
      * @param {String} publicKey The base64-encoded Ed25519 public key
@@ -38,11 +70,36 @@ export declare class Utils implements BaseUtils {
      */
     private computeSha256CantonHash;
     /**
-     * Method to create fingerprint (part of the canton partyId) from public key
-     * @param {String} publicKey the public key
-     * @returns {String}
+     * Decodes a Base64-encoded string into a Uint8Array
+     * @param {String} b64 The Base64-encoded string
+     * @returns {Uint8Array} The decoded byte array
+     * @private
      */
-    getAddressFromPublicKey(publicKey: string): string;
+    private fromBase64;
+    /**
+     * Decodes a Base64-encoded prepared transaction into a structured object
+     * @param {String} base64 The Base64-encoded transaction data
+     * @returns {IPreparedTransaction} The decoded `IPreparedTransaction` object
+     * @private
+     */
+    private decodePreparedTransaction;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 declare const utils: Utils;
 export default utils;

package/dist/src/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAA2B,MAAM,iBAAiB,CAAC;AAIrE,qBAAa,KAAM,YAAW,SAAS;IACrC,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;;OAKG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAOnB;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAKnD;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAA2B,MAAM,iBAAiB,CAAC;AAKrE,OAAO,EAA+C,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAG7F,qBAAa,KAAM,YAAW,SAAS;IACrC,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAMlD;;;;OAIG;IACH,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB;IAyDrE;;;;;OAKG;IACH,kCAAkC,CAAC,oBAAoB,EAAE,MAAM,EAAE,GAAG,MAAM;IAK1E;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kCAAkC;IAO1C;;;;;OAKG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAOnB;;;;;;;;OAQG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAIlB;;;;;OAKG;IACH,OAAO,CAAC,yBAAyB;IAKjC;;;;;;;;OAQG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;;;;OAKG;IACH,OAAO,CAAC,WAAW;CAKpB;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -4,8 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
-const sdk_core_1 = require("@bitgo/sdk-core");
 const crypto_1 = __importDefault(require("crypto"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const preparedTransaction_js_1 = require("../../resources/proto/preparedTransaction.js");
 const constant_1 = require("./constant");
 class Utils {
     /** @inheritdoc */
@@ -32,6 +33,109 @@ class Utils {
     isValidTransactionId(txId) {
         throw new Error('Method not implemented.');
     }
+    /**
+     * Method to create fingerprint (part of the canton partyId) from public key
+     * @param {String} publicKey the public key
+     * @returns {String}
+     */
+    getAddressFromPublicKey(publicKey) {
+        const key = this.signingPublicKeyFromEd25519(publicKey);
+        const hashPurpose = 12;
+        return this.computeSha256CantonHash(hashPurpose, key.publicKey);
+    }
+    /**
+     * Method to parse raw canton transaction & get required data
+     * @param {String} rawData base64 encoded string
+     * @returns {PreparedTxnParsedInfo}
+     */
+    parseRawCantonTransactionData(rawData) {
+        const decodedData = this.decodePreparedTransaction(rawData);
+        let sender = '';
+        let receiver = '';
+        let amount = '';
+        decodedData.transaction?.nodes?.forEach((node) => {
+            const versionedNode = node.versionedNode;
+            if (!versionedNode || versionedNode.oneofKind !== 'v1')
+                return;
+            const v1Node = versionedNode.v1;
+            const nodeType = v1Node.nodeType;
+            if (nodeType.oneofKind !== 'create')
+                return;
+            const createNode = nodeType.create;
+            // Check if it's the correct template
+            const template = createNode.templateId;
+            if (template?.entityName !== 'AmuletTransferInstruction')
+                return;
+            // Now parse the 'create' argument
+            if (createNode.argument?.sum?.oneofKind !== 'record')
+                return;
+            const fields = createNode.argument?.sum?.record?.fields;
+            if (!fields)
+                return;
+            // Find the 'transfer' field
+            const transferField = fields.find((f) => f.label === 'transfer');
+            if (transferField?.value?.sum?.oneofKind !== 'record')
+                return;
+            const transferRecord = transferField?.value?.sum?.record?.fields;
+            if (!transferRecord)
+                return;
+            const getField = (fields, label) => fields.find((f) => f.label === label)?.value?.sum;
+            const senderData = getField(transferRecord, 'sender');
+            if (!senderData || senderData.oneofKind !== 'party')
+                return;
+            sender = senderData.party;
+            const receiverData = getField(transferRecord, 'receiver');
+            if (!receiverData || receiverData.oneofKind !== 'party')
+                return;
+            receiver = receiverData.party;
+            const amountData = getField(transferRecord, 'amount');
+            if (!amountData || amountData.oneofKind !== 'numeric')
+                return;
+            amount = amountData.numeric;
+        });
+        if (!sender || !receiver || !amount) {
+            const missingFields = [];
+            if (!sender)
+                missingFields.push('sender');
+            if (!receiver)
+                missingFields.push('receiver');
+            if (!amount)
+                missingFields.push('amount');
+            throw new Error(`invalid transaction data: missing ${missingFields.join(', ')}`);
+        }
+        return {
+            sender,
+            receiver,
+            amount,
+        };
+    }
+    /**
+     * 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) {
+        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.
+     */
+    computeHashFromTopologyTransaction(preparedTransactions) {
+        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
@@ -76,17 +180,58 @@ class Utils {
         return Buffer.concat([multiprefix, hash]).toString('hex');
     }
     /**
-     * Method to create fingerprint (part of the canton partyId) from public key
-     * @param {String} publicKey the public key
-     * @returns {String}
+     * Decodes a Base64-encoded string into a Uint8Array
+     * @param {String} b64 The Base64-encoded string
+     * @returns {Uint8Array} The decoded byte array
+     * @private
      */
-    getAddressFromPublicKey(publicKey) {
-        const key = this.signingPublicKeyFromEd25519(publicKey);
-        const hashPurpose = 12;
-        return this.computeSha256CantonHash(hashPurpose, key.publicKey);
+    fromBase64(b64) {
+        return new Uint8Array(Buffer.from(b64, 'base64'));
+    }
+    /**
+     * Decodes a Base64-encoded prepared transaction into a structured object
+     * @param {String} base64 The Base64-encoded transaction data
+     * @returns {IPreparedTransaction} The decoded `IPreparedTransaction` object
+     * @private
+     */
+    decodePreparedTransaction(base64) {
+        const bytes = this.fromBase64(base64);
+        return preparedTransaction_js_1.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
+     */
+    computeMultiHashForTopology(hashes) {
+        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 = [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
+     */
+    encodeInt32(value) {
+        const buf = Buffer.alloc(4);
+        buf.writeInt32BE(value, 0);
+        return buf;
     }
 }
 exports.Utils = Utils;
 const utils = new Utils();
 exports.default = utils;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from 'crypto';\n\nimport { BaseUtils, isValidEd25519PublicKey } from '@bitgo/sdk-core';\n\nimport { PreparedTransaction } from '../../resources/proto/preparedTransaction.js';\n\nimport { CryptoKeyFormat, SigningAlgorithmSpec, SigningKeySpec } from './constant';\nimport { PreparedTransaction as IPreparedTransaction, PreparedTxnParsedInfo } from './iface';\nimport { RecordField } from './resourcesInterface';\n\nexport class Utils implements BaseUtils {\n  /** @inheritdoc */\n  isValidAddress(address: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPrivateKey(key: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidPublicKey(key: string): boolean {\n    return isValidEd25519PublicKey(key);\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Method to create fingerprint (part of the canton partyId) from public key\n   * @param {String} publicKey the public key\n   * @returns {String}\n   */\n  getAddressFromPublicKey(publicKey: string): string {\n    const key = this.signingPublicKeyFromEd25519(publicKey);\n    const hashPurpose = 12;\n    return this.computeSha256CantonHash(hashPurpose, key.publicKey);\n  }\n\n  /**\n   * Method to parse raw canton transaction & get required data\n   * @param {String} rawData base64 encoded string\n   * @returns {PreparedTxnParsedInfo}\n   */\n  parseRawCantonTransactionData(rawData: string): PreparedTxnParsedInfo {\n    const decodedData = this.decodePreparedTransaction(rawData);\n    let sender = '';\n    let receiver = '';\n    let amount = '';\n    decodedData.transaction?.nodes?.forEach((node) => {\n      const versionedNode = node.versionedNode;\n      if (!versionedNode || versionedNode.oneofKind !== 'v1') return;\n\n      const v1Node = versionedNode.v1;\n      const nodeType = v1Node.nodeType;\n\n      if (nodeType.oneofKind !== 'create') return;\n\n      const createNode = nodeType.create;\n\n      // Check if it's the correct template\n      const template = createNode.templateId;\n      if (template?.entityName !== 'AmuletTransferInstruction') return;\n\n      // Now parse the 'create' argument\n      if (createNode.argument?.sum?.oneofKind !== 'record') return;\n      const fields = createNode.argument?.sum?.record?.fields;\n      if (!fields) return;\n\n      // Find the 'transfer' field\n      const transferField = fields.find((f) => f.label === 'transfer');\n      if (transferField?.value?.sum?.oneofKind !== 'record') return;\n      const transferRecord = transferField?.value?.sum?.record?.fields;\n      if (!transferRecord) return;\n\n      const getField = (fields: RecordField[], label: string) => fields.find((f) => f.label === label)?.value?.sum;\n\n      const senderData = getField(transferRecord, 'sender');\n      if (!senderData || senderData.oneofKind !== 'party') return;\n      sender = senderData.party;\n      const receiverData = getField(transferRecord, 'receiver');\n      if (!receiverData || receiverData.oneofKind !== 'party') return;\n      receiver = receiverData.party;\n      const amountData = getField(transferRecord, 'amount');\n      if (!amountData || amountData.oneofKind !== 'numeric') return;\n      amount = amountData.numeric;\n    });\n    if (!sender || !receiver || !amount) {\n      const missingFields: string[] = [];\n      if (!sender) missingFields.push('sender');\n      if (!receiver) missingFields.push('receiver');\n      if (!amount) missingFields.push('amount');\n      throw new Error(`invalid transaction data: missing ${missingFields.join(', ')}`);\n    }\n    return {\n      sender,\n      receiver,\n      amount,\n    };\n  }\n\n  /**\n   * Computes the topology hash from the API response of the 'create party' endpoint.\n   *\n   * @param topologyTransactions - List of base64-encoded topology transactions from the Canton API.\n   * @returns The final base64-encoded topology transaction hash.\n   */\n  computeHashFromCreatePartyResponse(topologyTransactions: string[]): string {\n    const txBuffers = topologyTransactions.map((tx) => Buffer.from(tx, 'base64'));\n    return this.computeHashFromTopologyTransaction(txBuffers);\n  }\n\n  /**\n   * Computes the final topology transaction hash for a list of prepared Canton transactions.\n   *\n   * Each transaction is first hashed with purpose `11`, then all hashes are combined and\n   * hashed again with purpose `55`, following the Canton topology hash rules.\n   *\n   * The resulting hash is encoded as a base64 string.\n   *\n   * @param {Buffer[]} preparedTransactions - An array of Canton transaction buffers.\n   * @returns {string} The final topology hash, base64-encoded.\n   */\n  private computeHashFromTopologyTransaction(preparedTransactions: Buffer[]): string {\n    const rawHashes = preparedTransactions.map((tx) => this.computeSha256CantonHash(11, tx));\n    const combinedHashes = this.computeMultiHashForTopology(rawHashes);\n    const computedHash = this.computeSha256CantonHash(55, combinedHashes);\n    return Buffer.from(computedHash, 'hex').toString('base64');\n  }\n\n  /**\n   * Converts a base64-encoded Ed25519 public key string into a structured signing public key object.\n   * @param {String} publicKey The base64-encoded Ed25519 public key\n   * @returns {Object} The structured signing key object formatted for use with cryptographic operations\n   * @private\n   */\n  private signingPublicKeyFromEd25519(publicKey: string): {\n    format: number;\n    publicKey: Buffer;\n    scheme: number;\n    keySpec: number;\n    usage: [];\n  } {\n    return {\n      format: CryptoKeyFormat.RAW,\n      publicKey: Buffer.from(publicKey, 'base64'),\n      scheme: SigningAlgorithmSpec.ED25519,\n      keySpec: SigningKeySpec.EC_CURVE25519,\n      usage: [],\n    };\n  }\n\n  /**\n   * Creates a buffer with a 4-byte big-endian integer prefix followed by the provided byte buffer\n   * @param {Number} value The integer to prefix, written as 4 bytes in big-endian order\n   * @param {Buffer} bytes The buffer to append after the integer prefix\n   * @returns {Buffer} The resulting buffer with the prefixed integer\n   * @private\n   */\n  private prefixedInt(value: number, bytes: Buffer): Buffer {\n    const buffer = Buffer.alloc(4 + bytes.length);\n    buffer.writeUInt32BE(value, 0);\n    Buffer.from(bytes).copy(buffer, 4);\n    return buffer;\n  }\n\n  /**\n   * Computes an SHA-256 Canton-style hash by prefixing the input with a purpose identifier,\n   * then hashing the resulting buffer and prepending a multi-prefix\n   *\n   * @param {Number} purpose A numeric identifier to prefix the hash input with\n   * @param {Buffer} bytes The buffer to be hashed\n   * @returns {String} A hexadecimal string representation of the resulting hash with multi-prefix\n   * @private\n   */\n  private computeSha256CantonHash(purpose: number, bytes: Buffer): string {\n    const hashInput = this.prefixedInt(purpose, bytes);\n    const hash = crypto.createHash('sha256').update(hashInput).digest();\n    const multiprefix = Buffer.from([0x12, 0x20]);\n    return Buffer.concat([multiprefix, hash]).toString('hex');\n  }\n\n  /**\n   * Decodes a Base64-encoded string into a Uint8Array\n   * @param {String} b64 The Base64-encoded string\n   * @returns {Uint8Array} The decoded byte array\n   * @private\n   */\n  private fromBase64(b64: string): Uint8Array {\n    return new Uint8Array(Buffer.from(b64, 'base64'));\n  }\n\n  /**\n   * Decodes a Base64-encoded prepared transaction into a structured object\n   * @param {String} base64 The Base64-encoded transaction data\n   * @returns {IPreparedTransaction} The decoded `IPreparedTransaction` object\n   * @private\n   */\n  private decodePreparedTransaction(base64: string): IPreparedTransaction {\n    const bytes = this.fromBase64(base64);\n    return PreparedTransaction.fromBinary(bytes);\n  }\n\n  /**\n   * Computes a deterministic combined hash from an array of individual Canton-style SHA-256 hashes\n   *\n   * Each hash is decoded from hex, sorted lexicographically (by hex), and prefixed with its length\n   * The final buffer includes the number of hashes followed by each (length-prefixed) hash\n   *\n   * @param {string[]} hashes - An array of Canton-prefixed SHA-256 hashes in hexadecimal string format\n   * @returns {Buffer} A binary buffer representing the combined hash input\n   */\n  private computeMultiHashForTopology(hashes: string[]): Buffer {\n    const sortedHashes = hashes\n      .map((hex) => Buffer.from(hex, 'hex'))\n      .sort((a, b) => a.toString('hex').localeCompare(b.toString('hex')));\n\n    const numHashesBytes = this.encodeInt32(sortedHashes.length);\n    const parts: Buffer[] = [numHashesBytes];\n\n    for (const h of sortedHashes) {\n      const lengthBytes = this.encodeInt32(h.length);\n      parts.push(lengthBytes, h);\n    }\n\n    return Buffer.concat(parts);\n  }\n\n  /**\n   * Encodes a 32-bit signed integer into a 4-byte big-endian Buffer\n   *\n   * @param {number} value - The integer to encode\n   * @returns {Buffer} A 4-byte buffer representing the integer in big-endian format\n   */\n  private encodeInt32(value: number): Buffer {\n    const buf = Buffer.alloc(4);\n    buf.writeInt32BE(value, 0);\n    return buf;\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

package/dist/src/lib/walletInitBuilder.d.ts

@@ -0,0 +1,107 @@
+import BigNumber from 'bignumber.js';
+import { BaseAddress, BaseKey, BaseTransactionBuilder } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { PreparedParty, WalletInitRequest } from './iface';
+import { WalletInitTransaction } from './walletInitialization/walletInitTransaction';
+export declare class WalletInitBuilder extends BaseTransactionBuilder {
+    private _transaction;
+    private _publicKey;
+    private _synchronizer;
+    private _partyHint;
+    private _localParticipantObservationOnly;
+    private _otherConfirmingParticipantUids;
+    private _confirmationThreshold;
+    private _observingParticipantUids;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    initBuilder(tx: WalletInitTransaction): void;
+    protected buildImplementation(): Promise<WalletInitTransaction>;
+    protected fromImplementation(rawTransaction: any, isFirstSigner?: boolean): WalletInitTransaction;
+    protected signImplementation(key: BaseKey): WalletInitTransaction;
+    get transaction(): WalletInitTransaction;
+    set transaction(transaction: PreparedParty);
+    validateAddress(address: BaseAddress, addressFormat?: string): void;
+    validateKey(key: BaseKey): void;
+    validateRawTransaction(rawTransaction: string[]): void;
+    validateTransaction(transaction?: WalletInitTransaction): void;
+    validateValue(value: BigNumber): void;
+    /**
+     * Sets the public key used for signing.
+     *
+     * @param key - The public key of the wallet.
+     * @returns The current builder instance for chaining.
+     * @throws Error if key is not a valid public key
+     */
+    publicKey(key: string): this;
+    /**
+     * Sets the synchronizer ID for the wallet initialization.
+     *
+     * @param id - The synchronizer identifier (must be a non-empty string).
+     * @returns The current builder instance for chaining.
+     * @throws Error if the synchronizer ID is empty.
+     */
+    synchronizer(id: string): this;
+    /**
+     * Sets the party hint (alias or name) used during wallet initialization.
+     *
+     * @param hint - A 5-character non-empty string representing the party hint.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the hint is empty or more than 5 characters long.
+     */
+    partyHint(hint: string): this;
+    /**
+     * Sets whether the local participant should be added in observation-only mode.
+     *
+     * @param flag - Boolean flag indicating observation-only status.
+     * @returns The current builder instance for chaining.
+     */
+    localParticipantObservationOnly(flag: boolean): this;
+    /**
+     * Adds a confirming participant UID to the list of other confirming participants.
+     *
+     * @param uid - A non-empty string UID of another confirming participant.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the UID is empty.
+     */
+    otherConfirmingParticipantUid(uid: string): this;
+    /**
+     * Sets the confirmation threshold for the wallet initialization.
+     *
+     * @param threshold - A positive integer indicating how many confirmations are required.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the threshold is not a positive integer.
+     */
+    confirmationThreshold(threshold: number): this;
+    /**
+     * Adds an observing participant UID to the list of observers.
+     *
+     * @param uid - A non-empty string UID of the observing participant.
+     * @returns The current builder instance for chaining.
+     * @throws Error if the UID is empty.
+     */
+    observingParticipantUid(uid: string): this;
+    /**
+     * Builds and returns the WalletInitRequest object from the builder's internal state.
+     *
+     * This method performs validation before constructing the object. If required fields are
+     * missing or invalid, it throws an error.
+     *
+     * @returns {WalletInitRequest} - A fully constructed and validated request object for wallet initialization.
+     * @throws {Error} If any required field is missing or fails validation.
+     */
+    toRequestObject(): WalletInitRequest;
+    /**
+     * Validates the internal state of the builder before building the request object.
+     *
+     * Checks for:
+     * - Presence of a synchronizer ID.
+     * - `partyHint` must not be empty and must be at most 5 characters long.
+     * - Public key must include `keyData`, `format`, and `keySpec`.
+     * - Confirmation threshold must be a positive integer.
+     * - Confirming and observing participant UID lists must be arrays.
+     *
+     * @private
+     * @throws {Error} If any required field is missing or invalid.
+     */
+    private validate;
+}
+//# sourceMappingURL=walletInitBuilder.d.ts.map

package/dist/src/lib/walletInitBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletInitBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/walletInitBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,sBAAsB,EAAyB,MAAM,iBAAiB,CAAC;AACtG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGxD,OAAO,EAAc,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAGrF,qBAAa,iBAAkB,SAAQ,sBAAsB;IAC3D,OAAO,CAAC,YAAY,CAAwB;IAE5C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,gCAAgC,CAAS;IACjD,OAAO,CAAC,+BAA+B,CAAgB;IACvD,OAAO,CAAC,sBAAsB,CAAK;IACnC,OAAO,CAAC,yBAAyB,CAAgB;gBAErC,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,WAAW,CAAC,EAAE,EAAE,qBAAqB,GAAG,IAAI;IAI5C,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAI/D,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,GAAG,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,qBAAqB;IAIjG,SAAS,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,qBAAqB;IAIjE,IAAI,WAAW,IAAI,qBAAqB,CAEvC;IAED,IAAI,WAAW,CAAC,WAAW,EAAE,aAAa,EAEzC;IAED,eAAe,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI;IAMnE,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAY/B,sBAAsB,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,IAAI;IAUtD,mBAAmB,CAAC,WAAW,CAAC,EAAE,qBAAqB,GAAG,IAAI;IAW9D,aAAa,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAIrC;;;;;;OAMG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAU5B;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAQ9B;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAY7B;;;;;OAKG;IACH,+BAA+B,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAKpD;;;;;;OAMG;IACH,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAYhD;;;;;;OAMG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQ9C;;;;;;OAMG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAY1C;;;;;;;;OAQG;IACH,eAAe,IAAI,iBAAiB;IAapC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,QAAQ;CAgBjB"}