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

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

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+require("should");
+const importInP_1 = require("../../resources/transactionData/importInP");
+const lib_1 = require("../../../src/lib");
+const statics_1 = require("@bitgo-beta/statics");
+const signFlowTestSuit_1 = __importDefault(require("./signFlowTestSuit"));
+const utils_1 = __importDefault(require("../../../src/lib/utils"));
+describe('Flrp Import In P Tx Builder', () => {
+    const coinConfig = statics_1.coins.get('tflrp');
+    const factory = new lib_1.TransactionBuilderFactory(coinConfig);
+    describe('default fee', () => {
+        const FIXED_FEE = coinConfig.network.txFee;
+        it('should set fixedFee (1261000) by default in constructor', () => {
+            const txBuilder = factory.getImportInPBuilder();
+            // The fixedFee should be set from network.txFee = '1261000'
+            const transaction = txBuilder.transaction;
+            transaction._fee.fee.should.equal(FIXED_FEE);
+        });
+        it('should use default fixedFee when fee is not explicitly set', async () => {
+            // Create a UTXO with enough balance to cover the default fee
+            const utxoAmount = '50000000'; // 0.05 FLR - enough to cover fee and have output
+            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)
+                // NOTE: .fee() is NOT called - should use default fixedFee
+                .utxos([
+                {
+                    outputID: 0,
+                    amount: utxoAmount,
+                    txid: importInP_1.IMPORT_IN_P.outputs[0].txid,
+                    outputidx: '0',
+                    addresses: importInP_1.IMPORT_IN_P.outputs[0].addresses,
+                    threshold: importInP_1.IMPORT_IN_P.threshold,
+                },
+            ]);
+            const tx = (await txBuilder.build());
+            // Verify the fee in the built transaction equals the fixedFee
+            tx.fee.fee.should.equal(FIXED_FEE);
+        });
+    });
+    describe('validate txBuilder fields', () => {
+        const txBuilder = factory.getImportInPBuilder();
+        it('should fail target chain id length incorrect', () => {
+            assert_1.default.throws(() => {
+                txBuilder.externalChainId(Buffer.from(importInP_1.IMPORT_IN_P.INVALID_CHAIN_ID));
+            }, (e) => e.message === 'Chain id are 32 byte size');
+        });
+        it('should fail target chain id not a valid base58 string', () => {
+            assert_1.default.throws(() => {
+                txBuilder.externalChainId(importInP_1.IMPORT_IN_P.INVALID_CHAIN_ID);
+            }, (e) => e.message === 'Non-base58 character');
+        });
+        it('should fail target chain id cb58 invalid checksum', () => {
+            assert_1.default.throws(() => {
+                txBuilder.externalChainId(importInP_1.IMPORT_IN_P.VALID_C_CHAIN_ID.slice(2));
+            }, (e) => e.message === 'Invalid checksum');
+        });
+        it('should fail validate Utxos empty string', () => {
+            assert_1.default.throws(() => {
+                txBuilder.validateUtxos([]);
+            }, (e) => e.message === 'UTXOs array cannot be empty');
+        });
+        it('should fail validate Utxos without amount field', () => {
+            assert_1.default.throws(() => {
+                txBuilder.validateUtxos([{ outputID: '' }]);
+            }, (e) => e.message === 'UTXO missing required field: amount');
+        });
+    });
+    (0, signFlowTestSuit_1.default)({
+        transactionType: 'Import P2C',
+        newTxFactory: () => new lib_1.TransactionBuilderFactory(statics_1.coins.get('tflrp')),
+        newTxBuilder: () => new lib_1.TransactionBuilderFactory(statics_1.coins.get('tflrp'))
+            .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),
+        unsignedTxHex: importInP_1.IMPORT_IN_P.unsignedHex,
+        halfSignedTxHex: importInP_1.IMPORT_IN_P.halfSigntxHex,
+        fullSignedTxHex: importInP_1.IMPORT_IN_P.fullSigntxHex,
+        privateKey: {
+            prv1: importInP_1.IMPORT_IN_P.privateKeys[0],
+            prv2: importInP_1.IMPORT_IN_P.privateKeys[1],
+        },
+        txHash: importInP_1.IMPORT_IN_P.txhash,
+    });
+    it('Should full sign a import tx from unsigned raw tx', () => {
+        const txBuilder = new lib_1.TransactionBuilderFactory(statics_1.coins.get('tflrp')).from(importInP_1.IMPORT_IN_P.unsignedHex);
+        txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+        txBuilder
+            .build()
+            .then(() => assert_1.default.fail('it can sign'))
+            .catch((err) => {
+            err.message.should.be.equal('Private key cannot sign the transaction');
+        });
+    });
+    describe('on-chain verified transactions', () => {
+        it('should verify on-chain tx id for signed P-chain import', async () => {
+            const signedImportHex = '0x0000000000110000007200000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000002e79f04000000000000000000000002000000033329be7d01cd3ebaae6654d7327dd9f17a2e15817e918a5e8083ae4c9f2f0ed77055c24bf3665001c7324437c96c7c8a6a152da2385c1db5c3ab1f91000000000000000078db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da555247900000001063ec620d1892f802c8f0c124d05ce1e73a85686bea2b09380fc58f6d72497db0000000058734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000050000000002faf0800000000200000000000000010000000100000009000000022ed4ebc2c81e38820cc7bd6e952d10bd30382fa0679c8a0ba5dc67990a09125656d47eadcc622af935fd5dad654f9b00d3b9563df38e875ef1964e1c9ded851100ec514ace26baefce3ffeab94e3580443abcc3cea669a87c7c26ef8ffa3fe79b330e4bdbacabfd1cce9f7b6a9f2515b4fdf627f7d2678e9532d861a7673444aa700';
+            const txBuilder = new lib_1.TransactionBuilderFactory(statics_1.coins.get('tflrp')).from(signedImportHex);
+            const tx = await txBuilder.build();
+            const rawTx = tx.toBroadcastFormat();
+            rawTx.should.equal(signedImportHex);
+            tx.id.should.equal('2vwvuXp47dsUmqb4vkaMk7UsukrZNapKXT2ruZhVibbjMDpqr9');
+        });
+        it('should FAIL with unsorted UTXO addresses - demonstrates AddressMap mismatch issue', async () => {
+            // This test uses UTXO addresses in UNSORTED order to demonstrate the issue.
+            // With unsorted addresses, the current implementation will create AddressMaps incorrectly
+            // because it uses sorted addresses, not UTXO address order.
+            //
+            // Expected: AddressMap should map addresses to signature slots based on UTXO order (sigIndicies)
+            // Current (WRONG): AddressMap uses sorted addresses with sequential slots
+            //
+            // This test WILL FAIL with current implementation because AddressMaps don't match sigIndicies
+            // UTXO addresses in UNSORTED order (different from sorted)
+            // Sorted would be: [0x12cb... (smallest), 0xa6e0... (middle), 0xc386... (largest)]
+            // Unsorted: [0xc386... (largest), 0x12cb... (smallest), 0xa6e0... (middle)]
+            const unsortedUtxoAddresses = [
+                '0xc386d58d09a9ae77cf1cf07bf1c9de44ebb0c9f3', // Largest (would be index 2 if sorted)
+                '0x12cb32eaf92553064db98d271b56cba079ec78f5', // Smallest (would be index 0 if sorted)
+                '0xa6e0c1abd0132f70efb77e2274637ff336a29a57', // Middle (would be index 1 if sorted)
+            ];
+            // Corresponding P-chain addresses (in same order as UTXO)
+            const pAddresses = [
+                'P-costwo15msvr27szvhhpmah0c38gcml7vm29xjh7tcek8', // Maps to 0xc386... (UTXO index 0)
+                'P-costwo1zt9n96hey4fsvnde35n3k4kt5pu7c784dzewzd', // Maps to 0x12cb... (UTXO index 1)
+                'P-costwo1cwrdtrgf4xh80ncu7palrjw7gn4mpj0n4dxghh', // Maps to 0xa6e0... (UTXO index 2)
+            ];
+            // Create UTXO with UNSORTED addresses
+            const utxo = {
+                outputID: 0,
+                amount: '50000000',
+                txid: 'zstyYq5riDKYDSR3fUYKKkuXKJ1aJCe8WNrXKqEBJD4CGwzFw',
+                outputidx: '0',
+                addresses: unsortedUtxoAddresses, // UNSORTED order
+                threshold: 2,
+            };
+            // Build transaction
+            const txBuilder = factory
+                .getImportInPBuilder()
+                .threshold(2)
+                .locktime(0)
+                .fromPubKey(pAddresses)
+                .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                .fee('1261000')
+                .utxos([utxo]);
+            // Build unsigned transaction
+            const unsignedTx = await txBuilder.build();
+            const unsignedHex = unsignedTx.toBroadcastFormat();
+            // Parse it back to inspect AddressMaps and sigIndicies
+            const parsedBuilder = factory.from(unsignedHex);
+            const parsedTx = await parsedBuilder.build();
+            const flareTx = parsedTx._flareTransaction;
+            // Get the input to check sigIndicies
+            const importTx = flareTx.tx;
+            const input = importTx.ins[0];
+            const transferInput = input.input;
+            const sigIndicies = transferInput.sigIndicies();
+            // sigIndicies tells us: sigIndicies[slotIndex] = utxoAddressIndex
+            // For threshold=2, we need signatures for first 2 addresses in UTXO order
+            // UTXO order: [0xc386... (index 0), 0x12cb... (index 1), 0xa6e0... (index 2)]
+            // So sigIndicies should be [0, 1] meaning: slot 0 = UTXO index 0, slot 1 = UTXO index 1
+            // Verify sigIndicies are [0, 1] (first 2 addresses in UTXO order, NOT sorted order)
+            sigIndicies.length.should.equal(2);
+            sigIndicies[0].should.equal(0, 'First signature slot should be UTXO address index 0 (0xc386...)');
+            sigIndicies[1].should.equal(1, 'Second signature slot should be UTXO address index 1 (0x12cb...)');
+            // Now the key test: AddressMap should map addresses based on sigIndicies (UTXO order)
+            // NOT based on sorted order
+            //
+            // Current implementation (WRONG):
+            // - Sorts addresses: [0x12cb... (smallest), 0xa6e0... (middle), 0xc386... (largest)]
+            // - Maps: sorted[0] -> slot 0, sorted[1] -> slot 1
+            // - This means: 0x12cb... -> slot 0, 0xa6e0... -> slot 1 (WRONG!)
+            //
+            // Expected (CORRECT):
+            // - Uses UTXO order via sigIndicies: sigIndicies[0]=0, sigIndicies[1]=1
+            // - Maps: address at UTXO index 0 (0xc386...) -> slot 0, address at UTXO index 1 (0x12cb...) -> slot 1
+            // - This means: 0xc386... -> slot 0, 0x12cb... -> slot 1 (CORRECT!)
+            // Parse addresses
+            // Address at UTXO index 0 (0xc386...) should map to signature slot 0
+            const pAddr0Bytes = utils_1.default.parseAddress(pAddresses[0]); // Corresponds to UTXO index 0
+            // Address at UTXO index 1 (0x12cb...) should map to signature slot 1
+            const pAddr1Bytes = utils_1.default.parseAddress(pAddresses[1]); // Corresponds to UTXO index 1
+            // Get addresses from AddressMap
+            const addressesInMap = flareTx.getAddresses();
+            // Verify addresses are in the map
+            const addr0InMap = addressesInMap.some((addr) => Buffer.compare(Buffer.from(addr), pAddr0Bytes) === 0);
+            const addr1InMap = addressesInMap.some((addr) => Buffer.compare(Buffer.from(addr), pAddr1Bytes) === 0);
+            addr0InMap.should.be.true('Address at UTXO index 0 should be in AddressMap');
+            addr1InMap.should.be.true('Address at UTXO index 1 should be in AddressMap');
+            // The critical assertion: AddressMap should map addresses to signature slots based on sigIndicies
+            // Since we can't directly access individual AddressMap instances, we verify the behavior
+            // by checking that the transaction structure is correct.
+            //
+            // With current implementation (WRONG):
+            // - AddressMap maps sorted addresses: 0x12cb... -> slot 0, 0xa6e0... -> slot 1
+            // - But sigIndicies say: slot 0 = UTXO index 0 (0xc386...), slot 1 = UTXO index 1 (0x12cb...)
+            // - Mismatch! AddressMap says 0x12cb... -> slot 0, but sigIndicies say slot 0 = 0xc386...
+            //
+            // This mismatch will cause signing to fail because:
+            // - Signing logic uses AddressMap to find which slot to sign
+            // - But credentials expect signatures in slots based on sigIndicies (UTXO order)
+            // - Result: "wrong signature" error on-chain
+            // The critical test: Verify that signature slots have embedded addresses based on UTXO order
+            // With unsorted UTXO addresses, this will FAIL if AddressMaps don't match UTXO order
+            //
+            // sigIndicies tells us: sigIndicies[slotIndex] = utxoAddressIndex
+            // For threshold=2, we need signatures for first 2 addresses in UTXO order
+            // UTXO order: [0xc386... (index 0), 0x12cb... (index 1), 0xa6e0... (index 2)]
+            // So sigIndicies should be [0, 1] meaning: slot 0 = UTXO index 0, slot 1 = UTXO index 1
+            // Parse the credential to see which slots have which embedded addresses
+            const credential = flareTx.credentials[0];
+            const signatures = credential.getSignatures();
+            // Extract embedded addresses from signature slots
+            const embeddedAddresses = [];
+            // Helper function to check if signature has embedded address (same logic as transaction.ts)
+            const isEmptySignature = (signature) => {
+                return !!signature && utils_1.default.removeHexPrefix(signature).startsWith('0'.repeat(90));
+            };
+            const hasEmbeddedAddress = (signature) => {
+                if (!isEmptySignature(signature))
+                    return false;
+                const cleanSig = utils_1.default.removeHexPrefix(signature);
+                if (cleanSig.length < 130)
+                    return false;
+                const embeddedPart = cleanSig.substring(90, 130);
+                // Check if embedded part is not all zeros
+                return embeddedPart !== '0'.repeat(40);
+            };
+            signatures.forEach((sig, slotIndex) => {
+                if (hasEmbeddedAddress(sig)) {
+                    // Extract embedded address (after position 90, 40 chars = 20 bytes)
+                    const cleanSig = utils_1.default.removeHexPrefix(sig);
+                    const embeddedAddr = cleanSig.substring(90, 130).toLowerCase();
+                    embeddedAddresses[slotIndex] = '0x' + embeddedAddr;
+                }
+            });
+            // Verify: Credentials only embed ONE address (user/recovery), not both
+            // The embedded address should be based on addressesIndex logic, not sorted order
+            //
+            // Compute addressesIndex to determine expected signature order
+            const utxoAddressBytes = unsortedUtxoAddresses.map((addr) => utils_1.default.parseAddress(addr));
+            const pAddressBytes = pAddresses.map((addr) => utils_1.default.parseAddress(addr));
+            const addressesIndex = [];
+            pAddressBytes.forEach((pAddr) => {
+                const utxoIndex = utxoAddressBytes.findIndex((uAddr) => Buffer.compare(Buffer.from(uAddr), Buffer.from(pAddr)) === 0);
+                addressesIndex.push(utxoIndex);
+            });
+            // firstIndex = 0 (user), bitgoIndex = 1
+            const firstIndex = 0;
+            const bitgoIndex = 1;
+            // Determine expected signature order based on addressesIndex
+            const userComesFirst = addressesIndex[bitgoIndex] > addressesIndex[firstIndex];
+            // Expected credential structure:
+            // - If user comes first: [userAddress, zeros]
+            // - If bitgo comes first: [zeros, userAddress]
+            const userAddressHex = Buffer.from(pAddressBytes[firstIndex]).toString('hex').toLowerCase();
+            const expectedUserAddr = '0x' + userAddressHex;
+            if (userComesFirst) {
+                // Expected: [userAddress, zeros]
+                // Slot 0 should have user address (pAddr0 = 0xc386... = UTXO index 0)
+                if (embeddedAddresses[0]) {
+                    embeddedAddresses[0]
+                        .toLowerCase()
+                        .should.equal(expectedUserAddr, `Slot 0 should have user address (${expectedUserAddr}) because user comes first in UTXO order`);
+                }
+                else {
+                    throw new Error(`Slot 0 should have embedded user address, but is empty`);
+                }
+                // Slot 1 should be zeros (no embedded address)
+                if (embeddedAddresses[1]) {
+                    throw new Error(`Slot 1 should be zeros, but has embedded address: ${embeddedAddresses[1]}`);
+                }
+            }
+            else {
+                // Expected: [zeros, userAddress]
+                // Slot 0 should be zeros
+                if (embeddedAddresses[0]) {
+                    throw new Error(`Slot 0 should be zeros, but has embedded address: ${embeddedAddresses[0]}`);
+                }
+                // Slot 1 should have user address
+                if (embeddedAddresses[1]) {
+                    embeddedAddresses[1]
+                        .toLowerCase()
+                        .should.equal(expectedUserAddr, `Slot 1 should have user address (${expectedUserAddr}) because bitgo comes first in UTXO order`);
+                }
+                else {
+                    throw new Error(`Slot 1 should have embedded user address, but is empty`);
+                }
+            }
+            // The key verification: AddressMaps should match the credential order
+            // With the fix, AddressMaps are created using the same addressesIndex logic as credentials
+            // This ensures signing works correctly even with unsorted UTXO addresses
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"importInPTxBuilder.js","sourceRoot":"","sources":["../../../../test/unit/lib/importInPTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport 'should';\nimport { IMPORT_IN_P as testData } from '../../resources/transactionData/importInP';\nimport { TransactionBuilderFactory, DecodedUtxoObj, Transaction } from '../../../src/lib';\nimport { coins, FlareNetwork } from '@bitgo-beta/statics';\nimport signFlowTest from './signFlowTestSuit';\nimport testUtils from '../../../src/lib/utils';\n\ndescribe('Flrp Import In P Tx Builder', () => {\n  const coinConfig = coins.get('tflrp');\n  const factory = new TransactionBuilderFactory(coinConfig);\n\n  describe('default fee', () => {\n    const FIXED_FEE = (coinConfig.network as FlareNetwork).txFee;\n\n    it('should set fixedFee (1261000) by default in constructor', () => {\n      const txBuilder = factory.getImportInPBuilder();\n      // The fixedFee should be set from network.txFee = '1261000'\n      const transaction = (txBuilder as any).transaction;\n      transaction._fee.fee.should.equal(FIXED_FEE);\n    });\n\n    it('should use default fixedFee when fee is not explicitly set', async () => {\n      // Create a UTXO with enough balance to cover the default fee\n      const utxoAmount = '50000000'; // 0.05 FLR - enough to cover fee and have output\n\n      const txBuilder = factory\n        .getImportInPBuilder()\n        .threshold(testData.threshold)\n        .locktime(testData.locktime)\n        .fromPubKey(testData.pAddresses)\n        .externalChainId(testData.sourceChainId)\n        // NOTE: .fee() is NOT called - should use default fixedFee\n        .utxos([\n          {\n            outputID: 0,\n            amount: utxoAmount,\n            txid: testData.outputs[0].txid,\n            outputidx: '0',\n            addresses: testData.outputs[0].addresses,\n            threshold: testData.threshold,\n          },\n        ]);\n\n      const tx = (await txBuilder.build()) as Transaction;\n\n      // Verify the fee in the built transaction equals the fixedFee\n      tx.fee.fee.should.equal(FIXED_FEE);\n    });\n  });\n\n  describe('validate txBuilder fields', () => {\n    const txBuilder = factory.getImportInPBuilder();\n\n    it('should fail target chain id length incorrect', () => {\n      assert.throws(\n        () => {\n          txBuilder.externalChainId(Buffer.from(testData.INVALID_CHAIN_ID));\n        },\n        (e: any) => e.message === 'Chain id are 32 byte size'\n      );\n    });\n\n    it('should fail target chain id not a valid base58 string', () => {\n      assert.throws(\n        () => {\n          txBuilder.externalChainId(testData.INVALID_CHAIN_ID);\n        },\n        (e: any) => e.message === 'Non-base58 character'\n      );\n    });\n\n    it('should fail target chain id cb58 invalid checksum', () => {\n      assert.throws(\n        () => {\n          txBuilder.externalChainId(testData.VALID_C_CHAIN_ID.slice(2));\n        },\n        (e: any) => e.message === 'Invalid checksum'\n      );\n    });\n\n    it('should fail validate Utxos empty string', () => {\n      assert.throws(\n        () => {\n          txBuilder.validateUtxos([]);\n        },\n        (e: any) => e.message === 'UTXOs array cannot be empty'\n      );\n    });\n\n    it('should fail validate Utxos without amount field', () => {\n      assert.throws(\n        () => {\n          txBuilder.validateUtxos([{ outputID: '' } as any as DecodedUtxoObj]);\n        },\n        (e: any) => e.message === 'UTXO missing required field: amount'\n      );\n    });\n  });\n\n  signFlowTest({\n    transactionType: 'Import P2C',\n    newTxFactory: () => new TransactionBuilderFactory(coins.get('tflrp')),\n    newTxBuilder: () =>\n      new TransactionBuilderFactory(coins.get('tflrp'))\n        .getImportInPBuilder()\n        .threshold(testData.threshold)\n        .locktime(testData.locktime)\n        .fromPubKey(testData.pAddresses)\n        .externalChainId(testData.sourceChainId)\n        .fee(testData.fee)\n        .utxos(testData.outputs),\n    unsignedTxHex: testData.unsignedHex,\n    halfSignedTxHex: testData.halfSigntxHex,\n    fullSignedTxHex: testData.fullSigntxHex,\n    privateKey: {\n      prv1: testData.privateKeys[0],\n      prv2: testData.privateKeys[1],\n    },\n    txHash: testData.txhash,\n  });\n\n  it('Should full sign a import tx from unsigned raw tx', () => {\n    const txBuilder = new TransactionBuilderFactory(coins.get('tflrp')).from(testData.unsignedHex);\n    txBuilder.sign({ key: testData.privateKeys[0] });\n    txBuilder\n      .build()\n      .then(() => assert.fail('it can sign'))\n      .catch((err) => {\n        err.message.should.be.equal('Private key cannot sign the transaction');\n      });\n  });\n\n  describe('on-chain verified transactions', () => {\n    it('should verify on-chain tx id for signed P-chain import', async () => {\n      const signedImportHex =\n        '0x0000000000110000007200000000000000000000000000000000000000000000000000000000000000000000000158734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000070000000002e79f04000000000000000000000002000000033329be7d01cd3ebaae6654d7327dd9f17a2e15817e918a5e8083ae4c9f2f0ed77055c24bf3665001c7324437c96c7c8a6a152da2385c1db5c3ab1f91000000000000000078db5c30bed04c05ce209179812850bbb3fe6d46d7eef3744d814c0da555247900000001063ec620d1892f802c8f0c124d05ce1e73a85686bea2b09380fc58f6d72497db0000000058734f94af871c3d131b56131b6fb7a0291eacadd261e69dfb42a9cdf6f7fddd000000050000000002faf0800000000200000000000000010000000100000009000000022ed4ebc2c81e38820cc7bd6e952d10bd30382fa0679c8a0ba5dc67990a09125656d47eadcc622af935fd5dad654f9b00d3b9563df38e875ef1964e1c9ded851100ec514ace26baefce3ffeab94e3580443abcc3cea669a87c7c26ef8ffa3fe79b330e4bdbacabfd1cce9f7b6a9f2515b4fdf627f7d2678e9532d861a7673444aa700';\n      const txBuilder = new TransactionBuilderFactory(coins.get('tflrp')).from(signedImportHex);\n      const tx = await txBuilder.build();\n      const rawTx = tx.toBroadcastFormat();\n      rawTx.should.equal(signedImportHex);\n      tx.id.should.equal('2vwvuXp47dsUmqb4vkaMk7UsukrZNapKXT2ruZhVibbjMDpqr9');\n    });\n\n    it('should FAIL with unsorted UTXO addresses - demonstrates AddressMap mismatch issue', async () => {\n      // This test uses UTXO addresses in UNSORTED order to demonstrate the issue.\n      // With unsorted addresses, the current implementation will create AddressMaps incorrectly\n      // because it uses sorted addresses, not UTXO address order.\n      //\n      // Expected: AddressMap should map addresses to signature slots based on UTXO order (sigIndicies)\n      // Current (WRONG): AddressMap uses sorted addresses with sequential slots\n      //\n      // This test WILL FAIL with current implementation because AddressMaps don't match sigIndicies\n\n      // UTXO addresses in UNSORTED order (different from sorted)\n      // Sorted would be: [0x12cb... (smallest), 0xa6e0... (middle), 0xc386... (largest)]\n      // Unsorted: [0xc386... (largest), 0x12cb... (smallest), 0xa6e0... (middle)]\n      const unsortedUtxoAddresses = [\n        '0xc386d58d09a9ae77cf1cf07bf1c9de44ebb0c9f3', // Largest (would be index 2 if sorted)\n        '0x12cb32eaf92553064db98d271b56cba079ec78f5', // Smallest (would be index 0 if sorted)\n        '0xa6e0c1abd0132f70efb77e2274637ff336a29a57', // Middle (would be index 1 if sorted)\n      ];\n\n      // Corresponding P-chain addresses (in same order as UTXO)\n      const pAddresses = [\n        'P-costwo15msvr27szvhhpmah0c38gcml7vm29xjh7tcek8', // Maps to 0xc386... (UTXO index 0)\n        'P-costwo1zt9n96hey4fsvnde35n3k4kt5pu7c784dzewzd', // Maps to 0x12cb... (UTXO index 1)\n        'P-costwo1cwrdtrgf4xh80ncu7palrjw7gn4mpj0n4dxghh', // Maps to 0xa6e0... (UTXO index 2)\n      ];\n\n      // Create UTXO with UNSORTED addresses\n      const utxo: DecodedUtxoObj = {\n        outputID: 0,\n        amount: '50000000',\n        txid: 'zstyYq5riDKYDSR3fUYKKkuXKJ1aJCe8WNrXKqEBJD4CGwzFw',\n        outputidx: '0',\n        addresses: unsortedUtxoAddresses, // UNSORTED order\n        threshold: 2,\n      };\n\n      // Build transaction\n      const txBuilder = factory\n        .getImportInPBuilder()\n        .threshold(2)\n        .locktime(0)\n        .fromPubKey(pAddresses)\n        .externalChainId(testData.sourceChainId)\n        .fee('1261000')\n        .utxos([utxo]);\n\n      // Build unsigned transaction\n      const unsignedTx = await txBuilder.build();\n      const unsignedHex = unsignedTx.toBroadcastFormat();\n\n      // Parse it back to inspect AddressMaps and sigIndicies\n      const parsedBuilder = factory.from(unsignedHex);\n      const parsedTx = await parsedBuilder.build();\n      const flareTx = (parsedTx as any)._flareTransaction;\n\n      // Get the input to check sigIndicies\n      const importTx = flareTx.tx as any;\n      const input = importTx.ins[0];\n      const transferInput = input.input;\n      const sigIndicies = transferInput.sigIndicies();\n\n      // sigIndicies tells us: sigIndicies[slotIndex] = utxoAddressIndex\n      // For threshold=2, we need signatures for first 2 addresses in UTXO order\n      // UTXO order: [0xc386... (index 0), 0x12cb... (index 1), 0xa6e0... (index 2)]\n      // So sigIndicies should be [0, 1] meaning: slot 0 = UTXO index 0, slot 1 = UTXO index 1\n\n      // Verify sigIndicies are [0, 1] (first 2 addresses in UTXO order, NOT sorted order)\n      sigIndicies.length.should.equal(2);\n      sigIndicies[0].should.equal(0, 'First signature slot should be UTXO address index 0 (0xc386...)');\n      sigIndicies[1].should.equal(1, 'Second signature slot should be UTXO address index 1 (0x12cb...)');\n\n      // Now the key test: AddressMap should map addresses based on sigIndicies (UTXO order)\n      // NOT based on sorted order\n      //\n      // Current implementation (WRONG):\n      // - Sorts addresses: [0x12cb... (smallest), 0xa6e0... (middle), 0xc386... (largest)]\n      // - Maps: sorted[0] -> slot 0, sorted[1] -> slot 1\n      // - This means: 0x12cb... -> slot 0, 0xa6e0... -> slot 1 (WRONG!)\n      //\n      // Expected (CORRECT):\n      // - Uses UTXO order via sigIndicies: sigIndicies[0]=0, sigIndicies[1]=1\n      // - Maps: address at UTXO index 0 (0xc386...) -> slot 0, address at UTXO index 1 (0x12cb...) -> slot 1\n      // - This means: 0xc386... -> slot 0, 0x12cb... -> slot 1 (CORRECT!)\n\n      // Parse addresses\n      // Address at UTXO index 0 (0xc386...) should map to signature slot 0\n      const pAddr0Bytes = testUtils.parseAddress(pAddresses[0]); // Corresponds to UTXO index 0\n\n      // Address at UTXO index 1 (0x12cb...) should map to signature slot 1\n      const pAddr1Bytes = testUtils.parseAddress(pAddresses[1]); // Corresponds to UTXO index 1\n\n      // Get addresses from AddressMap\n      const addressesInMap = flareTx.getAddresses();\n\n      // Verify addresses are in the map\n      const addr0InMap = addressesInMap.some((addr) => Buffer.compare(Buffer.from(addr), pAddr0Bytes) === 0);\n      const addr1InMap = addressesInMap.some((addr) => Buffer.compare(Buffer.from(addr), pAddr1Bytes) === 0);\n\n      addr0InMap.should.be.true('Address at UTXO index 0 should be in AddressMap');\n      addr1InMap.should.be.true('Address at UTXO index 1 should be in AddressMap');\n\n      // The critical assertion: AddressMap should map addresses to signature slots based on sigIndicies\n      // Since we can't directly access individual AddressMap instances, we verify the behavior\n      // by checking that the transaction structure is correct.\n      //\n      // With current implementation (WRONG):\n      // - AddressMap maps sorted addresses: 0x12cb... -> slot 0, 0xa6e0... -> slot 1\n      // - But sigIndicies say: slot 0 = UTXO index 0 (0xc386...), slot 1 = UTXO index 1 (0x12cb...)\n      // - Mismatch! AddressMap says 0x12cb... -> slot 0, but sigIndicies say slot 0 = 0xc386...\n      //\n      // This mismatch will cause signing to fail because:\n      // - Signing logic uses AddressMap to find which slot to sign\n      // - But credentials expect signatures in slots based on sigIndicies (UTXO order)\n      // - Result: \"wrong signature\" error on-chain\n\n      // The critical test: Verify that signature slots have embedded addresses based on UTXO order\n      // With unsorted UTXO addresses, this will FAIL if AddressMaps don't match UTXO order\n      //\n      // sigIndicies tells us: sigIndicies[slotIndex] = utxoAddressIndex\n      // For threshold=2, we need signatures for first 2 addresses in UTXO order\n      // UTXO order: [0xc386... (index 0), 0x12cb... (index 1), 0xa6e0... (index 2)]\n      // So sigIndicies should be [0, 1] meaning: slot 0 = UTXO index 0, slot 1 = UTXO index 1\n\n      // Parse the credential to see which slots have which embedded addresses\n      const credential = flareTx.credentials[0];\n      const signatures = credential.getSignatures();\n\n      // Extract embedded addresses from signature slots\n      const embeddedAddresses: string[] = [];\n\n      // Helper function to check if signature has embedded address (same logic as transaction.ts)\n      const isEmptySignature = (signature: string): boolean => {\n        return !!signature && testUtils.removeHexPrefix(signature).startsWith('0'.repeat(90));\n      };\n\n      const hasEmbeddedAddress = (signature: string): boolean => {\n        if (!isEmptySignature(signature)) return false;\n        const cleanSig = testUtils.removeHexPrefix(signature);\n        if (cleanSig.length < 130) return false;\n        const embeddedPart = cleanSig.substring(90, 130);\n        // Check if embedded part is not all zeros\n        return embeddedPart !== '0'.repeat(40);\n      };\n\n      signatures.forEach((sig: string, slotIndex: number) => {\n        if (hasEmbeddedAddress(sig)) {\n          // Extract embedded address (after position 90, 40 chars = 20 bytes)\n          const cleanSig = testUtils.removeHexPrefix(sig);\n          const embeddedAddr = cleanSig.substring(90, 130).toLowerCase();\n          embeddedAddresses[slotIndex] = '0x' + embeddedAddr;\n        }\n      });\n\n      // Verify: Credentials only embed ONE address (user/recovery), not both\n      // The embedded address should be based on addressesIndex logic, not sorted order\n      //\n      // Compute addressesIndex to determine expected signature order\n      const utxoAddressBytes = unsortedUtxoAddresses.map((addr) => testUtils.parseAddress(addr));\n      const pAddressBytes = pAddresses.map((addr) => testUtils.parseAddress(addr));\n\n      const addressesIndex: number[] = [];\n      pAddressBytes.forEach((pAddr) => {\n        const utxoIndex = utxoAddressBytes.findIndex(\n          (uAddr) => Buffer.compare(Buffer.from(uAddr), Buffer.from(pAddr)) === 0\n        );\n        addressesIndex.push(utxoIndex);\n      });\n\n      // firstIndex = 0 (user), bitgoIndex = 1\n      const firstIndex = 0;\n      const bitgoIndex = 1;\n\n      // Determine expected signature order based on addressesIndex\n      const userComesFirst = addressesIndex[bitgoIndex] > addressesIndex[firstIndex];\n\n      // Expected credential structure:\n      // - If user comes first: [userAddress, zeros]\n      // - If bitgo comes first: [zeros, userAddress]\n      const userAddressHex = Buffer.from(pAddressBytes[firstIndex]).toString('hex').toLowerCase();\n      const expectedUserAddr = '0x' + userAddressHex;\n\n      if (userComesFirst) {\n        // Expected: [userAddress, zeros]\n        // Slot 0 should have user address (pAddr0 = 0xc386... = UTXO index 0)\n        if (embeddedAddresses[0]) {\n          embeddedAddresses[0]\n            .toLowerCase()\n            .should.equal(\n              expectedUserAddr,\n              `Slot 0 should have user address (${expectedUserAddr}) because user comes first in UTXO order`\n            );\n        } else {\n          throw new Error(`Slot 0 should have embedded user address, but is empty`);\n        }\n        // Slot 1 should be zeros (no embedded address)\n        if (embeddedAddresses[1]) {\n          throw new Error(`Slot 1 should be zeros, but has embedded address: ${embeddedAddresses[1]}`);\n        }\n      } else {\n        // Expected: [zeros, userAddress]\n        // Slot 0 should be zeros\n        if (embeddedAddresses[0]) {\n          throw new Error(`Slot 0 should be zeros, but has embedded address: ${embeddedAddresses[0]}`);\n        }\n        // Slot 1 should have user address\n        if (embeddedAddresses[1]) {\n          embeddedAddresses[1]\n            .toLowerCase()\n            .should.equal(\n              expectedUserAddr,\n              `Slot 1 should have user address (${expectedUserAddr}) because bitgo comes first in UTXO order`\n            );\n        } else {\n          throw new Error(`Slot 1 should have embedded user address, but is empty`);\n        }\n      }\n\n      // The key verification: AddressMaps should match the credential order\n      // With the fix, AddressMaps are created using the same addressesIndex logic as credentials\n      // This ensures signing works correctly even with unsorted UTXO addresses\n    });\n  });\n});\n"]}

package/dist/test/unit/lib/keyPair.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=keyPair.d.ts.map

package/dist/test/unit/lib/keyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../../test/unit/lib/keyPair.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const should_1 = __importDefault(require("should"));
+const lib_1 = require("../../../src/lib");
+const testData = __importStar(require("../../resources/account"));
+const pubKey = testData.ACCOUNT_1.publicKey;
+const prvKey = testData.ACCOUNT_1.privateKey;
+describe('Flr P Key Pair', () => {
+    describe('should create a valid KeyPair', () => {
+        it('from an empty value', () => {
+            const keyPair = new lib_1.KeyPair();
+            const pubKey = keyPair.getKeys().pub;
+            const prvKey = keyPair.getKeys().prv;
+            should_1.default.exists(pubKey);
+            should_1.default.exists(prvKey);
+        });
+        it('from a seed', () => {
+            const seed = testData.SEED_ACCOUNT.seed;
+            const keyPairObj = new lib_1.KeyPair({ seed: Buffer.from(seed, 'hex') });
+            const keys = keyPairObj.getKeys();
+            should_1.default.exists(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.equal(keys.prv, testData.SEED_ACCOUNT.privateKey);
+            should_1.default.equal(keys.pub, testData.SEED_ACCOUNT.publicKey);
+            const extendedKeys = keyPairObj.getExtendedKeys();
+            should_1.default.exists(extendedKeys.xprv);
+            should_1.default.exists(extendedKeys.xpub);
+            should_1.default.equal(extendedKeys.xprv, testData.SEED_ACCOUNT.xPrivateKey);
+            should_1.default.equal(extendedKeys.xpub, testData.SEED_ACCOUNT.xPublicKey);
+        });
+        it('from a xprv', () => {
+            const keyPairObj = new lib_1.KeyPair({ prv: testData.SEED_ACCOUNT.xPrivateKey });
+            const keys = keyPairObj.getKeys();
+            should_1.default.exists(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.equal(keys.prv, testData.SEED_ACCOUNT.privateKey);
+            should_1.default.equal(keys.pub, testData.SEED_ACCOUNT.publicKey);
+            const extendedKeys = keyPairObj.getExtendedKeys();
+            should_1.default.exists(extendedKeys.xprv);
+            should_1.default.exists(extendedKeys.xpub);
+            should_1.default.equal(extendedKeys.xprv, testData.SEED_ACCOUNT.xPrivateKey);
+            should_1.default.equal(extendedKeys.xpub, testData.SEED_ACCOUNT.xPublicKey);
+        });
+        it('from a xpub', () => {
+            const keyPairObj = new lib_1.KeyPair({ pub: testData.SEED_ACCOUNT.xPublicKey });
+            const keys = keyPairObj.getKeys();
+            should_1.default.not.exists(keys.prv);
+            should_1.default.exists(keys.pub);
+            should_1.default.equal(keys.pub, testData.SEED_ACCOUNT.publicKey);
+            const extendedKeys = keyPairObj.getExtendedKeys();
+            should_1.default.not.exists(extendedKeys.xprv);
+            should_1.default.exists(extendedKeys.xpub);
+            should_1.default.equal(extendedKeys.xpub, testData.SEED_ACCOUNT.xPublicKey);
+        });
+        it('from a public key', () => {
+            const keyPair = new lib_1.KeyPair({ pub: testData.ACCOUNT_3.publicKey });
+            should_1.default.equal(keyPair.getKeys().pub, testData.ACCOUNT_3.publicKey);
+            should_1.default.exists(keyPair.getAddress());
+        });
+        it('Should get same address key for account 3 private key ', () => {
+            const keyPair = new lib_1.KeyPair({ prv: testData.ACCOUNT_3.privateKey });
+            should_1.default.equal(keyPair.getKeys().prv, testData.ACCOUNT_3.privateKey);
+            should_1.default.equal(keyPair.getKeys().pub, testData.ACCOUNT_3.publicKey);
+            should_1.default.equal(keyPair.getAddress('testnet'), testData.ACCOUNT_3.address);
+        });
+        it('Should get same address key for account 4 private key ', () => {
+            const keyPair = new lib_1.KeyPair({ prv: testData.ACCOUNT_4.privateKey });
+            should_1.default.equal(keyPair.getKeys().prv, testData.ACCOUNT_4.privateKey);
+            should_1.default.equal(keyPair.getKeys().pub, testData.ACCOUNT_4.publicKey);
+            should_1.default.equal(keyPair.getAddress('testnet'), testData.ACCOUNT_4.address);
+        });
+        describe('getAddress', function () {
+            it('should get an address', () => {
+                const seed = testData.SEED_ACCOUNT.seed;
+                const keyPair = new lib_1.KeyPair({ seed: Buffer.from(seed, 'hex') });
+                const address = keyPair.getAddress();
+                address.should.equal(testData.SEED_ACCOUNT.addressMainnet);
+            });
+        });
+        it('without source', () => {
+            const keyPair = new lib_1.KeyPair();
+            keyPair.getKeys().should.have.property('pub');
+            keyPair.getKeys().should.have.property('prv');
+        });
+    });
+    describe('should fail to create a KeyPair', () => {
+        it('from an invalid public key', () => {
+            assert_1.default.throws(() => new lib_1.KeyPair({ pub: testData.INVALID_SHORT_KEYPAIR_KEY }), (e) => e.message === testData.INVALID_PUBLIC_KEY_ERROR_MESSAGE);
+        });
+        it('from an invalid private key', () => {
+            assert_1.default.throws(() => new lib_1.KeyPair({ prv: testData.INVALID_SHORT_KEYPAIR_KEY }), (e) => e.message === testData.INVALID_PRIVATE_KEY_ERROR_MESSAGE);
+            assert_1.default.throws(() => {
+                new lib_1.KeyPair({ prv: testData.INVALID_LONG_KEYPAIR_PRV });
+            }, (e) => e.message === testData.INVALID_PRIVATE_KEY_ERROR_MESSAGE);
+            assert_1.default.throws(() => new lib_1.KeyPair({ prv: prvKey + pubKey }), (e) => e.message === testData.INVALID_PRIVATE_KEY_ERROR_MESSAGE);
+        });
+    });
+    describe('verifyAddress', function () {
+        it('should get and match mainnet address', () => {
+            const seed = testData.SEED_ACCOUNT.seed;
+            const keyPair = new lib_1.KeyPair({ seed: Buffer.from(seed, 'hex') });
+            const address = keyPair.getAddress();
+            address.should.equal(testData.SEED_ACCOUNT.addressMainnet);
+            const prv = testData.ACCOUNT_1.privateKey;
+            const keyPair2 = new lib_1.KeyPair({ prv: prv });
+            const address2 = keyPair2.getAddress();
+            address2.should.equal(testData.ACCOUNT_1.addressMainnet);
+        });
+        it('should get and match testnet address', () => {
+            const seed = testData.SEED_ACCOUNT.seed;
+            const keyPair = new lib_1.KeyPair({ seed: Buffer.from(seed, 'hex') });
+            const address = keyPair.getAddress('testnet');
+            address.should.equal(testData.SEED_ACCOUNT.addressTestnet);
+            const prv = testData.ACCOUNT_1.privateKey;
+            const keyPair2 = new lib_1.KeyPair({ prv: prv });
+            const address2 = keyPair2.getAddress('testnet');
+            address2.should.equal(testData.ACCOUNT_1.addressTestnet);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyPair.js","sourceRoot":"","sources":["../../../../test/unit/lib/keyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport should from 'should';\nimport { KeyPair } from '../../../src/lib';\nimport * as testData from '../../resources/account';\n\nconst pubKey = testData.ACCOUNT_1.publicKey;\nconst prvKey = testData.ACCOUNT_1.privateKey;\n\ndescribe('Flr P Key Pair', () => {\n  describe('should create a valid KeyPair', () => {\n    it('from an empty value', () => {\n      const keyPair = new KeyPair();\n      const pubKey = keyPair.getKeys().pub;\n      const prvKey = keyPair.getKeys().prv;\n      should.exists(pubKey);\n      should.exists(prvKey);\n    });\n\n    it('from a seed', () => {\n      const seed = testData.SEED_ACCOUNT.seed;\n      const keyPairObj = new KeyPair({ seed: Buffer.from(seed, 'hex') });\n      const keys = keyPairObj.getKeys();\n      should.exists(keys.prv);\n      should.exists(keys.pub);\n      should.equal(keys.prv!, testData.SEED_ACCOUNT.privateKey);\n      should.equal(keys.pub, testData.SEED_ACCOUNT.publicKey);\n\n      const extendedKeys = keyPairObj.getExtendedKeys();\n      should.exists(extendedKeys.xprv);\n      should.exists(extendedKeys.xpub);\n      should.equal(extendedKeys.xprv, testData.SEED_ACCOUNT.xPrivateKey);\n      should.equal(extendedKeys.xpub, testData.SEED_ACCOUNT.xPublicKey);\n    });\n\n    it('from a xprv', () => {\n      const keyPairObj = new KeyPair({ prv: testData.SEED_ACCOUNT.xPrivateKey });\n      const keys = keyPairObj.getKeys();\n      should.exists(keys.prv);\n      should.exists(keys.pub);\n      should.equal(keys.prv!, testData.SEED_ACCOUNT.privateKey);\n      should.equal(keys.pub, testData.SEED_ACCOUNT.publicKey);\n\n      const extendedKeys = keyPairObj.getExtendedKeys();\n      should.exists(extendedKeys.xprv);\n      should.exists(extendedKeys.xpub);\n      should.equal(extendedKeys.xprv, testData.SEED_ACCOUNT.xPrivateKey);\n      should.equal(extendedKeys.xpub, testData.SEED_ACCOUNT.xPublicKey);\n    });\n\n    it('from a xpub', () => {\n      const keyPairObj = new KeyPair({ pub: testData.SEED_ACCOUNT.xPublicKey });\n      const keys = keyPairObj.getKeys();\n      should.not.exists(keys.prv);\n      should.exists(keys.pub);\n      should.equal(keys.pub, testData.SEED_ACCOUNT.publicKey);\n\n      const extendedKeys = keyPairObj.getExtendedKeys();\n      should.not.exists(extendedKeys.xprv);\n      should.exists(extendedKeys.xpub);\n      should.equal(extendedKeys.xpub, testData.SEED_ACCOUNT.xPublicKey);\n    });\n\n    it('from a public key', () => {\n      const keyPair = new KeyPair({ pub: testData.ACCOUNT_3.publicKey });\n      should.equal(keyPair.getKeys().pub, testData.ACCOUNT_3.publicKey);\n      should.exists(keyPair.getAddress());\n    });\n\n    it('Should get same address key for account 3 private key ', () => {\n      const keyPair = new KeyPair({ prv: testData.ACCOUNT_3.privateKey });\n      should.equal(keyPair.getKeys().prv, testData.ACCOUNT_3.privateKey);\n      should.equal(keyPair.getKeys().pub, testData.ACCOUNT_3.publicKey);\n      should.equal(keyPair.getAddress('testnet'), testData.ACCOUNT_3.address);\n    });\n\n    it('Should get same address key for account 4 private key ', () => {\n      const keyPair = new KeyPair({ prv: testData.ACCOUNT_4.privateKey });\n      should.equal(keyPair.getKeys().prv, testData.ACCOUNT_4.privateKey);\n      should.equal(keyPair.getKeys().pub, testData.ACCOUNT_4.publicKey);\n      should.equal(keyPair.getAddress('testnet'), testData.ACCOUNT_4.address);\n    });\n\n    describe('getAddress', function () {\n      it('should get an address', () => {\n        const seed = testData.SEED_ACCOUNT.seed;\n        const keyPair = new KeyPair({ seed: Buffer.from(seed, 'hex') });\n        const address = keyPair.getAddress();\n        address.should.equal(testData.SEED_ACCOUNT.addressMainnet);\n      });\n    });\n\n    it('without source', () => {\n      const keyPair = new KeyPair();\n      keyPair.getKeys().should.have.property('pub');\n      keyPair.getKeys().should.have.property('prv');\n    });\n  });\n\n  describe('should fail to create a KeyPair', () => {\n    it('from an invalid public key', () => {\n      assert.throws(\n        () => new KeyPair({ pub: testData.INVALID_SHORT_KEYPAIR_KEY }),\n        (e: any) => e.message === testData.INVALID_PUBLIC_KEY_ERROR_MESSAGE\n      );\n    });\n\n    it('from an invalid private key', () => {\n      assert.throws(\n        () => new KeyPair({ prv: testData.INVALID_SHORT_KEYPAIR_KEY }),\n        (e: any) => e.message === testData.INVALID_PRIVATE_KEY_ERROR_MESSAGE\n      );\n      assert.throws(\n        () => {\n          new KeyPair({ prv: testData.INVALID_LONG_KEYPAIR_PRV });\n        },\n        (e: any) => e.message === testData.INVALID_PRIVATE_KEY_ERROR_MESSAGE\n      );\n      assert.throws(\n        () => new KeyPair({ prv: prvKey + pubKey }),\n        (e: any) => e.message === testData.INVALID_PRIVATE_KEY_ERROR_MESSAGE\n      );\n    });\n  });\n\n  describe('verifyAddress', function () {\n    it('should get and match mainnet address', () => {\n      const seed = testData.SEED_ACCOUNT.seed;\n      const keyPair = new KeyPair({ seed: Buffer.from(seed, 'hex') });\n      const address = keyPair.getAddress();\n      address.should.equal(testData.SEED_ACCOUNT.addressMainnet);\n\n      const prv = testData.ACCOUNT_1.privateKey;\n      const keyPair2 = new KeyPair({ prv: prv });\n      const address2 = keyPair2.getAddress();\n      address2.should.equal(testData.ACCOUNT_1.addressMainnet);\n    });\n\n    it('should get and match testnet address', () => {\n      const seed = testData.SEED_ACCOUNT.seed;\n      const keyPair = new KeyPair({ seed: Buffer.from(seed, 'hex') });\n      const address = keyPair.getAddress('testnet');\n      address.should.equal(testData.SEED_ACCOUNT.addressTestnet);\n\n      const prv = testData.ACCOUNT_1.privateKey;\n      const keyPair2 = new KeyPair({ prv: prv });\n      const address2 = keyPair2.getAddress('testnet');\n      address2.should.equal(testData.ACCOUNT_1.addressTestnet);\n    });\n  });\n});\n"]}

package/dist/test/unit/lib/signFlowTestSuit.d.ts

@@ -0,0 +1,20 @@
+import { BaseTransactionBuilder, BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
+export interface signFlowTestSuitArgs {
+    transactionType: string;
+    newTxFactory: () => BaseTransactionBuilderFactory;
+    newTxBuilder: () => BaseTransactionBuilder;
+    unsignedTxHex: string;
+    halfSignedTxHex: string;
+    fullSignedTxHex: string;
+    privateKey: {
+        prv1: string;
+        prv2: string;
+    };
+    txHash: string;
+}
+/**
+ * Test suit focus in raw tx signing changes.
+ * @param {signFlowTestSuitArgs} data with require info.
+ */
+export default function signFlowTestSuit(data: signFlowTestSuitArgs): void;
+//# sourceMappingURL=signFlowTestSuit.d.ts.map

package/dist/test/unit/lib/signFlowTestSuit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signFlowTestSuit.d.ts","sourceRoot":"","sources":["../../../../test/unit/lib/signFlowTestSuit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAE7F,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,6BAA6B,CAAC;IAClD,YAAY,EAAE,MAAM,sBAAsB,CAAC;IAC3C,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAqFzE"}