feat: implement CB58 encoding and decoding with checksum validation in Utils class

TICKET: WIN-7747

Author: mohd-kashif

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

@@ -1,5 +1,6 @@
 import { TransferableOutput } from '@flarenetwork/flarejs';
 import { bech32 } from 'bech32';
+import bs58 from 'bs58';
 import {
   BaseUtils,
   Entry,
@@ -30,6 +31,7 @@ import {
   PADSTART_CHAR,
   HEX_RADIX,
   STRING_TYPE,
+  DECODED_BLOCK_ID_LENGTH,
 } from './constants';
 
 // Regex utility functions for hex validation
@@ -91,8 +93,7 @@ export class Utils implements BaseUtils {
     let pubBuf: Buffer;
     if (pub.length === SHORT_PUB_KEY_LENGTH) {
       try {
-        // For FlareJS, we'll need to implement CB58 decode functionality
-        pubBuf = Buffer.from(pub, HEX_ENCODING); // Temporary placeholder
+        pubBuf = this.cb58Decode(pub);
       } catch {
         return false;
       }
@@ -523,22 +524,6 @@ export class Utils implements BaseUtils {
     return parseInt(outputidx.toString(HEX_ENCODING), HEX_RADIX).toString();
   }
 
-  /**
-   * CB58 decode function - simple Base58 decode implementation
-   * @param {string} data - CB58 encoded string
-   * @returns {Buffer} decoded buffer
-   */
-  cb58Decode(data: string): Buffer {
-    // For now, use a simple hex decode as placeholder
-    // In a full implementation, this would be proper CB58 decoding
-    try {
-      return Buffer.from(data, HEX_ENCODING);
-    } catch {
-      // Fallback to buffer from string
-      return Buffer.from(data);
-    }
-  }
-
   /**
    * Convert string to bytes for FlareJS memo
    * Follows FlareJS utils.stringToBytes pattern
@@ -602,11 +587,60 @@ export class Utils implements BaseUtils {
     return memoBytes.length <= maxSize;
   }
 
+  /**
+   * Adds a checksum to a Buffer and returns the concatenated result
+   */
+  private addChecksum(buff: Buffer): Buffer {
+    const hashslice = createHash('sha256').update(buff).digest().slice(28);
+    return Buffer.concat([buff, hashslice]);
+  }
+
+  /**
+   * Validates a checksum on a Buffer and returns true if valid, false if not
+   */
+  private validateChecksum(buff: Buffer): boolean {
+    const checkslice = buff.slice(buff.length - 4);
+    const hashslice = createHash('sha256')
+      .update(buff.slice(0, buff.length - 4))
+      .digest()
+      .slice(28);
+    return checkslice.toString('hex') === hashslice.toString('hex');
+  }
+
+  /**
+   * Encodes a Buffer as a base58 string with checksum
+   */
+  public cb58Encode(bytes: Buffer): string {
+    const withChecksum = this.addChecksum(bytes);
+    return bs58.encode(withChecksum);
+  }
+
+  /**
+   * Decodes a base58 string with checksum to a Buffer
+   */
+  public cb58Decode(str: string): Buffer {
+    const decoded = bs58.decode(str);
+    if (!this.validateChecksum(Buffer.from(decoded))) {
+      throw new Error('Invalid checksum');
+    }
+    return Buffer.from(decoded.slice(0, decoded.length - 4));
+  }
+
+  /**
+   * Checks if a string is a valid CB58 (base58 with checksum) format
+   */
+  private isCB58(str: string): boolean {
+    try {
+      this.cb58Decode(str);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   isValidId(id: string): boolean {
     try {
-      // For Flare P-chain, IDs are bech32 encoded
-      const decoded = bech32.decode(id);
-      return Buffer.from(bech32.fromWords(decoded.words)).length === 36;
+      return this.isCB58(id) && this.cb58Decode(id).length === DECODED_BLOCK_ID_LENGTH;
     } catch {
       return false;
     }

modules/sdk-coin-flrp/test/resources/account.ts

@@ -8,6 +8,9 @@ export const SEED_ACCOUNT = {
     'xpub661MyMwAqRbcGPTv9byjmWXD6LF1Tph7tzWXPbmh4Wt9TTmBvwTn2pYZZeQqnBEH6cTYCQEeYLLkvs7rwDN9cAKrK91rbBs8ixs532ZDZgE',
   addressMainnet: 'P-flare1uyp5n76gjqltrddur7qlrsmt3kyh8fnrrqwtal',
   addressTestnet: 'P-costwo1uyp5n76gjqltrddur7qlrsmt3kyh8fnrmwhqk7',
+  message: 'test message',
+  signature:
+    '1692c0a25c84d389e63692ca3b7ebc89835c3b11f6e64a505ddd71664d2a3ae914e0d1be13a824ae97331805650a0631df9ae92ba133f9aa81911f3a56807ba301',
 };
 
 export const ACCOUNT_1 = {

modules/sdk-coin-flrp/test/unit/lib/utils.ts

@@ -2,6 +2,7 @@ import { coins, FlareNetwork } from '@bitgo/statics';
 import { NotImplementedError } from '@bitgo/sdk-core';
 import * as assert from 'assert';
 import { Utils } from '../../../src/lib/utils';
+import * as testData from '../../resources/account';
 
 describe('Utils', function () {
   let utils: Utils;
@@ -12,28 +13,32 @@ describe('Utils', function () {
 
   describe('includeIn', function () {
     it('should return true when all wallet addresses are in output addresses', function () {
-      const walletAddresses = ['addr1', 'addr2'];
-      const outputAddresses = ['addr1', 'addr2', 'addr3'];
+      const walletAddresses = [testData.ACCOUNT_1.addressMainnet, testData.ACCOUNT_3.address];
+      const outputAddresses = [
+        testData.ACCOUNT_1.addressMainnet,
+        testData.ACCOUNT_3.address,
+        testData.ACCOUNT_4.address,
+      ];
 
       assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), true);
     });
 
     it('should return false when not all wallet addresses are in output addresses', function () {
-      const walletAddresses = ['addr1', 'addr2'];
-      const outputAddresses = ['addr1', 'addr3'];
+      const walletAddresses = [testData.ACCOUNT_1.addressMainnet, testData.ACCOUNT_3.address];
+      const outputAddresses = [testData.ACCOUNT_3.address, testData.ACCOUNT_4.address];
 
       assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), false);
     });
 
     it('should return true for empty wallet addresses', function () {
       const walletAddresses: string[] = [];
-      const outputAddresses = ['addr1', 'addr2'];
+      const outputAddresses = [testData.ACCOUNT_1.addressMainnet, testData.ACCOUNT_3.address];
 
       assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), true);
     });
 
     it('should return false when wallet address not found in empty output addresses', function () {
-      const walletAddresses = ['addr1'];
+      const walletAddresses = [testData.ACCOUNT_1.addressMainnet];
       const outputAddresses: string[] = [];
 
       assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), false);
@@ -42,37 +47,44 @@ describe('Utils', function () {
 
   describe('isValidAddress', function () {
     it('should validate single valid Flare addresses', function () {
-      // Flare addresses start with 'flare:' or 'C-flare:'
       const validAddresses = [
-        'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
-        'C-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
+        testData.SEED_ACCOUNT.addressMainnet,
+        testData.SEED_ACCOUNT.addressTestnet,
+        testData.ACCOUNT_1.addressMainnet,
+        testData.ACCOUNT_1.addressTestnet,
       ];
 
       validAddresses.forEach((addr) => {
-        // Note: The current implementation uses regex validation
-        // This test will be updated once proper Flare address validation is implemented
         const result = utils.isValidAddress(addr);
-        // Currently returns false due to placeholder implementation
         assert.strictEqual(typeof result, 'boolean');
+        assert.strictEqual(result, true);
       });
     });
 
     it('should validate array of addresses', function () {
       const addresses = [
-        'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
-        'flare1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6f4avh',
+        testData.SEED_ACCOUNT.addressMainnet,
+        testData.SEED_ACCOUNT.addressTestnet,
+        testData.ACCOUNT_1.addressMainnet,
+        testData.ACCOUNT_1.addressTestnet,
       ];
 
       const result = utils.isValidAddress(addresses);
       assert.strictEqual(typeof result, 'boolean');
+      assert.strictEqual(result, true);
     });
 
     it('should validate addresses separated by ~', function () {
       const addressString =
-        'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh~flare1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6f4avh';
+        testData.SEED_ACCOUNT.addressTestnet +
+        '~' +
+        testData.ACCOUNT_1.addressTestnet +
+        '~' +
+        testData.ACCOUNT_4.address;
 
       const result = utils.isValidAddress(addressString);
       assert.strictEqual(typeof result, 'boolean');
+      assert.strictEqual(result, true);
     });
 
     it('should reject obviously invalid addresses', function () {
@@ -86,17 +98,18 @@ describe('Utils', function () {
 
       invalidAddresses.forEach((addr) => {
         const result = utils.isValidAddress(addr);
-        // Current implementation may not catch all invalid addresses
         assert.strictEqual(typeof result, 'boolean');
+        assert.strictEqual(result, false);
       });
     });
   });
 
   describe('isValidAddressRegex', function () {
     it('should test address format with regex', function () {
-      const testAddress = 'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';
+      const testAddress = testData.SEED_ACCOUNT.addressTestnet;
       const result = utils['isValidAddressRegex'](testAddress);
       assert.strictEqual(typeof result, 'boolean');
+      assert.strictEqual(result, true);
     });
 
     it('should reject empty strings', function () {
@@ -108,9 +121,9 @@ describe('Utils', function () {
   describe('isValidTransactionId', function () {
     it('should return true for valid transaction IDs', function () {
       const validTxIds = [
-        'UALK7W31ohV7z4sQ3W6XFasTQQZUDdHMp3ZsXkou3Zdu2EKgn',
-        '2fRj2y8SEv85VXRBfVYv9Uw8UDr1vEdrxFk9rBF5jU9fj3XaeP',
-        '21W2bYubjrBdZe8taKvC2KDGJutAdgyFbVgzJ9C9ygm4SjGcWz',
+        '6wewzpFrTDPGmFfRJoT9YyGVxsRDxQXu6pz6LSXLf2eU6StBe',
+        '3SuMRBREQwhsR1qQYjSpHPNgwV7keXQbKBgP8jULnKdz7ppEV',
+        '2ExGh7o1c4gQtQrzDt2BvJxg42FswGWaLY7NEXCqcejPxjSTij',
       ];
 
       validTxIds.forEach((txId) => {
@@ -138,9 +151,9 @@ describe('Utils', function () {
   describe('isValidBlockId', function () {
     it('should return true for valid block IDs', function () {
       const validTxIds = [
-        '2nf4RxA6mHVTEgfzUdGsS1XAoPbsz817fWKyVFwN8Hh3C41XuX',
-        '22Dvn8QXXRc8FwZ5ke4X4BLTFhSbyDXC4HpNJGk9snmD1Bu6n3',
-        '2uTF5zFSHTGWNdMBKe1AWjNojGY7sxdssqR9gxAZAJYf9PxNrd',
+        'mg3B2HsQ8Pqe63J2arXi6uD3wGJV1fgCNe5bRufDToAgVRVBp',
+        'rVWodN2iTugUMckkgf8ntXcoyuduey24ZgXCMi66mrFegcV4R',
+        '2MrU9G74ra9QX99wQRxvKrbzV93i6Ua7KgHMETVMSYoJq2tb5g',
       ];
 
       validTxIds.forEach((txId) => {
@@ -178,20 +191,20 @@ describe('Utils', function () {
   describe('createSignature', function () {
     it('should create signature using secp256k1', function () {
       const network = coins.get('flrp').network as FlareNetwork;
-      const message = Buffer.from('hello world', 'utf8');
-      const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
+      const message = Buffer.from(testData.SEED_ACCOUNT.message, 'utf8');
+      const privateKey = Buffer.from(testData.SEED_ACCOUNT.privateKey, 'hex');
 
-      const signature = utils.createSignature(network, message, privateKey);
+      const signature = utils.createSignature(network, message, privateKey).toString('hex');
 
-      assert.ok(signature instanceof Buffer);
       assert.ok(signature.length > 0);
+      assert.strictEqual(signature, testData.SEED_ACCOUNT.signature);
     });
 
     it('should create different signatures for different messages', function () {
       const network = coins.get('flrp').network as FlareNetwork;
       const message1 = Buffer.from('message 1', 'utf8');
       const message2 = Buffer.from('message 2', 'utf8');
-      const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
+      const privateKey = Buffer.from(testData.SEED_ACCOUNT.privateKey, 'hex');
 
       const sig1 = utils.createSignature(network, message1, privateKey);
       const sig2 = utils.createSignature(network, message2, privateKey);
@@ -211,23 +224,23 @@ describe('Utils', function () {
   describe('verifySignature', function () {
     it('should verify valid signature', function () {
       const network = coins.get('flrp').network as FlareNetwork;
-      const message = Buffer.from('hello world', 'utf8');
-      const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
+      const message = Buffer.from(testData.SEED_ACCOUNT.message, 'utf8');
+      const privateKey = Buffer.from(testData.SEED_ACCOUNT.privateKey, 'hex');
 
       // Create signature
       const signature = utils.createSignature(network, message, privateKey);
 
       // Get public key (this would normally come from the private key)
       // For testing, we'll use a mock public key approach
-      const publicKey = Buffer.from('02' + '0'.repeat(62), 'hex'); // Compressed public key format
+      const publicKey = Buffer.from(testData.SEED_ACCOUNT.publicKey, 'hex'); // Compressed public key format
 
       // Note: This test may fail if the public key doesn't match the private key
       // In a real implementation, you'd derive the public key from the private key
       // The method returns false when verification fails instead of throwing
       const isValid = utils.verifySignature(network, message, signature, publicKey);
       assert.strictEqual(typeof isValid, 'boolean');
       // With mock public key, this should return false
-      assert.strictEqual(isValid, false);
+      assert.strictEqual(isValid, true);
     });
 
     it('should return false for invalid signature', function () {