@bitgo-beta/sdk-coin-flrp 1.0.1-beta.36 → 1.0.1-beta.361

package/dist/test/unit/lib/utils.js

@@ -34,253 +34,585 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const statics_1 = require("@bitgo-beta/statics");
-const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const assert = __importStar(require("assert"));
 const utils_1 = require("../../../src/lib/utils");
+const account_1 = require("../../resources/account");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const exportInC_1 = require("../../resources/transactionData/exportInC");
+const importInP_1 = require("../../resources/transactionData/importInP");
+const exportInP_1 = require("../../resources/transactionData/exportInP");
+const importInC_1 = require("../../resources/transactionData/importInC");
+const lib_1 = require("../../../src/lib");
+const flarejs_1 = require("@flarenetwork/flarejs");
 describe('Utils', function () {
     let utils;
+    const network = statics_1.coins.get('flrp').network;
     beforeEach(function () {
         utils = new utils_1.Utils();
     });
     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'];
-            assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), true);
+        it('should return true when all wallet addresses are in UTXO output addresses', function () {
+            const walletAddresses = [exportInC_1.EXPORT_IN_C.pAddresses[0], exportInC_1.EXPORT_IN_C.pAddresses[1]];
+            const utxoOutputAddresses = [...exportInC_1.EXPORT_IN_C.pAddresses];
+            assert.strictEqual(utils.includeIn(walletAddresses, utxoOutputAddresses), true);
         });
-        it('should return false when not all wallet addresses are in output addresses', function () {
-            const walletAddresses = ['addr1', 'addr2'];
-            const outputAddresses = ['addr1', 'addr3'];
-            assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), false);
+        it('should return false when some wallet addresses are not in UTXO output addresses', function () {
+            const walletAddresses = [exportInC_1.EXPORT_IN_C.pAddresses[0], account_1.ACCOUNT_3.address];
+            const utxoOutputAddresses = [exportInC_1.EXPORT_IN_C.pAddresses[0], exportInC_1.EXPORT_IN_C.pAddresses[1]];
+            assert.strictEqual(utils.includeIn(walletAddresses, utxoOutputAddresses), false);
         });
         it('should return true for empty wallet addresses', function () {
             const walletAddresses = [];
-            const outputAddresses = ['addr1', 'addr2'];
-            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 outputAddresses = [];
-            assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), false);
+            const utxoOutputAddresses = [exportInC_1.EXPORT_IN_C.pAddresses[0]];
+            assert.strictEqual(utils.includeIn(walletAddresses, utxoOutputAddresses), true);
         });
     });
     describe('isValidAddress', function () {
-        it('should validate single valid Flare addresses', function () {
-            // Flare addresses start with 'flare:' or 'C-flare:'
-            const validAddresses = [
-                'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
-                'C-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
-            ];
-            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');
-            });
+        it('should return true for valid mainnet P-chain address', function () {
+            assert.strictEqual(utils.isValidAddress(account_1.SEED_ACCOUNT.addressMainnet), true);
         });
-        it('should validate array of addresses', function () {
-            const addresses = [
-                'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
-                'flare1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6f4avh',
-            ];
-            const result = utils.isValidAddress(addresses);
-            assert.strictEqual(typeof result, 'boolean');
-        });
-        it('should validate addresses separated by ~', function () {
-            const addressString = 'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh~flare1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6f4avh';
-            const result = utils.isValidAddress(addressString);
-            assert.strictEqual(typeof result, 'boolean');
-        });
-        it('should reject obviously invalid addresses', function () {
-            const invalidAddresses = [
-                '',
-                'invalid',
-                '123',
-                'bitcoin1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq',
-                'eth:0x1234567890123456789012345678901234567890',
-            ];
-            invalidAddresses.forEach((addr) => {
-                const result = utils.isValidAddress(addr);
-                // Current implementation may not catch all invalid addresses
-                assert.strictEqual(typeof result, 'boolean');
-            });
+        it('should return true for valid testnet P-chain address', function () {
+            assert.strictEqual(utils.isValidAddress(account_1.SEED_ACCOUNT.addressTestnet), true);
+        });
+        it('should return true for valid NodeID address', function () {
+            assert.strictEqual(utils.isValidAddress('NodeID-abc123xyz'), true);
+        });
+        it('should return true for array of valid addresses', function () {
+            assert.strictEqual(utils.isValidAddress(exportInC_1.EXPORT_IN_C.pAddresses), true);
+        });
+        it('should return true for tilde-separated addresses', function () {
+            const combined = exportInC_1.EXPORT_IN_C.pAddresses.join('~');
+            assert.strictEqual(utils.isValidAddress(combined), true);
+        });
+        it('should return false for invalid address format', function () {
+            assert.strictEqual(utils.isValidAddress('invalid'), false);
+        });
+        it('should return false for address without prefix', function () {
+            assert.strictEqual(utils.isValidAddress('flare1abc123'), false);
+        });
+    });
+    describe('isValidBlockId', function () {
+        it('should return true for valid 32-byte hex block ID', function () {
+            assert.strictEqual(utils.isValidBlockId(account_1.SEED_ACCOUNT.privateKey), true); // 64 hex chars = 32 bytes
+        });
+        it('should return false for invalid length block ID', function () {
+            assert.strictEqual(utils.isValidBlockId(account_1.INVALID_SHORT_KEYPAIR_KEY), false);
+        });
+        it('should return false for empty block ID', function () {
+            assert.strictEqual(utils.isValidBlockId(''), false);
         });
     });
-    describe('isValidAddressRegex', function () {
-        it('should test address format with regex', function () {
-            const testAddress = 'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';
-            const result = utils['isValidAddressRegex'](testAddress);
-            assert.strictEqual(typeof result, 'boolean');
+    describe('isValidPublicKey', function () {
+        it('should return true for valid compressed public key starting with 03', function () {
+            assert.strictEqual(utils.isValidPublicKey(account_1.SEED_ACCOUNT.publicKey), true);
         });
-        it('should reject empty strings', function () {
-            const result = utils['isValidAddressRegex']('');
-            assert.strictEqual(result, false);
+        it('should return true for valid compressed public key starting with 02', function () {
+            assert.strictEqual(utils.isValidPublicKey(account_1.ACCOUNT_1.publicKey), true);
+        });
+        it('should return true for another valid compressed public key', function () {
+            assert.strictEqual(utils.isValidPublicKey(account_1.ACCOUNT_2.publicKey), true);
+        });
+        it('should return true for valid xpub', function () {
+            assert.strictEqual(utils.isValidPublicKey(account_1.SEED_ACCOUNT.xPublicKey), true);
+        });
+        it('should return true for ACCOUNT_1 xpub', function () {
+            assert.strictEqual(utils.isValidPublicKey(account_1.ACCOUNT_1.xPublicKey), true);
+        });
+        it('should return false for invalid short public key', function () {
+            assert.strictEqual(utils.isValidPublicKey(account_1.INVALID_SHORT_KEYPAIR_KEY), false);
+        });
+        it('should return false for compressed key with wrong prefix', function () {
+            const invalidKey = '05' + account_1.SEED_ACCOUNT.privateKey;
+            assert.strictEqual(utils.isValidPublicKey(invalidKey), false);
+        });
+        it('should return false for non-hex public key', function () {
+            const invalidKey = 'zz' + account_1.SEED_ACCOUNT.privateKey;
+            assert.strictEqual(utils.isValidPublicKey(invalidKey), false);
         });
     });
-    describe('isValidTransactionId', function () {
-        it('should throw NotImplementedError', function () {
-            assert.throws(() => utils.isValidTransactionId('txid123'), sdk_core_1.NotImplementedError, 'isValidTransactionId not implemented');
+    describe('isValidPrivateKey', function () {
+        it('should return true for valid 64-char hex private key', function () {
+            assert.strictEqual(utils.isValidPrivateKey(account_1.SEED_ACCOUNT.privateKey), true);
+        });
+        it('should return true for ACCOUNT_1 private key', function () {
+            assert.strictEqual(utils.isValidPrivateKey(account_1.ACCOUNT_1.privateKey), true);
+        });
+        it('should return true for ACCOUNT_2 private key', function () {
+            assert.strictEqual(utils.isValidPrivateKey(account_1.ACCOUNT_2.privateKey), true);
+        });
+        it('should return true for valid xprv', function () {
+            assert.strictEqual(utils.isValidPrivateKey(account_1.SEED_ACCOUNT.xPrivateKey), true);
+        });
+        it('should return true for 66-char private key ending with 01', function () {
+            const extendedKey = account_1.SEED_ACCOUNT.privateKey + '01';
+            assert.strictEqual(utils.isValidPrivateKey(extendedKey), true);
+        });
+        it('should return false for 66-char private key not ending with 01', function () {
+            assert.strictEqual(utils.isValidPrivateKey(account_1.INVALID_LONG_KEYPAIR_PRV), false);
+        });
+        it('should return false for invalid short private key', function () {
+            assert.strictEqual(utils.isValidPrivateKey(account_1.INVALID_SHORT_KEYPAIR_KEY), false);
+        });
+        it('should return false for non-hex private key', function () {
+            const invalidKey = 'zz' + account_1.SEED_ACCOUNT.privateKey.slice(2);
+            assert.strictEqual(utils.isValidPrivateKey(invalidKey), false);
         });
     });
-    describe('isValidSignature', function () {
-        it('should throw NotImplementedError', function () {
-            assert.throws(() => utils.isValidSignature('signature123'), sdk_core_1.NotImplementedError, 'isValidSignature not implemented');
+    describe('allHexChars', function () {
+        it('should return true for valid private key hex', function () {
+            assert.strictEqual(utils.allHexChars(account_1.SEED_ACCOUNT.privateKey), true);
+        });
+        it('should return true for valid public key hex', function () {
+            assert.strictEqual(utils.allHexChars(account_1.SEED_ACCOUNT.publicKey), true);
+        });
+        it('should return true for hex string with 0x prefix', function () {
+            assert.strictEqual(utils.allHexChars(exportInC_1.EXPORT_IN_C.cHexAddress), true);
+        });
+        it('should return true for valid signature hex', function () {
+            assert.strictEqual(utils.allHexChars(account_1.SEED_ACCOUNT.signature), true);
+        });
+        it('should return false for non-hex characters', function () {
+            assert.strictEqual(utils.allHexChars('ghijkl'), false);
+        });
+        it('should return false for empty string', function () {
+            assert.strictEqual(utils.allHexChars(''), false);
         });
     });
-    describe('createSignature', function () {
-        it('should create signature using secp256k1', function () {
-            const network = statics_1.coins.get('flrp').network;
-            const message = Buffer.from('hello world', 'utf8');
-            const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
+    describe('createSignature and verifySignature', function () {
+        it('should create a valid 65-byte signature', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.SEED_ACCOUNT.privateKey, 'hex');
             const signature = utils.createSignature(network, message, privateKey);
             assert.ok(signature instanceof Buffer);
-            assert.ok(signature.length > 0);
-        });
-        it('should create different signatures for different messages', function () {
-            const network = statics_1.coins.get('flrp').network;
-            const message1 = Buffer.from('message 1', 'utf8');
-            const message2 = Buffer.from('message 2', 'utf8');
-            const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
-            const sig1 = utils.createSignature(network, message1, privateKey);
-            const sig2 = utils.createSignature(network, message2, privateKey);
-            assert.notDeepStrictEqual(sig1, sig2);
-        });
-        it('should throw error for invalid private key', function () {
-            const network = statics_1.coins.get('flrp').network;
-            const message = Buffer.from('hello world', 'utf8');
-            const invalidPrivateKey = Buffer.from('invalid', 'utf8');
-            assert.throws(() => utils.createSignature(network, message, invalidPrivateKey), /Failed to create signature/);
+            assert.strictEqual(signature.length, 65);
         });
-    });
-    describe('verifySignature', function () {
-        it('should verify valid signature', function () {
-            const network = statics_1.coins.get('flrp').network;
-            const message = Buffer.from('hello world', 'utf8');
-            const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
-            // Create signature
+        it('should verify a valid signature', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.SEED_ACCOUNT.privateKey, 'hex');
+            const publicKey = Buffer.from(account_1.SEED_ACCOUNT.publicKey, 'hex');
             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
-            // 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);
+            const sigOnly = signature.slice(0, 64);
+            const messageHash = utils.sha256(message);
+            const isValid = utils.verifySignature(messageHash, sigOnly, publicKey);
+            assert.strictEqual(isValid, true);
         });
         it('should return false for invalid signature', function () {
-            const network = statics_1.coins.get('flrp').network;
-            const message = Buffer.from('hello world', 'utf8');
-            const invalidSignature = Buffer.from('invalid signature', 'utf8');
-            const publicKey = Buffer.from('02' + '0'.repeat(62), 'hex');
-            // This should return false due to invalid signature format
-            // The method catches errors internally and returns false
-            const result = utils.verifySignature(network, message, invalidSignature, publicKey);
-            assert.strictEqual(result, false);
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const publicKey = Buffer.from(account_1.SEED_ACCOUNT.publicKey, 'hex');
+            const invalidSignature = Buffer.alloc(64);
+            const messageHash = utils.sha256(message);
+            const isValid = utils.verifySignature(messageHash, invalidSignature, publicKey);
+            assert.strictEqual(isValid, false);
+        });
+        it('should create signature with ACCOUNT_1 keys', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.ACCOUNT_1.privateKey, 'hex');
+            const signature = utils.createSignature(network, message, privateKey);
+            assert.ok(signature instanceof Buffer);
+            assert.strictEqual(signature.length, 65);
+        });
+    });
+    describe('createNewSig', function () {
+        it('should create a signature from valid signature hex string', function () {
+            const sig = utils.createNewSig(account_1.SEED_ACCOUNT.signature);
+            assert.ok(sig);
+        });
+        it('should create a signature from export signature hex', function () {
+            const sigHex = utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.signature[0]);
+            const sig = utils.createNewSig(sigHex);
+            assert.ok(sig);
+        });
+        it('should pad short hex strings', function () {
+            const sigHex = account_1.INVALID_SHORT_KEYPAIR_KEY;
+            const sig = utils.createNewSig(sigHex);
+            assert.ok(sig);
+        });
+    });
+    describe('createEmptySigWithAddress and getAddressFromEmptySig', function () {
+        it('should create empty signature with embedded C-chain address', function () {
+            const addressHex = utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.cHexAddress);
+            const sig = utils.createEmptySigWithAddress(addressHex);
+            assert.ok(sig);
+        });
+        it('should extract embedded address from empty signature', function () {
+            const addressHex = utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.cHexAddress).toLowerCase();
+            const sig = utils.createEmptySigWithAddress(addressHex);
+            // Get signature bytes and convert to hex
+            const sigBytes = sig.toBytes();
+            const sigHex = Buffer.from(sigBytes).toString('hex');
+            const extractedAddress = utils.getAddressFromEmptySig(sigHex);
+            assert.strictEqual(extractedAddress, addressHex);
+        });
+        it('should handle 0x prefixed address', function () {
+            const sig = utils.createEmptySigWithAddress(exportInC_1.EXPORT_IN_C.cHexAddress);
+            assert.ok(sig);
+        });
+        it('should return empty string for short signature', function () {
+            const shortSig = account_1.SEED_ACCOUNT.privateKey; // 64 chars, less than 130
+            assert.strictEqual(utils.getAddressFromEmptySig(shortSig), '');
+        });
+    });
+    describe('sha256', function () {
+        it('should compute SHA256 hash of message', function () {
+            const data = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const hash = utils.sha256(data);
+            assert.ok(hash instanceof Buffer);
+            assert.strictEqual(hash.length, 32);
+        });
+        it('should produce consistent hash for same input', function () {
+            const data = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const hash1 = utils.sha256(data);
+            const hash2 = utils.sha256(data);
+            assert.deepStrictEqual(hash1, hash2);
+        });
+        it('should produce different hash for different input', function () {
+            const data1 = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const data2 = Buffer.from(account_1.SEED_ACCOUNT.privateKey, 'utf8');
+            const hash1 = utils.sha256(data1);
+            const hash2 = utils.sha256(data2);
+            assert.notDeepStrictEqual(hash1, hash2);
+        });
+    });
+    describe('validateRawTransaction', function () {
+        it('should not throw for valid unsigned hex transaction', function () {
+            const rawTx = utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.unsignedHex);
+            assert.doesNotThrow(() => utils.validateRawTransaction(rawTx));
+        });
+        it('should not throw for valid signed hex transaction', function () {
+            const rawTx = utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.signedHex);
+            assert.doesNotThrow(() => utils.validateRawTransaction(rawTx));
+        });
+        it('should not throw for import transaction hex', function () {
+            const rawTx = utils.removeHexPrefix(importInP_1.IMPORT_IN_P.unsignedHex);
+            assert.doesNotThrow(() => utils.validateRawTransaction(rawTx));
+        });
+        it('should throw for empty transaction', function () {
+            assert.throws(() => utils.validateRawTransaction(''), /Raw transaction is empty/);
+        });
+        it('should throw for non-hex transaction', function () {
+            assert.throws(() => utils.validateRawTransaction('xyz123'), /Raw transaction is not hex string/);
+        });
+    });
+    describe('removeHexPrefix', function () {
+        it('should remove 0x prefix from C-chain address', function () {
+            assert.strictEqual(utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.cHexAddress), exportInC_1.EXPORT_IN_C.cHexAddress.slice(2));
+        });
+        it('should remove 0x prefix from unsigned hex', function () {
+            assert.strictEqual(utils.removeHexPrefix(exportInC_1.EXPORT_IN_C.unsignedHex), exportInC_1.EXPORT_IN_C.unsignedHex.slice(2));
+        });
+        it('should return string unchanged if no prefix', function () {
+            assert.strictEqual(utils.removeHexPrefix(account_1.SEED_ACCOUNT.privateKey), account_1.SEED_ACCOUNT.privateKey);
+        });
+        it('should handle empty string', function () {
+            assert.strictEqual(utils.removeHexPrefix(''), '');
         });
     });
-    describe('address parsing utilities', function () {
-        it('should handle address separator constants', function () {
-            const { ADDRESS_SEPARATOR } = require('../../../src/lib/iface');
-            assert.strictEqual(ADDRESS_SEPARATOR, '~');
+    describe('outputidxNumberToBuffer and outputidxBufferToNumber', function () {
+        it('should convert output index to buffer and back', function () {
+            const outputIdx = importInP_1.IMPORT_IN_P.outputs[0].outputidx;
+            const buffer = utils.outputidxNumberToBuffer(outputIdx);
+            const result = utils.outputidxBufferToNumber(buffer);
+            assert.strictEqual(result, outputIdx);
+        });
+        it('should handle nonce value', function () {
+            const nonceStr = exportInC_1.EXPORT_IN_C.nonce.toString();
+            const buffer = utils.outputidxNumberToBuffer(nonceStr);
+            const result = utils.outputidxBufferToNumber(buffer);
+            assert.strictEqual(result, nonceStr);
+        });
+        it('should produce 4-byte buffer', function () {
+            const buffer = utils.outputidxNumberToBuffer('255');
+            assert.strictEqual(buffer.length, 4);
+        });
+    });
+    describe('addressToString', function () {
+        it('should convert address buffer to mainnet bech32 string', function () {
+            const address = account_1.SEED_ACCOUNT.addressMainnet;
+            const addressBuffer = utils.parseAddress(address);
+            const result = utils.addressToString('flare', 'P', addressBuffer);
+            assert.ok(result.startsWith('P-'));
+            assert.ok(result.includes('flare'));
+        });
+        it('should convert address buffer to testnet bech32 string', function () {
+            const address = account_1.SEED_ACCOUNT.addressTestnet;
+            const addressBuffer = utils.parseAddress(address);
+            const result = utils.addressToString('costwo', 'P', addressBuffer);
+            assert.ok(result.startsWith('P-'));
+            assert.ok(result.includes('costwo'));
+        });
+    });
+    describe('cb58Encode and cb58Decode', function () {
+        it('should encode and decode target chain ID correctly', function () {
+            const encoded = exportInC_1.EXPORT_IN_C.targetChainId;
+            const decoded = utils.cb58Decode(encoded);
+            const reEncoded = utils.cb58Encode(decoded);
+            assert.strictEqual(reEncoded, encoded);
+        });
+        it('should encode and decode source chain ID correctly', function () {
+            const encoded = importInP_1.IMPORT_IN_P.sourceChainId;
+            const decoded = utils.cb58Decode(encoded);
+            const reEncoded = utils.cb58Encode(decoded);
+            assert.strictEqual(reEncoded, encoded);
+        });
+        it('should throw for invalid checksum', function () {
+            assert.throws(() => utils.cb58Decode('1111111111111'), /Invalid checksum/);
+        });
+    });
+    describe('parseAddress and stringToAddress', function () {
+        it('should parse hex address with 0x prefix', function () {
+            const buffer = utils.parseAddress(exportInC_1.EXPORT_IN_C.cHexAddress);
+            assert.ok(buffer instanceof Buffer);
+            assert.strictEqual(buffer.length, 20);
+        });
+        it('should parse raw hex address from outputs', function () {
+            const address = importInP_1.IMPORT_IN_P.outputs[0].addresses[0];
+            const buffer = utils.parseAddress(address);
+            assert.ok(buffer instanceof Buffer);
+            assert.strictEqual(buffer.length, 20);
         });
-        it('should handle input separator constants', function () {
-            const { INPUT_SEPARATOR } = require('../../../src/lib/iface');
-            assert.strictEqual(INPUT_SEPARATOR, ':');
+        it('should parse mainnet bech32 address', function () {
+            const buffer = utils.parseAddress(account_1.SEED_ACCOUNT.addressMainnet);
+            assert.ok(buffer instanceof Buffer);
+            assert.strictEqual(buffer.length, 20);
+        });
+        it('should parse testnet bech32 address', function () {
+            const buffer = utils.parseAddress(account_1.SEED_ACCOUNT.addressTestnet);
+            assert.ok(buffer instanceof Buffer);
+            assert.strictEqual(buffer.length, 20);
+        });
+        it('should parse P-chain addresses from export data', function () {
+            exportInC_1.EXPORT_IN_C.pAddresses.forEach((address) => {
+                const buffer = utils.parseAddress(address);
+                assert.ok(buffer instanceof Buffer);
+                assert.strictEqual(buffer.length, 20);
+            });
+        });
+        it('should throw for address without dash separator', function () {
+            assert.throws(() => utils.parseAddress('flare1abc'), /Valid address should include -/);
+        });
+        it('should throw for invalid HRP', function () {
+            assert.throws(() => utils.parseAddress('P-invalid1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq5evzmy'), /Invalid HRP/);
         });
     });
-    describe('error handling', function () {
-        it('should properly extend base utils', function () {
-            // Test that utils class exists and has expected methods
-            assert.ok('isValidAddress' in utils);
-            assert.ok('includeIn' in utils);
-            assert.ok('createSignature' in utils);
-            assert.ok('verifySignature' in utils);
-        });
-        it('should handle parsing errors gracefully', function () {
-            // Test that utils can handle malformed input without crashing
-            // Note: These may throw errors, which is acceptable behavior
-            try {
-                utils.isValidAddress(null);
-                utils.isValidAddress(undefined);
-            }
-            catch (error) {
-                // Expected behavior - utils should handle or throw meaningful errors
-                assert.ok(error instanceof Error);
-            }
+    describe('flareIdString', function () {
+        it('should create Id from private key hex string', function () {
+            const id = utils.flareIdString(account_1.SEED_ACCOUNT.privateKey);
+            assert.ok(id);
+        });
+        it('should create Id from asset ID hex', function () {
+            // Asset ID is typically 32 bytes (64 hex chars)
+            const assetIdHex = account_1.SEED_ACCOUNT.privateKey; // Using as a 32-byte hex
+            const id = utils.flareIdString(assetIdHex);
+            assert.ok(id);
         });
     });
-    describe('constants validation', function () {
-        it('should have correct constant values', function () {
-            const constants = require('../../../src/lib/constants');
-            assert.strictEqual(typeof constants.DECODED_BLOCK_ID_LENGTH, 'number');
-            assert.strictEqual(typeof constants.SHORT_PUB_KEY_LENGTH, 'number');
-            assert.strictEqual(typeof constants.COMPRESSED_PUBLIC_KEY_LENGTH, 'number');
-            assert.strictEqual(typeof constants.UNCOMPRESSED_PUBLIC_KEY_LENGTH, 'number');
-            assert.strictEqual(typeof constants.RAW_PRIVATE_KEY_LENGTH, 'number');
-            assert.strictEqual(typeof constants.SUFFIXED_PRIVATE_KEY_LENGTH, 'number');
-            assert.strictEqual(typeof constants.PRIVATE_KEY_COMPRESSED_SUFFIX, 'string');
-            assert.strictEqual(typeof constants.OUTPUT_INDEX_HEX_LENGTH, 'number');
-            assert.ok(constants.ADDRESS_REGEX instanceof RegExp);
-            assert.ok(constants.HEX_REGEX instanceof RegExp);
+    describe('recoverySignature', function () {
+        it('should recover public key from valid signature', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.SEED_ACCOUNT.privateKey, 'hex');
+            // Create signature using the same private key (createSignature hashes the message internally)
+            const signature = utils.createSignature(network, message, privateKey);
+            // Recover public key - pass the hashed message since recoverySignature expects pre-hashed
+            const messageHash = utils.sha256(message);
+            const recoveredPubKey = utils.recoverySignature(messageHash, signature);
+            assert.ok(recoveredPubKey instanceof Buffer);
+            assert.strictEqual(recoveredPubKey.length, 33); // Should be compressed public key (33 bytes)
+        });
+        it('should recover same public key for same message and signature', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.SEED_ACCOUNT.privateKey, 'hex');
+            const signature = utils.createSignature(network, message, privateKey);
+            const messageHash = utils.sha256(message);
+            const pubKey1 = utils.recoverySignature(messageHash, signature);
+            const pubKey2 = utils.recoverySignature(messageHash, signature);
+            assert.deepStrictEqual(pubKey1, pubKey2);
+        });
+        it('should recover public key that matches original key', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.SEED_ACCOUNT.privateKey, 'hex');
+            // Get original public key
+            const originalPubKey = Buffer.from(secp256k1_1.ecc.pointFromScalar(privateKey, true));
+            // Create signature and recover public key
+            const signature = utils.createSignature(network, message, privateKey);
+            const messageHash = utils.sha256(message);
+            const recoveredPubKey = utils.recoverySignature(messageHash, signature);
+            // Convert both to hex strings for comparison
+            assert.strictEqual(recoveredPubKey.toString('hex'), originalPubKey.toString('hex'));
+        });
+        it('should recover public key using ACCOUNT_1 keys', function () {
+            const message = Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8');
+            const privateKey = Buffer.from(account_1.ACCOUNT_1.privateKey, 'hex');
+            const originalPubKey = Buffer.from(secp256k1_1.ecc.pointFromScalar(privateKey, true));
+            const signature = utils.createSignature(network, message, privateKey);
+            const messageHash = utils.sha256(message);
+            const recoveredPubKey = utils.recoverySignature(messageHash, signature);
+            assert.strictEqual(recoveredPubKey.toString('hex'), originalPubKey.toString('hex'));
+        });
+        it('should throw error for invalid signature length', function () {
+            const messageHash = utils.sha256(Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8'));
+            const invalidSignature = Buffer.from(account_1.INVALID_SHORT_KEYPAIR_KEY, 'hex');
+            assert.throws(() => utils.recoverySignature(messageHash, invalidSignature), /Failed to recover signature/);
+        });
+        it('should throw error for signature with invalid recovery parameter', function () {
+            const messageHash = utils.sha256(Buffer.from(account_1.SEED_ACCOUNT.message, 'utf8'));
+            const signature = Buffer.alloc(65); // Valid length but all zeros - invalid signature
+            assert.throws(() => utils.recoverySignature(messageHash, signature), /Failed to recover signature/);
+        });
+        it('should recover signature and verify sender address from signed C-chain Export tx', async function () {
+            // Transaction from actual build response - C-chain Export tx
+            const tx = '0x0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da55524790000000000000000000000000000000000000000000000000000000000000000000000012a96025ad506b9fbb9023fbdc1665c7f7d7c923f000000000605236658734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd00000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000006052340000000000000000000000002000000037fa8c7e0c8ad9f09f9179b42b77e94a487c3df758d4ba538f772333ca7bf3668a2fe36648438c79d9b6b77b56effb860eaa430e0e30c4e392f59cd08000000010000000900000001750076e67d9720283a71c6e7a9a88ff662608fefdd3f316f1211957ca1873eee3ee4a74b468bda66176a3e5d3ab54d43a8c0be12348f251a3093c16d9db00cd001c31e9c15';
+            const expectedSenderAddress = '0x2a96025ad506b9fbb9023fbdc1665c7f7d7c923f';
+            const factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get('tflrp'));
+            const txn = (await factory.from(tx).build());
+            const signablePayload = txn.signablePayload;
+            const signatures = txn.signature;
+            const sig = Buffer.from(utils.removeHexPrefix(signatures[0]), 'hex');
+            // Recover public key from signature (signablePayload is already SHA256 hashed)
+            const recoveredPubKey = utils.recoverySignature(signablePayload, sig);
+            // Get the sender address from the transaction inputs
+            const txInputs = txn.inputs;
+            const senderAddressFromTx = txInputs[0].address.toLowerCase();
+            // Verify sender address matches expected
+            assert.strictEqual(senderAddressFromTx, expectedSenderAddress.toLowerCase(), 'Transaction sender address does not match expected');
+            // Derive address from recovered public key
+            const derivedEvmAddress = '0x' + Buffer.from(new flarejs_1.Address(flarejs_1.secp256k1.publicKeyToEthAddress(recoveredPubKey)).toBytes()).toString('hex');
+            // Verify the recovered public key matches the sender
+            assert.strictEqual(derivedEvmAddress.toLowerCase(), senderAddressFromTx, 'Recovered public key does not match sender address');
+            // Also verify signature validity
+            const sigOnly = sig.slice(0, 64);
+            const isValid = utils.verifySignature(signablePayload, sigOnly, recoveredPubKey);
+            assert.strictEqual(isValid, true, 'Signature verification failed');
         });
     });
-    describe('Memo Utilities', function () {
-        it('should convert string to bytes', function () {
-            const text = 'Hello Flare';
-            const bytes = utils.stringToBytes(text);
-            assert.ok(bytes instanceof Uint8Array);
-            assert.strictEqual(utils.bytesToString(bytes), text);
-        });
-        it('should handle UTF-8 strings', function () {
-            const text = 'Hello 世界 🌍';
-            const bytes = utils.stringToBytes(text);
-            assert.strictEqual(utils.bytesToString(bytes), text);
-        });
-        it('should create memo bytes from string', function () {
-            const text = 'Memo text';
-            const bytes = utils.createMemoBytes(text);
-            assert.ok(bytes instanceof Uint8Array);
-            assert.strictEqual(utils.parseMemoBytes(bytes), text);
-        });
-        it('should create memo bytes from JSON object', function () {
-            const obj = { type: 'payment', amount: 1000 };
-            const bytes = utils.createMemoBytes(obj);
-            const parsed = utils.parseMemoBytes(bytes);
-            assert.strictEqual(parsed, JSON.stringify(obj));
-        });
-        it('should handle Uint8Array input', function () {
-            const originalBytes = new Uint8Array([1, 2, 3, 4]);
-            const bytes = utils.createMemoBytes(originalBytes);
-            assert.deepStrictEqual(bytes, originalBytes);
-        });
-        it('should throw error for invalid memo type', function () {
-            assert.throws(() => {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                utils.createMemoBytes(123);
-            }, /Invalid memo format/);
-        });
-        it('should parse empty memo', function () {
-            const emptyBytes = new Uint8Array([]);
-            const parsed = utils.parseMemoBytes(emptyBytes);
-            assert.strictEqual(parsed, '');
-        });
-        it('should validate memo size', function () {
-            const smallMemo = new Uint8Array([1, 2, 3]);
-            const largeMemo = new Uint8Array(5000);
-            assert.strictEqual(utils.validateMemoSize(smallMemo), true);
-            assert.strictEqual(utils.validateMemoSize(largeMemo), false);
-            assert.strictEqual(utils.validateMemoSize(largeMemo, 6000), true);
-        });
-        it('should handle special characters in memo', function () {
-            const specialText = 'Special: \n\t\r\0';
-            const bytes = utils.createMemoBytes(specialText);
-            const parsed = utils.parseMemoBytes(bytes);
-            assert.strictEqual(parsed, specialText);
+    describe('isTransactionOf', function () {
+        const factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get('tflrp'));
+        const utilsInstance = new utils_1.Utils();
+        const testnetNetwork = statics_1.coins.get('tflrp').network;
+        const pChainBlockchainIdHex = Buffer.from(utilsInstance.cb58Decode(testnetNetwork.blockchainID)).toString('hex');
+        const cChainBlockchainIdHex = Buffer.from(utilsInstance.cb58Decode(testnetNetwork.cChainBlockchainID)).toString('hex');
+        it('should return true for Import in P transaction with matching P-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getImportInPBuilder()
+                .threshold(importInP_1.IMPORT_IN_P.threshold)
+                .locktime(importInP_1.IMPORT_IN_P.locktime)
+                .fromPubKey(importInP_1.IMPORT_IN_P.pAddresses)
+                .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                .fee(importInP_1.IMPORT_IN_P.fee)
+                .utxos(importInP_1.IMPORT_IN_P.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), true);
+        });
+        it('should return false for Import in P transaction with non-matching C-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getImportInPBuilder()
+                .threshold(importInP_1.IMPORT_IN_P.threshold)
+                .locktime(importInP_1.IMPORT_IN_P.locktime)
+                .fromPubKey(importInP_1.IMPORT_IN_P.pAddresses)
+                .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                .fee(importInP_1.IMPORT_IN_P.fee)
+                .utxos(importInP_1.IMPORT_IN_P.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), false);
+        });
+        it('should return true for Export in P transaction with matching P-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getExportInPBuilder()
+                .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                .fee(exportInP_1.EXPORT_IN_P.fee)
+                .amount(exportInP_1.EXPORT_IN_P.amount)
+                .utxos(exportInP_1.EXPORT_IN_P.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), true);
+        });
+        it('should return false for Export in P transaction with non-matching C-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getExportInPBuilder()
+                .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                .fee(exportInP_1.EXPORT_IN_P.fee)
+                .amount(exportInP_1.EXPORT_IN_P.amount)
+                .utxos(exportInP_1.EXPORT_IN_P.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), false);
+        });
+        it('should return true for Import in C transaction with matching C-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getImportInCBuilder()
+                .threshold(importInC_1.IMPORT_IN_C.threshold)
+                .locktime(importInC_1.IMPORT_IN_C.locktime)
+                .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                .externalChainId(importInC_1.IMPORT_IN_C.sourceChainId)
+                .feeRate(importInC_1.IMPORT_IN_C.fee)
+                .to(importInC_1.IMPORT_IN_C.to)
+                .utxos(importInC_1.IMPORT_IN_C.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), true);
+        });
+        it('should return false for Import in C transaction with non-matching P-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getImportInCBuilder()
+                .threshold(importInC_1.IMPORT_IN_C.threshold)
+                .locktime(importInC_1.IMPORT_IN_C.locktime)
+                .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                .externalChainId(importInC_1.IMPORT_IN_C.sourceChainId)
+                .feeRate(importInC_1.IMPORT_IN_C.fee)
+                .to(importInC_1.IMPORT_IN_C.to)
+                .utxos(importInC_1.IMPORT_IN_C.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), false);
+        });
+        it('should return true for Export in C transaction with matching C-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getExportInCBuilder()
+                .fromPubKey(exportInC_1.EXPORT_IN_C.cHexAddress)
+                .nonce(exportInC_1.EXPORT_IN_C.nonce)
+                .amount(exportInC_1.EXPORT_IN_C.amount)
+                .threshold(exportInC_1.EXPORT_IN_C.threshold)
+                .locktime(exportInC_1.EXPORT_IN_C.locktime)
+                .to(exportInC_1.EXPORT_IN_C.pAddresses)
+                .feeRate(exportInC_1.EXPORT_IN_C.fee);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), true);
+        });
+        it('should return false for Export in C transaction with non-matching P-chain blockchain ID', async function () {
+            const txBuilder = factory
+                .getExportInCBuilder()
+                .fromPubKey(exportInC_1.EXPORT_IN_C.cHexAddress)
+                .nonce(exportInC_1.EXPORT_IN_C.nonce)
+                .amount(exportInC_1.EXPORT_IN_C.amount)
+                .threshold(exportInC_1.EXPORT_IN_C.threshold)
+                .locktime(exportInC_1.EXPORT_IN_C.locktime)
+                .to(exportInC_1.EXPORT_IN_C.pAddresses)
+                .feeRate(exportInC_1.EXPORT_IN_C.fee);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), false);
+        });
+        it('should return false for invalid blockchain ID', async function () {
+            const txBuilder = factory
+                .getImportInPBuilder()
+                .threshold(importInP_1.IMPORT_IN_P.threshold)
+                .locktime(importInP_1.IMPORT_IN_P.locktime)
+                .fromPubKey(importInP_1.IMPORT_IN_P.pAddresses)
+                .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                .fee(importInP_1.IMPORT_IN_P.fee)
+                .utxos(importInP_1.IMPORT_IN_P.outputs);
+            const tx = (await txBuilder.build());
+            const flareTransaction = tx.getFlareTransaction();
+            assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, 'invalidblockchainid'), false);
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../test/unit/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins, FlareNetwork } from '@bitgo-beta/statics';\nimport { NotImplementedError } from '@bitgo-beta/sdk-core';\nimport * as assert from 'assert';\nimport { Utils } from '../../../src/lib/utils';\n\ndescribe('Utils', function () {\n  let utils: Utils;\n\n  beforeEach(function () {\n    utils = new Utils();\n  });\n\n  describe('includeIn', function () {\n    it('should return true when all wallet addresses are in output addresses', function () {\n      const walletAddresses = ['addr1', 'addr2'];\n      const outputAddresses = ['addr1', 'addr2', 'addr3'];\n\n      assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), true);\n    });\n\n    it('should return false when not all wallet addresses are in output addresses', function () {\n      const walletAddresses = ['addr1', 'addr2'];\n      const outputAddresses = ['addr1', 'addr3'];\n\n      assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), false);\n    });\n\n    it('should return true for empty wallet addresses', function () {\n      const walletAddresses: string[] = [];\n      const outputAddresses = ['addr1', 'addr2'];\n\n      assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), true);\n    });\n\n    it('should return false when wallet address not found in empty output addresses', function () {\n      const walletAddresses = ['addr1'];\n      const outputAddresses: string[] = [];\n\n      assert.strictEqual(utils.includeIn(walletAddresses, outputAddresses), false);\n    });\n  });\n\n  describe('isValidAddress', function () {\n    it('should validate single valid Flare addresses', function () {\n      // Flare addresses start with 'flare:' or 'C-flare:'\n      const validAddresses = [\n        'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',\n        'C-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',\n      ];\n\n      validAddresses.forEach((addr) => {\n        // Note: The current implementation uses regex validation\n        // This test will be updated once proper Flare address validation is implemented\n        const result = utils.isValidAddress(addr);\n        // Currently returns false due to placeholder implementation\n        assert.strictEqual(typeof result, 'boolean');\n      });\n    });\n\n    it('should validate array of addresses', function () {\n      const addresses = [\n        'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',\n        'flare1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6f4avh',\n      ];\n\n      const result = utils.isValidAddress(addresses);\n      assert.strictEqual(typeof result, 'boolean');\n    });\n\n    it('should validate addresses separated by ~', function () {\n      const addressString =\n        'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh~flare1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa6f4avh';\n\n      const result = utils.isValidAddress(addressString);\n      assert.strictEqual(typeof result, 'boolean');\n    });\n\n    it('should reject obviously invalid addresses', function () {\n      const invalidAddresses = [\n        '',\n        'invalid',\n        '123',\n        'bitcoin1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq',\n        'eth:0x1234567890123456789012345678901234567890',\n      ];\n\n      invalidAddresses.forEach((addr) => {\n        const result = utils.isValidAddress(addr);\n        // Current implementation may not catch all invalid addresses\n        assert.strictEqual(typeof result, 'boolean');\n      });\n    });\n  });\n\n  describe('isValidAddressRegex', function () {\n    it('should test address format with regex', function () {\n      const testAddress = 'flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';\n      const result = utils['isValidAddressRegex'](testAddress);\n      assert.strictEqual(typeof result, 'boolean');\n    });\n\n    it('should reject empty strings', function () {\n      const result = utils['isValidAddressRegex']('');\n      assert.strictEqual(result, false);\n    });\n  });\n\n  describe('isValidTransactionId', function () {\n    it('should throw NotImplementedError', function () {\n      assert.throws(\n        () => utils.isValidTransactionId('txid123'),\n        NotImplementedError,\n        'isValidTransactionId not implemented'\n      );\n    });\n  });\n\n  describe('isValidSignature', function () {\n    it('should throw NotImplementedError', function () {\n      assert.throws(\n        () => utils.isValidSignature('signature123'),\n        NotImplementedError,\n        'isValidSignature not implemented'\n      );\n    });\n  });\n\n  describe('createSignature', function () {\n    it('should create signature using secp256k1', function () {\n      const network = coins.get('flrp').network as FlareNetwork;\n      const message = Buffer.from('hello world', 'utf8');\n      const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');\n\n      const signature = utils.createSignature(network, message, privateKey);\n\n      assert.ok(signature instanceof Buffer);\n      assert.ok(signature.length > 0);\n    });\n\n    it('should create different signatures for different messages', function () {\n      const network = coins.get('flrp').network as FlareNetwork;\n      const message1 = Buffer.from('message 1', 'utf8');\n      const message2 = Buffer.from('message 2', 'utf8');\n      const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');\n\n      const sig1 = utils.createSignature(network, message1, privateKey);\n      const sig2 = utils.createSignature(network, message2, privateKey);\n\n      assert.notDeepStrictEqual(sig1, sig2);\n    });\n\n    it('should throw error for invalid private key', function () {\n      const network = coins.get('flrp').network as FlareNetwork;\n      const message = Buffer.from('hello world', 'utf8');\n      const invalidPrivateKey = Buffer.from('invalid', 'utf8');\n\n      assert.throws(() => utils.createSignature(network, message, invalidPrivateKey), /Failed to create signature/);\n    });\n  });\n\n  describe('verifySignature', function () {\n    it('should verify valid signature', function () {\n      const network = coins.get('flrp').network as FlareNetwork;\n      const message = Buffer.from('hello world', 'utf8');\n      const privateKey = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');\n\n      // Create signature\n      const signature = utils.createSignature(network, message, privateKey);\n\n      // Get public key (this would normally come from the private key)\n      // For testing, we'll use a mock public key approach\n      const publicKey = Buffer.from('02' + '0'.repeat(62), 'hex'); // Compressed public key format\n\n      // Note: This test may fail if the public key doesn't match the private key\n      // In a real implementation, you'd derive the public key from the private key\n      // The method returns false when verification fails instead of throwing\n      const isValid = utils.verifySignature(network, message, signature, publicKey);\n      assert.strictEqual(typeof isValid, 'boolean');\n      // With mock public key, this should return false\n      assert.strictEqual(isValid, false);\n    });\n\n    it('should return false for invalid signature', function () {\n      const network = coins.get('flrp').network as FlareNetwork;\n      const message = Buffer.from('hello world', 'utf8');\n      const invalidSignature = Buffer.from('invalid signature', 'utf8');\n      const publicKey = Buffer.from('02' + '0'.repeat(62), 'hex');\n\n      // This should return false due to invalid signature format\n      // The method catches errors internally and returns false\n      const result = utils.verifySignature(network, message, invalidSignature, publicKey);\n      assert.strictEqual(result, false);\n    });\n  });\n\n  describe('address parsing utilities', function () {\n    it('should handle address separator constants', function () {\n      const { ADDRESS_SEPARATOR } = require('../../../src/lib/iface');\n      assert.strictEqual(ADDRESS_SEPARATOR, '~');\n    });\n\n    it('should handle input separator constants', function () {\n      const { INPUT_SEPARATOR } = require('../../../src/lib/iface');\n      assert.strictEqual(INPUT_SEPARATOR, ':');\n    });\n  });\n\n  describe('error handling', function () {\n    it('should properly extend base utils', function () {\n      // Test that utils class exists and has expected methods\n      assert.ok('isValidAddress' in utils);\n      assert.ok('includeIn' in utils);\n      assert.ok('createSignature' in utils);\n      assert.ok('verifySignature' in utils);\n    });\n\n    it('should handle parsing errors gracefully', function () {\n      // Test that utils can handle malformed input without crashing\n      // Note: These may throw errors, which is acceptable behavior\n      try {\n        utils.isValidAddress(null as unknown as string);\n        utils.isValidAddress(undefined as unknown as string);\n      } catch (error) {\n        // Expected behavior - utils should handle or throw meaningful errors\n        assert.ok(error instanceof Error);\n      }\n    });\n  });\n\n  describe('constants validation', function () {\n    it('should have correct constant values', function () {\n      const constants = require('../../../src/lib/constants');\n\n      assert.strictEqual(typeof constants.DECODED_BLOCK_ID_LENGTH, 'number');\n      assert.strictEqual(typeof constants.SHORT_PUB_KEY_LENGTH, 'number');\n      assert.strictEqual(typeof constants.COMPRESSED_PUBLIC_KEY_LENGTH, 'number');\n      assert.strictEqual(typeof constants.UNCOMPRESSED_PUBLIC_KEY_LENGTH, 'number');\n      assert.strictEqual(typeof constants.RAW_PRIVATE_KEY_LENGTH, 'number');\n      assert.strictEqual(typeof constants.SUFFIXED_PRIVATE_KEY_LENGTH, 'number');\n      assert.strictEqual(typeof constants.PRIVATE_KEY_COMPRESSED_SUFFIX, 'string');\n      assert.strictEqual(typeof constants.OUTPUT_INDEX_HEX_LENGTH, 'number');\n      assert.ok(constants.ADDRESS_REGEX instanceof RegExp);\n      assert.ok(constants.HEX_REGEX instanceof RegExp);\n    });\n  });\n\n  describe('Memo Utilities', function () {\n    it('should convert string to bytes', function () {\n      const text = 'Hello Flare';\n      const bytes = utils.stringToBytes(text);\n\n      assert.ok(bytes instanceof Uint8Array);\n      assert.strictEqual(utils.bytesToString(bytes), text);\n    });\n\n    it('should handle UTF-8 strings', function () {\n      const text = 'Hello 世界 🌍';\n      const bytes = utils.stringToBytes(text);\n\n      assert.strictEqual(utils.bytesToString(bytes), text);\n    });\n\n    it('should create memo bytes from string', function () {\n      const text = 'Memo text';\n      const bytes = utils.createMemoBytes(text);\n\n      assert.ok(bytes instanceof Uint8Array);\n      assert.strictEqual(utils.parseMemoBytes(bytes), text);\n    });\n\n    it('should create memo bytes from JSON object', function () {\n      const obj = { type: 'payment', amount: 1000 };\n      const bytes = utils.createMemoBytes(obj);\n      const parsed = utils.parseMemoBytes(bytes);\n\n      assert.strictEqual(parsed, JSON.stringify(obj));\n    });\n\n    it('should handle Uint8Array input', function () {\n      const originalBytes = new Uint8Array([1, 2, 3, 4]);\n      const bytes = utils.createMemoBytes(originalBytes);\n\n      assert.deepStrictEqual(bytes, originalBytes);\n    });\n\n    it('should throw error for invalid memo type', function () {\n      assert.throws(() => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        utils.createMemoBytes(123 as any);\n      }, /Invalid memo format/);\n    });\n\n    it('should parse empty memo', function () {\n      const emptyBytes = new Uint8Array([]);\n      const parsed = utils.parseMemoBytes(emptyBytes);\n\n      assert.strictEqual(parsed, '');\n    });\n\n    it('should validate memo size', function () {\n      const smallMemo = new Uint8Array([1, 2, 3]);\n      const largeMemo = new Uint8Array(5000);\n\n      assert.strictEqual(utils.validateMemoSize(smallMemo), true);\n      assert.strictEqual(utils.validateMemoSize(largeMemo), false);\n      assert.strictEqual(utils.validateMemoSize(largeMemo, 6000), true);\n    });\n\n    it('should handle special characters in memo', function () {\n      const specialText = 'Special: \\n\\t\\r\\0';\n      const bytes = utils.createMemoBytes(specialText);\n      const parsed = utils.parseMemoBytes(bytes);\n\n      assert.strictEqual(parsed, specialText);\n    });\n  });\n});\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../test/unit/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins, FlareNetwork } from '@bitgo-beta/statics';\nimport * as assert from 'assert';\nimport { Utils } from '../../../src/lib/utils';\nimport {\n  SEED_ACCOUNT,\n  ACCOUNT_1,\n  ACCOUNT_2,\n  ACCOUNT_3,\n  INVALID_SHORT_KEYPAIR_KEY,\n  INVALID_LONG_KEYPAIR_PRV,\n} from '../../resources/account';\nimport { ecc } from '@bitgo-beta/secp256k1';\nimport { EXPORT_IN_C } from '../../resources/transactionData/exportInC';\nimport { IMPORT_IN_P } from '../../resources/transactionData/importInP';\nimport { EXPORT_IN_P } from '../../resources/transactionData/exportInP';\nimport { IMPORT_IN_C } from '../../resources/transactionData/importInC';\nimport { TransactionBuilderFactory, Transaction } from '../../../src/lib';\nimport { secp256k1, Address } from '@flarenetwork/flarejs';\n\ndescribe('Utils', function () {\n  let utils: Utils;\n  const network = coins.get('flrp').network as FlareNetwork;\n\n  beforeEach(function () {\n    utils = new Utils();\n  });\n\n  describe('includeIn', function () {\n    it('should return true when all wallet addresses are in UTXO output addresses', function () {\n      const walletAddresses = [EXPORT_IN_C.pAddresses[0], EXPORT_IN_C.pAddresses[1]];\n      const utxoOutputAddresses = [...EXPORT_IN_C.pAddresses];\n      assert.strictEqual(utils.includeIn(walletAddresses, utxoOutputAddresses), true);\n    });\n\n    it('should return false when some wallet addresses are not in UTXO output addresses', function () {\n      const walletAddresses = [EXPORT_IN_C.pAddresses[0], ACCOUNT_3.address];\n      const utxoOutputAddresses = [EXPORT_IN_C.pAddresses[0], EXPORT_IN_C.pAddresses[1]];\n      assert.strictEqual(utils.includeIn(walletAddresses, utxoOutputAddresses), false);\n    });\n\n    it('should return true for empty wallet addresses', function () {\n      const walletAddresses: string[] = [];\n      const utxoOutputAddresses = [EXPORT_IN_C.pAddresses[0]];\n      assert.strictEqual(utils.includeIn(walletAddresses, utxoOutputAddresses), true);\n    });\n  });\n\n  describe('isValidAddress', function () {\n    it('should return true for valid mainnet P-chain address', function () {\n      assert.strictEqual(utils.isValidAddress(SEED_ACCOUNT.addressMainnet), true);\n    });\n\n    it('should return true for valid testnet P-chain address', function () {\n      assert.strictEqual(utils.isValidAddress(SEED_ACCOUNT.addressTestnet), true);\n    });\n\n    it('should return true for valid NodeID address', function () {\n      assert.strictEqual(utils.isValidAddress('NodeID-abc123xyz'), true);\n    });\n\n    it('should return true for array of valid addresses', function () {\n      assert.strictEqual(utils.isValidAddress(EXPORT_IN_C.pAddresses), true);\n    });\n\n    it('should return true for tilde-separated addresses', function () {\n      const combined = EXPORT_IN_C.pAddresses.join('~');\n      assert.strictEqual(utils.isValidAddress(combined), true);\n    });\n\n    it('should return false for invalid address format', function () {\n      assert.strictEqual(utils.isValidAddress('invalid'), false);\n    });\n\n    it('should return false for address without prefix', function () {\n      assert.strictEqual(utils.isValidAddress('flare1abc123'), false);\n    });\n  });\n\n  describe('isValidBlockId', function () {\n    it('should return true for valid 32-byte hex block ID', function () {\n      assert.strictEqual(utils.isValidBlockId(SEED_ACCOUNT.privateKey), true); // 64 hex chars = 32 bytes\n    });\n\n    it('should return false for invalid length block ID', function () {\n      assert.strictEqual(utils.isValidBlockId(INVALID_SHORT_KEYPAIR_KEY), false);\n    });\n\n    it('should return false for empty block ID', function () {\n      assert.strictEqual(utils.isValidBlockId(''), false);\n    });\n  });\n\n  describe('isValidPublicKey', function () {\n    it('should return true for valid compressed public key starting with 03', function () {\n      assert.strictEqual(utils.isValidPublicKey(SEED_ACCOUNT.publicKey), true);\n    });\n\n    it('should return true for valid compressed public key starting with 02', function () {\n      assert.strictEqual(utils.isValidPublicKey(ACCOUNT_1.publicKey), true);\n    });\n\n    it('should return true for another valid compressed public key', function () {\n      assert.strictEqual(utils.isValidPublicKey(ACCOUNT_2.publicKey), true);\n    });\n\n    it('should return true for valid xpub', function () {\n      assert.strictEqual(utils.isValidPublicKey(SEED_ACCOUNT.xPublicKey), true);\n    });\n\n    it('should return true for ACCOUNT_1 xpub', function () {\n      assert.strictEqual(utils.isValidPublicKey(ACCOUNT_1.xPublicKey), true);\n    });\n\n    it('should return false for invalid short public key', function () {\n      assert.strictEqual(utils.isValidPublicKey(INVALID_SHORT_KEYPAIR_KEY), false);\n    });\n\n    it('should return false for compressed key with wrong prefix', function () {\n      const invalidKey = '05' + SEED_ACCOUNT.privateKey;\n      assert.strictEqual(utils.isValidPublicKey(invalidKey), false);\n    });\n\n    it('should return false for non-hex public key', function () {\n      const invalidKey = 'zz' + SEED_ACCOUNT.privateKey;\n      assert.strictEqual(utils.isValidPublicKey(invalidKey), false);\n    });\n  });\n\n  describe('isValidPrivateKey', function () {\n    it('should return true for valid 64-char hex private key', function () {\n      assert.strictEqual(utils.isValidPrivateKey(SEED_ACCOUNT.privateKey), true);\n    });\n\n    it('should return true for ACCOUNT_1 private key', function () {\n      assert.strictEqual(utils.isValidPrivateKey(ACCOUNT_1.privateKey), true);\n    });\n\n    it('should return true for ACCOUNT_2 private key', function () {\n      assert.strictEqual(utils.isValidPrivateKey(ACCOUNT_2.privateKey), true);\n    });\n\n    it('should return true for valid xprv', function () {\n      assert.strictEqual(utils.isValidPrivateKey(SEED_ACCOUNT.xPrivateKey), true);\n    });\n\n    it('should return true for 66-char private key ending with 01', function () {\n      const extendedKey = SEED_ACCOUNT.privateKey + '01';\n      assert.strictEqual(utils.isValidPrivateKey(extendedKey), true);\n    });\n\n    it('should return false for 66-char private key not ending with 01', function () {\n      assert.strictEqual(utils.isValidPrivateKey(INVALID_LONG_KEYPAIR_PRV), false);\n    });\n\n    it('should return false for invalid short private key', function () {\n      assert.strictEqual(utils.isValidPrivateKey(INVALID_SHORT_KEYPAIR_KEY), false);\n    });\n\n    it('should return false for non-hex private key', function () {\n      const invalidKey = 'zz' + SEED_ACCOUNT.privateKey.slice(2);\n      assert.strictEqual(utils.isValidPrivateKey(invalidKey), false);\n    });\n  });\n\n  describe('allHexChars', function () {\n    it('should return true for valid private key hex', function () {\n      assert.strictEqual(utils.allHexChars(SEED_ACCOUNT.privateKey), true);\n    });\n\n    it('should return true for valid public key hex', function () {\n      assert.strictEqual(utils.allHexChars(SEED_ACCOUNT.publicKey), true);\n    });\n\n    it('should return true for hex string with 0x prefix', function () {\n      assert.strictEqual(utils.allHexChars(EXPORT_IN_C.cHexAddress), true);\n    });\n\n    it('should return true for valid signature hex', function () {\n      assert.strictEqual(utils.allHexChars(SEED_ACCOUNT.signature), true);\n    });\n\n    it('should return false for non-hex characters', function () {\n      assert.strictEqual(utils.allHexChars('ghijkl'), false);\n    });\n\n    it('should return false for empty string', function () {\n      assert.strictEqual(utils.allHexChars(''), false);\n    });\n  });\n\n  describe('createSignature and verifySignature', function () {\n    it('should create a valid 65-byte signature', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(SEED_ACCOUNT.privateKey, 'hex');\n\n      const signature = utils.createSignature(network, message, privateKey);\n\n      assert.ok(signature instanceof Buffer);\n      assert.strictEqual(signature.length, 65);\n    });\n\n    it('should verify a valid signature', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(SEED_ACCOUNT.privateKey, 'hex');\n      const publicKey = Buffer.from(SEED_ACCOUNT.publicKey, 'hex');\n\n      const signature = utils.createSignature(network, message, privateKey);\n      const sigOnly = signature.slice(0, 64);\n\n      const messageHash = utils.sha256(message);\n      const isValid = utils.verifySignature(messageHash, sigOnly, publicKey);\n      assert.strictEqual(isValid, true);\n    });\n\n    it('should return false for invalid signature', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const publicKey = Buffer.from(SEED_ACCOUNT.publicKey, 'hex');\n      const invalidSignature = Buffer.alloc(64);\n\n      const messageHash = utils.sha256(message);\n      const isValid = utils.verifySignature(messageHash, invalidSignature, publicKey);\n      assert.strictEqual(isValid, false);\n    });\n\n    it('should create signature with ACCOUNT_1 keys', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(ACCOUNT_1.privateKey, 'hex');\n\n      const signature = utils.createSignature(network, message, privateKey);\n\n      assert.ok(signature instanceof Buffer);\n      assert.strictEqual(signature.length, 65);\n    });\n  });\n\n  describe('createNewSig', function () {\n    it('should create a signature from valid signature hex string', function () {\n      const sig = utils.createNewSig(SEED_ACCOUNT.signature);\n      assert.ok(sig);\n    });\n\n    it('should create a signature from export signature hex', function () {\n      const sigHex = utils.removeHexPrefix(EXPORT_IN_C.signature[0]);\n      const sig = utils.createNewSig(sigHex);\n      assert.ok(sig);\n    });\n\n    it('should pad short hex strings', function () {\n      const sigHex = INVALID_SHORT_KEYPAIR_KEY;\n      const sig = utils.createNewSig(sigHex);\n      assert.ok(sig);\n    });\n  });\n\n  describe('createEmptySigWithAddress and getAddressFromEmptySig', function () {\n    it('should create empty signature with embedded C-chain address', function () {\n      const addressHex = utils.removeHexPrefix(EXPORT_IN_C.cHexAddress);\n      const sig = utils.createEmptySigWithAddress(addressHex);\n      assert.ok(sig);\n    });\n\n    it('should extract embedded address from empty signature', function () {\n      const addressHex = utils.removeHexPrefix(EXPORT_IN_C.cHexAddress).toLowerCase();\n      const sig = utils.createEmptySigWithAddress(addressHex);\n\n      // Get signature bytes and convert to hex\n      const sigBytes = sig.toBytes();\n      const sigHex = Buffer.from(sigBytes).toString('hex');\n\n      const extractedAddress = utils.getAddressFromEmptySig(sigHex);\n      assert.strictEqual(extractedAddress, addressHex);\n    });\n\n    it('should handle 0x prefixed address', function () {\n      const sig = utils.createEmptySigWithAddress(EXPORT_IN_C.cHexAddress);\n      assert.ok(sig);\n    });\n\n    it('should return empty string for short signature', function () {\n      const shortSig = SEED_ACCOUNT.privateKey; // 64 chars, less than 130\n      assert.strictEqual(utils.getAddressFromEmptySig(shortSig), '');\n    });\n  });\n\n  describe('sha256', function () {\n    it('should compute SHA256 hash of message', function () {\n      const data = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const hash = utils.sha256(data);\n\n      assert.ok(hash instanceof Buffer);\n      assert.strictEqual(hash.length, 32);\n    });\n\n    it('should produce consistent hash for same input', function () {\n      const data = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const hash1 = utils.sha256(data);\n      const hash2 = utils.sha256(data);\n\n      assert.deepStrictEqual(hash1, hash2);\n    });\n\n    it('should produce different hash for different input', function () {\n      const data1 = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const data2 = Buffer.from(SEED_ACCOUNT.privateKey, 'utf8');\n      const hash1 = utils.sha256(data1);\n      const hash2 = utils.sha256(data2);\n\n      assert.notDeepStrictEqual(hash1, hash2);\n    });\n  });\n\n  describe('validateRawTransaction', function () {\n    it('should not throw for valid unsigned hex transaction', function () {\n      const rawTx = utils.removeHexPrefix(EXPORT_IN_C.unsignedHex);\n      assert.doesNotThrow(() => utils.validateRawTransaction(rawTx));\n    });\n\n    it('should not throw for valid signed hex transaction', function () {\n      const rawTx = utils.removeHexPrefix(EXPORT_IN_C.signedHex);\n      assert.doesNotThrow(() => utils.validateRawTransaction(rawTx));\n    });\n\n    it('should not throw for import transaction hex', function () {\n      const rawTx = utils.removeHexPrefix(IMPORT_IN_P.unsignedHex);\n      assert.doesNotThrow(() => utils.validateRawTransaction(rawTx));\n    });\n\n    it('should throw for empty transaction', function () {\n      assert.throws(() => utils.validateRawTransaction(''), /Raw transaction is empty/);\n    });\n\n    it('should throw for non-hex transaction', function () {\n      assert.throws(() => utils.validateRawTransaction('xyz123'), /Raw transaction is not hex string/);\n    });\n  });\n\n  describe('removeHexPrefix', function () {\n    it('should remove 0x prefix from C-chain address', function () {\n      assert.strictEqual(utils.removeHexPrefix(EXPORT_IN_C.cHexAddress), EXPORT_IN_C.cHexAddress.slice(2));\n    });\n\n    it('should remove 0x prefix from unsigned hex', function () {\n      assert.strictEqual(utils.removeHexPrefix(EXPORT_IN_C.unsignedHex), EXPORT_IN_C.unsignedHex.slice(2));\n    });\n\n    it('should return string unchanged if no prefix', function () {\n      assert.strictEqual(utils.removeHexPrefix(SEED_ACCOUNT.privateKey), SEED_ACCOUNT.privateKey);\n    });\n\n    it('should handle empty string', function () {\n      assert.strictEqual(utils.removeHexPrefix(''), '');\n    });\n  });\n\n  describe('outputidxNumberToBuffer and outputidxBufferToNumber', function () {\n    it('should convert output index to buffer and back', function () {\n      const outputIdx = IMPORT_IN_P.outputs[0].outputidx;\n      const buffer = utils.outputidxNumberToBuffer(outputIdx);\n      const result = utils.outputidxBufferToNumber(buffer);\n\n      assert.strictEqual(result, outputIdx);\n    });\n\n    it('should handle nonce value', function () {\n      const nonceStr = EXPORT_IN_C.nonce.toString();\n      const buffer = utils.outputidxNumberToBuffer(nonceStr);\n      const result = utils.outputidxBufferToNumber(buffer);\n\n      assert.strictEqual(result, nonceStr);\n    });\n\n    it('should produce 4-byte buffer', function () {\n      const buffer = utils.outputidxNumberToBuffer('255');\n      assert.strictEqual(buffer.length, 4);\n    });\n  });\n\n  describe('addressToString', function () {\n    it('should convert address buffer to mainnet bech32 string', function () {\n      const address = SEED_ACCOUNT.addressMainnet;\n      const addressBuffer = utils.parseAddress(address);\n      const result = utils.addressToString('flare', 'P', addressBuffer);\n\n      assert.ok(result.startsWith('P-'));\n      assert.ok(result.includes('flare'));\n    });\n\n    it('should convert address buffer to testnet bech32 string', function () {\n      const address = SEED_ACCOUNT.addressTestnet;\n      const addressBuffer = utils.parseAddress(address);\n      const result = utils.addressToString('costwo', 'P', addressBuffer);\n\n      assert.ok(result.startsWith('P-'));\n      assert.ok(result.includes('costwo'));\n    });\n  });\n\n  describe('cb58Encode and cb58Decode', function () {\n    it('should encode and decode target chain ID correctly', function () {\n      const encoded = EXPORT_IN_C.targetChainId;\n      const decoded = utils.cb58Decode(encoded);\n      const reEncoded = utils.cb58Encode(decoded);\n\n      assert.strictEqual(reEncoded, encoded);\n    });\n\n    it('should encode and decode source chain ID correctly', function () {\n      const encoded = IMPORT_IN_P.sourceChainId;\n      const decoded = utils.cb58Decode(encoded);\n      const reEncoded = utils.cb58Encode(decoded);\n\n      assert.strictEqual(reEncoded, encoded);\n    });\n\n    it('should throw for invalid checksum', function () {\n      assert.throws(() => utils.cb58Decode('1111111111111'), /Invalid checksum/);\n    });\n  });\n\n  describe('parseAddress and stringToAddress', function () {\n    it('should parse hex address with 0x prefix', function () {\n      const buffer = utils.parseAddress(EXPORT_IN_C.cHexAddress);\n\n      assert.ok(buffer instanceof Buffer);\n      assert.strictEqual(buffer.length, 20);\n    });\n\n    it('should parse raw hex address from outputs', function () {\n      const address = IMPORT_IN_P.outputs[0].addresses[0];\n      const buffer = utils.parseAddress(address);\n\n      assert.ok(buffer instanceof Buffer);\n      assert.strictEqual(buffer.length, 20);\n    });\n\n    it('should parse mainnet bech32 address', function () {\n      const buffer = utils.parseAddress(SEED_ACCOUNT.addressMainnet);\n\n      assert.ok(buffer instanceof Buffer);\n      assert.strictEqual(buffer.length, 20);\n    });\n\n    it('should parse testnet bech32 address', function () {\n      const buffer = utils.parseAddress(SEED_ACCOUNT.addressTestnet);\n\n      assert.ok(buffer instanceof Buffer);\n      assert.strictEqual(buffer.length, 20);\n    });\n\n    it('should parse P-chain addresses from export data', function () {\n      EXPORT_IN_C.pAddresses.forEach((address) => {\n        const buffer = utils.parseAddress(address);\n        assert.ok(buffer instanceof Buffer);\n        assert.strictEqual(buffer.length, 20);\n      });\n    });\n\n    it('should throw for address without dash separator', function () {\n      assert.throws(() => utils.parseAddress('flare1abc'), /Valid address should include -/);\n    });\n\n    it('should throw for invalid HRP', function () {\n      assert.throws(() => utils.parseAddress('P-invalid1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq5evzmy'), /Invalid HRP/);\n    });\n  });\n\n  describe('flareIdString', function () {\n    it('should create Id from private key hex string', function () {\n      const id = utils.flareIdString(SEED_ACCOUNT.privateKey);\n      assert.ok(id);\n    });\n\n    it('should create Id from asset ID hex', function () {\n      // Asset ID is typically 32 bytes (64 hex chars)\n      const assetIdHex = SEED_ACCOUNT.privateKey; // Using as a 32-byte hex\n      const id = utils.flareIdString(assetIdHex);\n      assert.ok(id);\n    });\n  });\n\n  describe('recoverySignature', function () {\n    it('should recover public key from valid signature', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(SEED_ACCOUNT.privateKey, 'hex');\n\n      // Create signature using the same private key (createSignature hashes the message internally)\n      const signature = utils.createSignature(network, message, privateKey);\n\n      // Recover public key - pass the hashed message since recoverySignature expects pre-hashed\n      const messageHash = utils.sha256(message);\n      const recoveredPubKey = utils.recoverySignature(messageHash, signature);\n\n      assert.ok(recoveredPubKey instanceof Buffer);\n      assert.strictEqual(recoveredPubKey.length, 33); // Should be compressed public key (33 bytes)\n    });\n\n    it('should recover same public key for same message and signature', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(SEED_ACCOUNT.privateKey, 'hex');\n      const signature = utils.createSignature(network, message, privateKey);\n\n      const messageHash = utils.sha256(message);\n      const pubKey1 = utils.recoverySignature(messageHash, signature);\n      const pubKey2 = utils.recoverySignature(messageHash, signature);\n\n      assert.deepStrictEqual(pubKey1, pubKey2);\n    });\n\n    it('should recover public key that matches original key', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(SEED_ACCOUNT.privateKey, 'hex');\n\n      // Get original public key\n      const originalPubKey = Buffer.from(ecc.pointFromScalar(privateKey, true) as Uint8Array);\n\n      // Create signature and recover public key\n      const signature = utils.createSignature(network, message, privateKey);\n      const messageHash = utils.sha256(message);\n      const recoveredPubKey = utils.recoverySignature(messageHash, signature);\n\n      // Convert both to hex strings for comparison\n      assert.strictEqual(recoveredPubKey.toString('hex'), originalPubKey.toString('hex'));\n    });\n\n    it('should recover public key using ACCOUNT_1 keys', function () {\n      const message = Buffer.from(SEED_ACCOUNT.message, 'utf8');\n      const privateKey = Buffer.from(ACCOUNT_1.privateKey, 'hex');\n\n      const originalPubKey = Buffer.from(ecc.pointFromScalar(privateKey, true) as Uint8Array);\n\n      const signature = utils.createSignature(network, message, privateKey);\n      const messageHash = utils.sha256(message);\n      const recoveredPubKey = utils.recoverySignature(messageHash, signature);\n\n      assert.strictEqual(recoveredPubKey.toString('hex'), originalPubKey.toString('hex'));\n    });\n\n    it('should throw error for invalid signature length', function () {\n      const messageHash = utils.sha256(Buffer.from(SEED_ACCOUNT.message, 'utf8'));\n      const invalidSignature = Buffer.from(INVALID_SHORT_KEYPAIR_KEY, 'hex');\n\n      assert.throws(() => utils.recoverySignature(messageHash, invalidSignature), /Failed to recover signature/);\n    });\n\n    it('should throw error for signature with invalid recovery parameter', function () {\n      const messageHash = utils.sha256(Buffer.from(SEED_ACCOUNT.message, 'utf8'));\n      const signature = Buffer.alloc(65); // Valid length but all zeros - invalid signature\n\n      assert.throws(() => utils.recoverySignature(messageHash, signature), /Failed to recover signature/);\n    });\n\n    it('should recover signature and verify sender address from signed C-chain Export tx', async function () {\n      // Transaction from actual build response - C-chain Export tx\n      const tx =\n        '0x0000000000010000007278db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da55524790000000000000000000000000000000000000000000000000000000000000000000000012a96025ad506b9fbb9023fbdc1665c7f7d7c923f000000000605236658734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd00000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000006052340000000000000000000000002000000037fa8c7e0c8ad9f09f9179b42b77e94a487c3df758d4ba538f772333ca7bf3668a2fe36648438c79d9b6b77b56effb860eaa430e0e30c4e392f59cd08000000010000000900000001750076e67d9720283a71c6e7a9a88ff662608fefdd3f316f1211957ca1873eee3ee4a74b468bda66176a3e5d3ab54d43a8c0be12348f251a3093c16d9db00cd001c31e9c15';\n      const expectedSenderAddress = '0x2a96025ad506b9fbb9023fbdc1665c7f7d7c923f';\n\n      const factory = new TransactionBuilderFactory(coins.get('tflrp'));\n      const txn = (await factory.from(tx).build()) as Transaction;\n      const signablePayload = txn.signablePayload;\n      const signatures = txn.signature;\n      const sig = Buffer.from(utils.removeHexPrefix(signatures[0]), 'hex');\n\n      // Recover public key from signature (signablePayload is already SHA256 hashed)\n      const recoveredPubKey = utils.recoverySignature(signablePayload, sig);\n\n      // Get the sender address from the transaction inputs\n      const txInputs = txn.inputs;\n      const senderAddressFromTx = txInputs[0].address.toLowerCase();\n\n      // Verify sender address matches expected\n      assert.strictEqual(\n        senderAddressFromTx,\n        expectedSenderAddress.toLowerCase(),\n        'Transaction sender address does not match expected'\n      );\n\n      // Derive address from recovered public key\n      const derivedEvmAddress =\n        '0x' + Buffer.from(new Address(secp256k1.publicKeyToEthAddress(recoveredPubKey)).toBytes()).toString('hex');\n\n      // Verify the recovered public key matches the sender\n      assert.strictEqual(\n        derivedEvmAddress.toLowerCase(),\n        senderAddressFromTx,\n        'Recovered public key does not match sender address'\n      );\n\n      // Also verify signature validity\n      const sigOnly = sig.slice(0, 64);\n      const isValid = utils.verifySignature(signablePayload, sigOnly, recoveredPubKey);\n      assert.strictEqual(isValid, true, 'Signature verification failed');\n    });\n  });\n\n  describe('isTransactionOf', function () {\n    const factory = new TransactionBuilderFactory(coins.get('tflrp'));\n    const utilsInstance = new Utils();\n    const testnetNetwork = coins.get('tflrp').network as FlareNetwork;\n    const pChainBlockchainIdHex = Buffer.from(utilsInstance.cb58Decode(testnetNetwork.blockchainID)).toString('hex');\n    const cChainBlockchainIdHex = Buffer.from(utilsInstance.cb58Decode(testnetNetwork.cChainBlockchainID)).toString(\n      'hex'\n    );\n\n    it('should return true for Import in P transaction with matching P-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getImportInPBuilder()\n        .threshold(IMPORT_IN_P.threshold)\n        .locktime(IMPORT_IN_P.locktime)\n        .fromPubKey(IMPORT_IN_P.pAddresses)\n        .externalChainId(IMPORT_IN_P.sourceChainId)\n        .fee(IMPORT_IN_P.fee)\n        .utxos(IMPORT_IN_P.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), true);\n    });\n\n    it('should return false for Import in P transaction with non-matching C-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getImportInPBuilder()\n        .threshold(IMPORT_IN_P.threshold)\n        .locktime(IMPORT_IN_P.locktime)\n        .fromPubKey(IMPORT_IN_P.pAddresses)\n        .externalChainId(IMPORT_IN_P.sourceChainId)\n        .fee(IMPORT_IN_P.fee)\n        .utxos(IMPORT_IN_P.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), false);\n    });\n\n    it('should return true for Export in P transaction with matching P-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getExportInPBuilder()\n        .threshold(EXPORT_IN_P.threshold)\n        .locktime(EXPORT_IN_P.locktime)\n        .fromPubKey(EXPORT_IN_P.pAddresses)\n        .externalChainId(EXPORT_IN_P.sourceChainId)\n        .fee(EXPORT_IN_P.fee)\n        .amount(EXPORT_IN_P.amount)\n        .utxos(EXPORT_IN_P.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), true);\n    });\n\n    it('should return false for Export in P transaction with non-matching C-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getExportInPBuilder()\n        .threshold(EXPORT_IN_P.threshold)\n        .locktime(EXPORT_IN_P.locktime)\n        .fromPubKey(EXPORT_IN_P.pAddresses)\n        .externalChainId(EXPORT_IN_P.sourceChainId)\n        .fee(EXPORT_IN_P.fee)\n        .amount(EXPORT_IN_P.amount)\n        .utxos(EXPORT_IN_P.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), false);\n    });\n\n    it('should return true for Import in C transaction with matching C-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getImportInCBuilder()\n        .threshold(IMPORT_IN_C.threshold)\n        .locktime(IMPORT_IN_C.locktime)\n        .fromPubKey(IMPORT_IN_C.pAddresses)\n        .externalChainId(IMPORT_IN_C.sourceChainId)\n        .feeRate(IMPORT_IN_C.fee)\n        .to(IMPORT_IN_C.to)\n        .utxos(IMPORT_IN_C.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), true);\n    });\n\n    it('should return false for Import in C transaction with non-matching P-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getImportInCBuilder()\n        .threshold(IMPORT_IN_C.threshold)\n        .locktime(IMPORT_IN_C.locktime)\n        .fromPubKey(IMPORT_IN_C.pAddresses)\n        .externalChainId(IMPORT_IN_C.sourceChainId)\n        .feeRate(IMPORT_IN_C.fee)\n        .to(IMPORT_IN_C.to)\n        .utxos(IMPORT_IN_C.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), false);\n    });\n\n    it('should return true for Export in C transaction with matching C-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getExportInCBuilder()\n        .fromPubKey(EXPORT_IN_C.cHexAddress)\n        .nonce(EXPORT_IN_C.nonce)\n        .amount(EXPORT_IN_C.amount)\n        .threshold(EXPORT_IN_C.threshold)\n        .locktime(EXPORT_IN_C.locktime)\n        .to(EXPORT_IN_C.pAddresses)\n        .feeRate(EXPORT_IN_C.fee);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, cChainBlockchainIdHex), true);\n    });\n\n    it('should return false for Export in C transaction with non-matching P-chain blockchain ID', async function () {\n      const txBuilder = factory\n        .getExportInCBuilder()\n        .fromPubKey(EXPORT_IN_C.cHexAddress)\n        .nonce(EXPORT_IN_C.nonce)\n        .amount(EXPORT_IN_C.amount)\n        .threshold(EXPORT_IN_C.threshold)\n        .locktime(EXPORT_IN_C.locktime)\n        .to(EXPORT_IN_C.pAddresses)\n        .feeRate(EXPORT_IN_C.fee);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, pChainBlockchainIdHex), false);\n    });\n\n    it('should return false for invalid blockchain ID', async function () {\n      const txBuilder = factory\n        .getImportInPBuilder()\n        .threshold(IMPORT_IN_P.threshold)\n        .locktime(IMPORT_IN_P.locktime)\n        .fromPubKey(IMPORT_IN_P.pAddresses)\n        .externalChainId(IMPORT_IN_P.sourceChainId)\n        .fee(IMPORT_IN_P.fee)\n        .utxos(IMPORT_IN_P.outputs);\n\n      const tx = (await txBuilder.build()) as Transaction;\n      const flareTransaction = tx.getFlareTransaction();\n\n      assert.strictEqual(utilsInstance.isTransactionOf(flareTransaction, 'invalidblockchainid'), false);\n    });\n  });\n});\n"]}