@bitgo-beta/sdk-coin-flrp 1.0.1-beta.40 → 1.0.1-beta.401

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

@@ -0,0 +1,1173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Comprehensive test suite for signature index handling in FLRP atomic transactions.
+ *
+ * This tests the alignment with AVAX P implementation for:
+ * 1. addressesIndex computation (mapping sender addresses to UTXO positions)
+ * 2. Signature slot ordering (based on UTXO address positions)
+ * 3. Two-phase signing flow (build -> parse -> sign -> parse -> sign)
+ * 4. Different UTXO address orderings
+ * 5. Mixed threshold UTXOs (threshold=1 and threshold=2)
+ * 6. Recovery signing scenarios
+ */
+require("should");
+const lib_1 = require("../../../src/lib");
+const statics_1 = require("@bitgo-beta/statics");
+const importInP_1 = require("../../resources/transactionData/importInP");
+const importInC_1 = require("../../resources/transactionData/importInC");
+const exportInP_1 = require("../../resources/transactionData/exportInP");
+describe('Signature Index Handling - AVAX P Alignment', () => {
+    const coinConfig = statics_1.coins.get('tflrp');
+    const newFactory = () => new lib_1.TransactionBuilderFactory(coinConfig);
+    describe('addressesIndex Computation', () => {
+        describe('Import In P - addressesIndex scenarios', () => {
+            it('should compute addressesIndex correctly when UTXO addresses differ from sender order', async () => {
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.type.should.equal(23);
+                txJson.threshold.should.equal(2);
+            });
+            it('should handle UTXO where addresses match sender order exactly', async () => {
+                const utxosMatchingOrder = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        addresses: [importInP_1.IMPORT_IN_P.pAddresses[0], importInP_1.IMPORT_IN_P.pAddresses[1], importInP_1.IMPORT_IN_P.pAddresses[2]],
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(utxosMatchingOrder);
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.signatures.length.should.equal(2);
+            });
+            it('should handle UTXO where bitgo address comes before user in UTXO list', async () => {
+                const utxosBitgoFirst = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        addresses: [importInP_1.IMPORT_IN_P.pAddresses[1], importInP_1.IMPORT_IN_P.pAddresses[0], importInP_1.IMPORT_IN_P.pAddresses[2]],
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(utxosBitgoFirst);
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.signatures.length.should.equal(2);
+                tx.toBroadcastFormat().should.be.a.String();
+            });
+            it('should handle UTXO where user address comes before bitgo in UTXO list', async () => {
+                const utxosUserFirst = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        addresses: [importInP_1.IMPORT_IN_P.pAddresses[0], importInP_1.IMPORT_IN_P.pAddresses[1], importInP_1.IMPORT_IN_P.pAddresses[2]],
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(utxosUserFirst);
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.signatures.length.should.equal(2);
+                tx.toBroadcastFormat().should.be.a.String();
+            });
+        });
+        describe('Import In C - addressesIndex scenarios', () => {
+            it('should compute addressesIndex correctly for C-chain import with multiple UTXOs', async () => {
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(importInC_1.IMPORT_IN_C.utxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.type.should.equal(23);
+            });
+            it('should handle multiple UTXOs with same address ordering', async () => {
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(importInC_1.IMPORT_IN_C.utxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.signatures.length.should.equal(2);
+            });
+        });
+        describe('Export In P - addressesIndex scenarios with mixed thresholds', () => {
+            it('should handle UTXOs with different thresholds (threshold=1 and threshold=2)', async () => {
+                const txBuilder = newFactory()
+                    .getExportInPBuilder()
+                    .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                    .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                    .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                    .amount(exportInP_1.EXPORT_IN_P.amount)
+                    .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                    .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                    .context(exportInP_1.EXPORT_IN_P.context)
+                    .decodedUtxos(exportInP_1.EXPORT_IN_P.utxos);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.type.should.equal(22);
+            });
+            it('should correctly sign threshold=1 UTXOs with single signature slot', async () => {
+                const threshold1Utxos = exportInP_1.EXPORT_IN_P.utxos
+                    .filter((u) => u.threshold === 1)
+                    .map((u) => ({
+                    ...u,
+                    amount: (BigInt(u.amount) * 2n).toString(),
+                }));
+                if (threshold1Utxos.length > 0) {
+                    const txBuilder = newFactory()
+                        .getExportInPBuilder()
+                        .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                        .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                        .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                        .amount('20000000')
+                        .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                        .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                        .context(exportInP_1.EXPORT_IN_P.context)
+                        .decodedUtxos(threshold1Utxos);
+                    txBuilder.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[2] });
+                    const tx = await txBuilder.build();
+                    tx.toBroadcastFormat().should.be.a.String();
+                }
+            });
+        });
+    });
+    describe('Two-Phase Signing Flow', () => {
+        describe('Import In P - Two-phase signing', () => {
+            it('should correctly preserve addressesIndex through parse-sign-parse-sign flow', async () => {
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                const unsignedTx = await builder1.build();
+                const unsignedHex = unsignedTx.toBroadcastFormat();
+                unsignedTx.toJson().signatures.length.should.equal(0);
+                const builder2 = newFactory().from(unsignedHex);
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const halfSignedHex = halfSignedTx.toBroadcastFormat();
+                halfSignedTx.toJson().signatures.length.should.equal(1);
+                const builder3 = newFactory().from(halfSignedHex);
+                builder3.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+                fullSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+                fullSignedTx.id.should.equal(importInP_1.IMPORT_IN_P.txhash);
+            });
+            it('should produce same result when signing in single phase vs two phases', async () => {
+                const singlePhaseBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                singlePhaseBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                singlePhaseBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const singlePhaseTx = await singlePhaseBuilder.build();
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                const unsignedTx = await builder1.build();
+                const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder3.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const twoPhasesTx = await builder3.build();
+                singlePhaseTx.toBroadcastFormat().should.equal(twoPhasesTx.toBroadcastFormat());
+                singlePhaseTx.id.should.equal(twoPhasesTx.id);
+            });
+            it('should handle signing from parsed unsigned tx directly', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.unsignedHex);
+                builder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                builder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx = await builder.build();
+                tx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+                tx.id.should.equal(importInP_1.IMPORT_IN_P.txhash);
+            });
+            it('should handle signing from parsed half-signed tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.halfSigntxHex);
+                builder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx = await builder.build();
+                tx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+                tx.id.should.equal(importInP_1.IMPORT_IN_P.txhash);
+            });
+        });
+        describe('Import In C - Two-phase signing', () => {
+            it('should correctly handle two-phase signing for C-chain import', async () => {
+                const builder1 = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(importInC_1.IMPORT_IN_C.utxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                const unsignedTx = await builder1.build();
+                const unsignedHex = unsignedTx.toBroadcastFormat();
+                const builder2 = newFactory().from(unsignedHex);
+                builder2.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const halfSignedHex = halfSignedTx.toBroadcastFormat();
+                const builder3 = newFactory().from(halfSignedHex);
+                builder3.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toBroadcastFormat().should.equal(importInC_1.IMPORT_IN_C.fullSigntxHex);
+                fullSignedTx.id.should.equal(importInC_1.IMPORT_IN_C.txhash);
+            });
+            it('should handle multiple UTXOs in two-phase signing', async () => {
+                const builder1 = newFactory().from(importInC_1.IMPORT_IN_C.unsignedHex);
+                const unsignedTx = await builder1.build();
+                unsignedTx.toJson().signatures.length.should.equal(0);
+                const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                halfSignedTx.toJson().signatures.length.should.equal(1);
+                const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder3.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+            });
+        });
+        describe('Export In P - Two-phase signing with mixed thresholds', () => {
+            it('should correctly handle two-phase signing with threshold=1 and threshold=2 UTXOs', async () => {
+                const builder1 = newFactory()
+                    .getExportInPBuilder()
+                    .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                    .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                    .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                    .amount(exportInP_1.EXPORT_IN_P.amount)
+                    .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                    .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                    .context(exportInP_1.EXPORT_IN_P.context)
+                    .decodedUtxos(exportInP_1.EXPORT_IN_P.utxos);
+                const unsignedTx = await builder1.build();
+                const unsignedHex = unsignedTx.toBroadcastFormat();
+                const builder2 = newFactory().from(unsignedHex);
+                builder2.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const halfSignedHex = halfSignedTx.toBroadcastFormat();
+                const builder3 = newFactory().from(halfSignedHex);
+                builder3.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toBroadcastFormat().should.equal(exportInP_1.EXPORT_IN_P.fullSigntxHex);
+                fullSignedTx.id.should.equal(exportInP_1.EXPORT_IN_P.txhash);
+            });
+        });
+    });
+    describe('Signature Slot Ordering', () => {
+        describe('Credential creation with embedded addresses', () => {
+            it('should embed correct address in unsigned tx signature slots', async () => {
+                const builder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                const tx = await builder.build();
+                const hex = tx.toBroadcastFormat();
+                hex.should.equal(importInP_1.IMPORT_IN_P.unsignedHex);
+            });
+            it('should replace embedded address with actual signature after signing', async () => {
+                const builder1 = newFactory().from(importInP_1.IMPORT_IN_P.unsignedHex);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder1.build();
+                halfSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.halfSigntxHex);
+                const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder2.build();
+                fullSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+            });
+        });
+        describe('Signing order independence', () => {
+            it('should produce valid signatures regardless of which key signs first (fresh build)', async () => {
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx1 = await builder1.build();
+                const builder2 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const tx2 = await builder2.build();
+                tx1.toJson().signatures.length.should.equal(2);
+                tx2.toJson().signatures.length.should.equal(2);
+                tx1.id.should.be.a.String();
+                tx1.id.length.should.be.greaterThan(0);
+                tx2.id.should.be.a.String();
+                tx2.id.length.should.be.greaterThan(0);
+            });
+            it('should produce identical tx when signing in expected slot order', async () => {
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx1 = await builder1.build();
+                const builder2 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx2 = await builder2.build();
+                tx1.toBroadcastFormat().should.equal(tx2.toBroadcastFormat());
+                tx1.id.should.equal(tx2.id);
+            });
+        });
+    });
+    describe('Edge Cases', () => {
+        describe('Transaction recovery and rebuild', () => {
+            it('should preserve transaction structure when parsing and rebuilding unsigned tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.unsignedHex);
+                const tx = await builder.build();
+                tx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.unsignedHex);
+            });
+            it('should preserve transaction structure when parsing and rebuilding half-signed tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.halfSigntxHex);
+                const tx = await builder.build();
+                tx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.halfSigntxHex);
+            });
+            it('should preserve transaction structure when parsing and rebuilding fully-signed tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.signedHex);
+                const tx = await builder.build();
+                tx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+                tx.id.should.equal(importInP_1.IMPORT_IN_P.txhash);
+            });
+        });
+        describe('Signature count validation', () => {
+            it('should have 0 signatures for unsigned tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.unsignedHex);
+                const tx = await builder.build();
+                tx.toJson().signatures.length.should.equal(0);
+            });
+            it('should have 1 signature for half-signed tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.halfSigntxHex);
+                const tx = await builder.build();
+                tx.toJson().signatures.length.should.equal(1);
+            });
+            it('should have 2 signatures for fully-signed tx', async () => {
+                const builder = newFactory().from(importInP_1.IMPORT_IN_P.signedHex);
+                const tx = await builder.build();
+                tx.toJson().signatures.length.should.equal(2);
+            });
+        });
+        describe('Multiple UTXOs with different address orderings', () => {
+            it('should handle multiple UTXOs where each has different address order', async () => {
+                const mixedOrderUtxos = [
+                    {
+                        ...importInC_1.IMPORT_IN_C.utxos[0],
+                        addresses: [importInC_1.IMPORT_IN_C.pAddresses[2], importInC_1.IMPORT_IN_C.pAddresses[0], importInC_1.IMPORT_IN_C.pAddresses[1]],
+                    },
+                    {
+                        ...importInC_1.IMPORT_IN_C.utxos[1],
+                        addresses: [importInC_1.IMPORT_IN_C.pAddresses[0], importInC_1.IMPORT_IN_C.pAddresses[1], importInC_1.IMPORT_IN_C.pAddresses[2]],
+                    },
+                    {
+                        ...importInC_1.IMPORT_IN_C.utxos[2],
+                        addresses: [importInC_1.IMPORT_IN_C.pAddresses[1], importInC_1.IMPORT_IN_C.pAddresses[2], importInC_1.IMPORT_IN_C.pAddresses[0]],
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(mixedOrderUtxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.signatures.length.should.equal(2);
+                tx.toBroadcastFormat().should.be.a.String();
+            });
+        });
+        describe('Cross-builder consistency', () => {
+            it('should use same addressesIndex logic across all atomic builders', async () => {
+                const utxoAddresses = [
+                    importInP_1.IMPORT_IN_P.pAddresses[2],
+                    importInP_1.IMPORT_IN_P.pAddresses[0],
+                    importInP_1.IMPORT_IN_P.pAddresses[1],
+                ];
+                // ImportInP
+                const importPBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos([{ ...importInP_1.IMPORT_IN_P.utxos[0], addresses: utxoAddresses }]);
+                importPBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const importPTx = await importPBuilder.build();
+                importPTx.toJson().signatures.length.should.equal(1);
+                const importCBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos([{ ...importInC_1.IMPORT_IN_C.utxos[0], addresses: utxoAddresses }])
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                importCBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                const importCTx = await importCBuilder.build();
+                importCTx.toJson().signatures.length.should.equal(1);
+                const exportPBuilder = newFactory()
+                    .getExportInPBuilder()
+                    .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                    .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                    .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                    .amount('20000000')
+                    .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                    .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                    .context(exportInP_1.EXPORT_IN_P.context)
+                    .decodedUtxos([{ ...exportInP_1.EXPORT_IN_P.utxos[1], addresses: utxoAddresses }]);
+                exportPBuilder.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[2] });
+                const exportPTx = await exportPBuilder.build();
+                exportPTx.toJson().signatures.length.should.equal(1);
+            });
+        });
+    });
+    describe('Real-world Scenario: Failed Transaction Fix Verification', () => {
+        it('should correctly sign when UTXO addresses are in IMS order (not BitGo order)', async () => {
+            const imsOrderUtxos = [
+                {
+                    ...importInP_1.IMPORT_IN_P.utxos[0],
+                    addresses: [importInP_1.IMPORT_IN_P.pAddresses[1], importInP_1.IMPORT_IN_P.pAddresses[2], importInP_1.IMPORT_IN_P.pAddresses[0]],
+                },
+            ];
+            const wpBuilder = newFactory()
+                .getImportInPBuilder()
+                .threshold(importInP_1.IMPORT_IN_P.threshold)
+                .locktime(importInP_1.IMPORT_IN_P.locktime)
+                .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                .to(importInP_1.IMPORT_IN_P.pAddresses)
+                .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                .feeState(importInP_1.IMPORT_IN_P.feeState)
+                .context(importInP_1.IMPORT_IN_P.context)
+                .decodedUtxos(imsOrderUtxos);
+            const unsignedTx = await wpBuilder.build();
+            const unsignedHex = unsignedTx.toBroadcastFormat();
+            const ovc1Builder = newFactory().from(unsignedHex);
+            ovc1Builder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+            const halfSignedTx = await ovc1Builder.build();
+            const halfSignedHex = halfSignedTx.toBroadcastFormat();
+            halfSignedTx.toJson().signatures.length.should.equal(1);
+            const ovc2Builder = newFactory().from(halfSignedHex);
+            ovc2Builder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+            const fullSignedTx = await ovc2Builder.build();
+            fullSignedTx.toJson().signatures.length.should.equal(2);
+            const txId = fullSignedTx.id;
+            txId.should.be.a.String();
+            txId.length.should.be.greaterThan(0);
+        });
+        it('should handle the exact UTXO configuration from the failed production transaction', async () => {
+            const builder1 = newFactory()
+                .getImportInPBuilder()
+                .threshold(importInP_1.IMPORT_IN_P.threshold)
+                .locktime(importInP_1.IMPORT_IN_P.locktime)
+                .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                .to(importInP_1.IMPORT_IN_P.pAddresses)
+                .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                .feeState(importInP_1.IMPORT_IN_P.feeState)
+                .context(importInP_1.IMPORT_IN_P.context)
+                .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+            const unsignedTx = await builder1.build();
+            const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());
+            builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+            const halfSignedTx = await builder2.build();
+            const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());
+            builder3.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+            const fullSignedTx = await builder3.build();
+            fullSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+            fullSignedTx.id.should.equal(importInP_1.IMPORT_IN_P.txhash);
+        });
+    });
+    /**
+     * Test suite for UTXO reordering fix.
+     *
+     * FlareJS's newImportTx/newExportTx functions sort inputs by UTXO ID (txid + outputidx)
+     * for deterministic transaction building. The SDK must match inputs back to UTXOs
+     * by UTXO ID, not by array index, to ensure credentials are created for the correct inputs.
+     *
+     * These tests verify that transactions with multiple UTXOs work correctly regardless
+     * of the order in which UTXOs are provided.
+     */
+    describe('UTXO Reordering Fix - Multiple UTXOs with Different txids', () => {
+        describe('ImportInC with reordered UTXOs', () => {
+            it('should correctly handle multiple UTXOs that may get reordered by FlareJS', async () => {
+                const reorderedUtxos = [importInC_1.IMPORT_IN_C.utxos[4], importInC_1.IMPORT_IN_C.utxos[0]];
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(reorderedUtxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.signatures.length.should.equal(2);
+                tx.toBroadcastFormat().should.be.a.String();
+                txJson.inputs.length.should.equal(2);
+            });
+            it('should correctly sign in parse-sign-parse-sign flow with multiple UTXOs', async () => {
+                const reorderedUtxos = [importInC_1.IMPORT_IN_C.utxos[3], importInC_1.IMPORT_IN_C.utxos[1]];
+                const builder1 = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(reorderedUtxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                const unsignedTx = await builder1.build();
+                unsignedTx.toJson().signatures.length.should.equal(0);
+                const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                halfSignedTx.toJson().signatures.length.should.equal(1);
+                const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder3.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+                fullSignedTx.toBroadcastFormat().should.be.a.String();
+                fullSignedTx.id.should.be.a.String();
+            });
+            it('should handle 3+ UTXOs with different ordering', async () => {
+                const mixedUtxos = [importInC_1.IMPORT_IN_C.utxos[2], importInC_1.IMPORT_IN_C.utxos[4], importInC_1.IMPORT_IN_C.utxos[0]];
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(mixedUtxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                tx.toJson().signatures.length.should.equal(2);
+                tx.toJson().inputs.length.should.equal(3);
+            });
+            it('should handle all 5 UTXOs from test data', async () => {
+                const allUtxosReversed = [...importInC_1.IMPORT_IN_C.utxos].reverse();
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(allUtxosReversed)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                tx.toJson().signatures.length.should.equal(2);
+                tx.toJson().inputs.length.should.equal(5);
+            });
+        });
+        describe('ImportInP with multiple UTXOs', () => {
+            it('should correctly handle multiple UTXOs with different outputidx', async () => {
+                const multipleUtxos = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '1',
+                        amount: '25000000',
+                    },
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '0',
+                        amount: '25000000',
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(multipleUtxos);
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                txBuilder.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx = await txBuilder.build();
+                tx.toJson().signatures.length.should.equal(2);
+                tx.toJson().inputs.length.should.equal(2);
+            });
+            it('should correctly sign in parse-sign-parse-sign flow with multiple UTXOs', async () => {
+                const multipleUtxos = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '1',
+                        amount: '25000000',
+                    },
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '0',
+                        amount: '25000000',
+                    },
+                ];
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(multipleUtxos);
+                const unsignedTx = await builder1.build();
+                const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder3.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+                fullSignedTx.toBroadcastFormat().should.be.a.String();
+            });
+        });
+        describe('ExportInP with multiple UTXOs', () => {
+            it('should correctly handle multiple UTXOs that may get reordered', async () => {
+                const reorderedUtxos = [
+                    {
+                        ...exportInP_1.EXPORT_IN_P.utxos[1],
+                        outputidx: '1',
+                    },
+                    {
+                        ...exportInP_1.EXPORT_IN_P.utxos[1],
+                        outputidx: '0',
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getExportInPBuilder()
+                    .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                    .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                    .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                    .amount('20000000')
+                    .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                    .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                    .context(exportInP_1.EXPORT_IN_P.context)
+                    .decodedUtxos(reorderedUtxos);
+                txBuilder.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[2] });
+                txBuilder.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[0] });
+                const tx = await txBuilder.build();
+                tx.toJson().signatures.length.should.equal(2);
+            });
+            it('should correctly sign in parse-sign-parse-sign flow with multiple UTXOs', async () => {
+                const reorderedUtxos = [
+                    {
+                        ...exportInP_1.EXPORT_IN_P.utxos[1],
+                        outputidx: '1',
+                    },
+                    {
+                        ...exportInP_1.EXPORT_IN_P.utxos[1],
+                        outputidx: '0',
+                    },
+                ];
+                const builder1 = newFactory()
+                    .getExportInPBuilder()
+                    .threshold(exportInP_1.EXPORT_IN_P.threshold)
+                    .locktime(exportInP_1.EXPORT_IN_P.locktime)
+                    .fromPubKey(exportInP_1.EXPORT_IN_P.pAddresses)
+                    .amount('20000000')
+                    .externalChainId(exportInP_1.EXPORT_IN_P.sourceChainId)
+                    .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                    .context(exportInP_1.EXPORT_IN_P.context)
+                    .decodedUtxos(reorderedUtxos);
+                const unsignedTx = await builder1.build();
+                const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());
+                builder2.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder3.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+                fullSignedTx.toBroadcastFormat().should.be.a.String();
+            });
+        });
+        describe('Edge cases for UTXO matching', () => {
+            it('should match UTXOs by both txid AND outputidx', async () => {
+                const sameIdUtxos = [
+                    {
+                        ...importInC_1.IMPORT_IN_C.utxos[0],
+                        outputidx: '2',
+                    },
+                    {
+                        ...importInC_1.IMPORT_IN_C.utxos[0],
+                        outputidx: '0',
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(sameIdUtxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                tx.toJson().signatures.length.should.equal(2);
+                tx.toJson().inputs.length.should.equal(2);
+            });
+            it('should work correctly when UTXOs are already in sorted order', async () => {
+                const sortedUtxos = [importInC_1.IMPORT_IN_C.utxos[0], importInC_1.IMPORT_IN_C.utxos[1]];
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(sortedUtxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                txBuilder.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[0] });
+                const tx = await txBuilder.build();
+                tx.toJson().signatures.length.should.equal(2);
+            });
+        });
+    });
+    /**
+     * Tests specifically for the sigIndices fix.
+     *
+     * Background: FLRP import to P transactions were failing with:
+     * - "could not parse transaction" (HSM error)
+     * - "wrong signature" (on-chain error)
+     *
+     * Root cause: Mismatch between SDK's assumed credential order and FlareJS's
+     * actual sigIndices order. When UTXO addresses are sorted differently than
+     * sender addresses, the credentials must follow FlareJS's sigIndices order
+     * (ascending by UTXO position), not the SDK's sender address order.
+     *
+     * The fix reads actual sigIndices from FlareJS-built transaction inputs
+     * and creates credentials in that exact order.
+     *
+     * Real-world failure examples:
+     * 1. Wallet 697738a870cd159b6ab80f7071e3146a - HSM error "could not parse transaction"
+     *    - UTXO addresses: [r6gzm4acz..., x3u4xeal7..., l4f9rrc7w...]
+     *    - Sender addresses: [l4f9rrc7w..., x3u4xeal7..., r6gzm4acz...]
+     *
+     * 2. Wallet 69773884a565c4dbaf680e360b920c9e - On-chain "wrong signature"
+     *    - UTXO addresses: [t37m2e8fa..., urz6r3jy2..., 7r4k0nqne...]
+     *    - Sender addresses: [urz6r3jy2..., 7r4k0nqne..., t37m2e8fa...]
+     */
+    describe('SigIndices Fix Verification', () => {
+        describe('Credential ordering matches FlareJS sigIndices', () => {
+            it('should create credentials in correct order when UTXO addresses differ from sender order', async () => {
+                // Test data where UTXO addresses are in different order than pAddresses
+                // UTXO addresses: [xv5mulgpe..., 06gc5h5qs..., cueygd7fd...]
+                // pAddresses:     [06gc5h5qs..., cueygd7fd..., xv5mulgpe...]
+                //
+                // FlareJS will compute sigIndices based on which addresses are signing
+                // and their positions in the UTXO's address list (sorted by address bytes)
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                const tx = await txBuilder.build();
+                const hex = tx.toBroadcastFormat();
+                // The fix ensures the unsigned tx has credentials ordered correctly
+                // Before fix: credentials were in sender address order
+                // After fix: credentials are in sigIndices order (ascending UTXO position)
+                hex.should.equal(importInP_1.IMPORT_IN_P.unsignedHex);
+                // Verify we can sign and the signatures go in the correct slots
+                const builder1 = newFactory().from(hex);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] }); // user key
+                const halfSignedTx = await builder1.build();
+                halfSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.halfSigntxHex);
+                const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] }); // bitgo key
+                const fullSignedTx = await builder2.build();
+                fullSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+            });
+            it('should produce valid signatures when signing keys are provided in any order', async () => {
+                // This tests that the fix properly handles the address mapping
+                // regardless of which key signs first
+                const txBuilder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                // Sign user first, then bitgo
+                txBuilder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                txBuilder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx1 = await txBuilder1.build();
+                const txBuilder2 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                // Sign bitgo first, then user
+                txBuilder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                txBuilder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const tx2 = await txBuilder2.build();
+                // Both should produce the same valid transaction
+                tx1.toBroadcastFormat().should.equal(tx2.toBroadcastFormat());
+                tx1.toJson().signatures.length.should.equal(2);
+                tx2.toJson().signatures.length.should.equal(2);
+            });
+            it('should handle Export P transaction with correct sigIndices order', async () => {
+                const txBuilder = newFactory()
+                    .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)
+                    .feeState(exportInP_1.EXPORT_IN_P.feeState)
+                    .context(exportInP_1.EXPORT_IN_P.context)
+                    .decodedUtxos(exportInP_1.EXPORT_IN_P.utxos)
+                    .amount(exportInP_1.EXPORT_IN_P.amount);
+                const tx = await txBuilder.build();
+                const hex = tx.toBroadcastFormat();
+                hex.should.equal(exportInP_1.EXPORT_IN_P.unsignedHex);
+                // Verify signing flow
+                const builder1 = newFactory().from(hex);
+                builder1.sign({ key: exportInP_1.EXPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder1.build();
+                halfSignedTx.toBroadcastFormat().should.equal(exportInP_1.EXPORT_IN_P.halfSigntxHex);
+            });
+            it('should handle Import C transaction with correct sigIndices order', async () => {
+                const txBuilder = newFactory()
+                    .getImportInCBuilder()
+                    .threshold(importInC_1.IMPORT_IN_C.threshold)
+                    .fromPubKey(importInC_1.IMPORT_IN_C.pAddresses)
+                    .decodedUtxos(importInC_1.IMPORT_IN_C.utxos)
+                    .to(importInC_1.IMPORT_IN_C.to)
+                    .fee(importInC_1.IMPORT_IN_C.fee)
+                    .context(importInC_1.IMPORT_IN_C.context);
+                const tx = await txBuilder.build();
+                const hex = tx.toBroadcastFormat();
+                hex.should.equal(importInC_1.IMPORT_IN_C.unsignedHex);
+                // Verify signing flow
+                const builder1 = newFactory().from(hex);
+                builder1.sign({ key: importInC_1.IMPORT_IN_C.privateKeys[2] });
+                const halfSignedTx = await builder1.build();
+                halfSignedTx.toBroadcastFormat().should.equal(importInC_1.IMPORT_IN_C.halfSigntxHex);
+            });
+        });
+        describe('Two-phase signing flow (mimics HSM flow)', () => {
+            it('should support build -> serialize -> parse -> sign -> serialize -> parse -> sign flow for Import P', async () => {
+                // Phase 1: Build unsigned transaction
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(importInP_1.IMPORT_IN_P.utxos);
+                const unsignedTx = await builder1.build();
+                const unsignedHex = unsignedTx.toBroadcastFormat();
+                // Phase 2: Parse unsigned and add first signature (user/backup)
+                const builder2 = newFactory().from(unsignedHex);
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder2.build();
+                const halfSignedHex = halfSignedTx.toBroadcastFormat();
+                halfSignedTx.toJson().signatures.length.should.equal(1);
+                // Phase 3: Parse half-signed and add second signature (bitgo)
+                const builder3 = newFactory().from(halfSignedHex);
+                builder3.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder3.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+                fullSignedTx.toBroadcastFormat().should.equal(importInP_1.IMPORT_IN_P.signedHex);
+            });
+        });
+        describe('Failed transaction scenarios (real-world cases)', () => {
+            /**
+             * This test simulates the exact failure pattern from wallet 697738a870cd159b6ab80f7071e3146a
+             * which failed at HSM with "could not parse transaction".
+             *
+             * The failure occurred because:
+             * - UTXO addresses were in order: [addr0, addr1, addr2]
+             * - Sender addresses were in order: [addr2, addr1, addr0] (reversed)
+             * - FlareJS computed sigIndices based on UTXO positions
+             * - SDK was creating credentials based on sender positions (wrong)
+             *
+             * After the fix, credentials are created in the order specified by FlareJS sigIndices.
+             */
+            it('should handle address ordering where UTXO order differs significantly from sender order', async () => {
+                // Simulate the failed case pattern:
+                // UTXO addresses: [pAddresses[2], pAddresses[1], pAddresses[0]]
+                // Sender addresses: [pAddresses[0], pAddresses[1], pAddresses[2]]
+                const reorderedUtxos = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        addresses: [
+                            importInP_1.IMPORT_IN_P.pAddresses[2], // backup at UTXO position 0
+                            importInP_1.IMPORT_IN_P.pAddresses[1], // bitgo at UTXO position 1
+                            importInP_1.IMPORT_IN_P.pAddresses[0], // user at UTXO position 2
+                        ],
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(reorderedUtxos);
+                const tx = await txBuilder.build();
+                const hex = tx.toBroadcastFormat();
+                // Verify transaction can be built without errors
+                hex.should.be.a.String();
+                hex.length.should.be.greaterThan(0);
+                // Verify we can parse and sign the transaction
+                const builder1 = newFactory().from(hex);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] }); // user key
+                const halfSignedTx = await builder1.build();
+                halfSignedTx.toJson().signatures.length.should.equal(1);
+                const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] }); // bitgo key
+                const fullSignedTx = await builder2.build();
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+                // Both signatures should be present and valid
+                const signatures = fullSignedTx.toJson().signatures;
+                signatures.forEach((sig) => {
+                    sig.should.be.a.String();
+                    sig.length.should.be.greaterThan(0);
+                });
+            });
+            /**
+             * This test simulates scenarios with multiple UTXOs where each has different
+             * address orderings, similar to the failed transaction with 4 UTXOs.
+             */
+            it('should handle multiple UTXOs with varying address orderings', async () => {
+                // Create multiple UTXOs with different address orderings
+                // Use same txid but different outputidx to create valid unique UTXOs
+                const multipleUtxos = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '0',
+                        addresses: [
+                            importInP_1.IMPORT_IN_P.pAddresses[2], // backup first
+                            importInP_1.IMPORT_IN_P.pAddresses[0], // user second
+                            importInP_1.IMPORT_IN_P.pAddresses[1], // bitgo third
+                        ],
+                    },
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '1',
+                        addresses: [
+                            importInP_1.IMPORT_IN_P.pAddresses[1], // bitgo first
+                            importInP_1.IMPORT_IN_P.pAddresses[2], // backup second
+                            importInP_1.IMPORT_IN_P.pAddresses[0], // user third
+                        ],
+                    },
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        outputidx: '2',
+                        addresses: [
+                            importInP_1.IMPORT_IN_P.pAddresses[0], // user first
+                            importInP_1.IMPORT_IN_P.pAddresses[1], // bitgo second
+                            importInP_1.IMPORT_IN_P.pAddresses[2], // backup third
+                        ],
+                    },
+                ];
+                const txBuilder = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(multipleUtxos);
+                const tx = await txBuilder.build();
+                const hex = tx.toBroadcastFormat();
+                // Verify transaction builds successfully
+                hex.should.be.a.String();
+                tx.toJson().inputs.length.should.equal(3);
+                // Verify full signing flow works
+                const builder1 = newFactory().from(hex);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const halfSignedTx = await builder1.build();
+                const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const fullSignedTx = await builder2.build();
+                // Each input should have its own credential
+                fullSignedTx.toJson().signatures.length.should.equal(2);
+            });
+            /**
+             * This test verifies that signing order doesn't matter even with
+             * complex address orderings - the fix ensures signatures go to
+             * the correct slots based on FlareJS sigIndices.
+             */
+            it('should produce identical results regardless of signing order with reordered addresses', async () => {
+                const reorderedUtxos = [
+                    {
+                        ...importInP_1.IMPORT_IN_P.utxos[0],
+                        addresses: [importInP_1.IMPORT_IN_P.pAddresses[2], importInP_1.IMPORT_IN_P.pAddresses[1], importInP_1.IMPORT_IN_P.pAddresses[0]],
+                    },
+                ];
+                // Sign user first, then bitgo
+                const builder1 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(reorderedUtxos);
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                builder1.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                const tx1 = await builder1.build();
+                // Sign bitgo first, then user
+                const builder2 = newFactory()
+                    .getImportInPBuilder()
+                    .threshold(importInP_1.IMPORT_IN_P.threshold)
+                    .locktime(importInP_1.IMPORT_IN_P.locktime)
+                    .fromPubKey(importInP_1.IMPORT_IN_P.corethAddresses)
+                    .to(importInP_1.IMPORT_IN_P.pAddresses)
+                    .externalChainId(importInP_1.IMPORT_IN_P.sourceChainId)
+                    .feeState(importInP_1.IMPORT_IN_P.feeState)
+                    .context(importInP_1.IMPORT_IN_P.context)
+                    .decodedUtxos(reorderedUtxos);
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[0] });
+                builder2.sign({ key: importInP_1.IMPORT_IN_P.privateKeys[2] });
+                const tx2 = await builder2.build();
+                // Both should produce identical fully signed transactions
+                tx1.toBroadcastFormat().should.equal(tx2.toBroadcastFormat());
+                tx1.toJson().signatures.length.should.equal(2);
+                tx2.toJson().signatures.length.should.equal(2);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signatureIndex.js","sourceRoot":"","sources":["../../../../test/unit/lib/signatureIndex.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive test suite for signature index handling in FLRP atomic transactions.\n *\n * This tests the alignment with AVAX P implementation for:\n * 1. addressesIndex computation (mapping sender addresses to UTXO positions)\n * 2. Signature slot ordering (based on UTXO address positions)\n * 3. Two-phase signing flow (build -> parse -> sign -> parse -> sign)\n * 4. Different UTXO address orderings\n * 5. Mixed threshold UTXOs (threshold=1 and threshold=2)\n * 6. Recovery signing scenarios\n */\nimport 'should';\nimport { TransactionBuilderFactory } from '../../../src/lib';\nimport { coins } from '@bitgo-beta/statics';\nimport { IMPORT_IN_P as importPTestData } from '../../resources/transactionData/importInP';\nimport { IMPORT_IN_C as importCTestData } from '../../resources/transactionData/importInC';\nimport { EXPORT_IN_P as exportPTestData } from '../../resources/transactionData/exportInP';\n\ndescribe('Signature Index Handling - AVAX P Alignment', () => {\n  const coinConfig = coins.get('tflrp');\n  const newFactory = () => new TransactionBuilderFactory(coinConfig);\n\n  describe('addressesIndex Computation', () => {\n    describe('Import In P - addressesIndex scenarios', () => {\n      it('should compute addressesIndex correctly when UTXO addresses differ from sender order', async () => {\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.type.should.equal(23);\n        txJson.threshold.should.equal(2);\n      });\n\n      it('should handle UTXO where addresses match sender order exactly', async () => {\n        const utxosMatchingOrder = [\n          {\n            ...importPTestData.utxos[0],\n            addresses: [importPTestData.pAddresses[0], importPTestData.pAddresses[1], importPTestData.pAddresses[2]],\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(utxosMatchingOrder);\n\n        txBuilder.sign({ key: importPTestData.privateKeys[2] });\n        txBuilder.sign({ key: importPTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.signatures.length.should.equal(2);\n      });\n\n      it('should handle UTXO where bitgo address comes before user in UTXO list', async () => {\n        const utxosBitgoFirst = [\n          {\n            ...importPTestData.utxos[0],\n            addresses: [importPTestData.pAddresses[1], importPTestData.pAddresses[0], importPTestData.pAddresses[2]],\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(utxosBitgoFirst);\n\n        txBuilder.sign({ key: importPTestData.privateKeys[2] });\n        txBuilder.sign({ key: importPTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.signatures.length.should.equal(2);\n        tx.toBroadcastFormat().should.be.a.String();\n      });\n\n      it('should handle UTXO where user address comes before bitgo in UTXO list', async () => {\n        const utxosUserFirst = [\n          {\n            ...importPTestData.utxos[0],\n            addresses: [importPTestData.pAddresses[0], importPTestData.pAddresses[1], importPTestData.pAddresses[2]],\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(utxosUserFirst);\n\n        txBuilder.sign({ key: importPTestData.privateKeys[2] });\n        txBuilder.sign({ key: importPTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.signatures.length.should.equal(2);\n        tx.toBroadcastFormat().should.be.a.String();\n      });\n    });\n\n    describe('Import In C - addressesIndex scenarios', () => {\n      it('should compute addressesIndex correctly for C-chain import with multiple UTXOs', async () => {\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(importCTestData.utxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.type.should.equal(23);\n      });\n\n      it('should handle multiple UTXOs with same address ordering', async () => {\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(importCTestData.utxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.signatures.length.should.equal(2);\n      });\n    });\n\n    describe('Export In P - addressesIndex scenarios with mixed thresholds', () => {\n      it('should handle UTXOs with different thresholds (threshold=1 and threshold=2)', async () => {\n        const txBuilder = newFactory()\n          .getExportInPBuilder()\n          .threshold(exportPTestData.threshold)\n          .locktime(exportPTestData.locktime)\n          .fromPubKey(exportPTestData.pAddresses)\n          .amount(exportPTestData.amount)\n          .externalChainId(exportPTestData.sourceChainId)\n          .feeState(exportPTestData.feeState)\n          .context(exportPTestData.context)\n          .decodedUtxos(exportPTestData.utxos);\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.type.should.equal(22);\n      });\n\n      it('should correctly sign threshold=1 UTXOs with single signature slot', async () => {\n        const threshold1Utxos = exportPTestData.utxos\n          .filter((u) => u.threshold === 1)\n          .map((u) => ({\n            ...u,\n            amount: (BigInt(u.amount) * 2n).toString(),\n          }));\n\n        if (threshold1Utxos.length > 0) {\n          const txBuilder = newFactory()\n            .getExportInPBuilder()\n            .threshold(exportPTestData.threshold)\n            .locktime(exportPTestData.locktime)\n            .fromPubKey(exportPTestData.pAddresses)\n            .amount('20000000')\n            .externalChainId(exportPTestData.sourceChainId)\n            .feeState(exportPTestData.feeState)\n            .context(exportPTestData.context)\n            .decodedUtxos(threshold1Utxos);\n\n          txBuilder.sign({ key: exportPTestData.privateKeys[2] });\n\n          const tx = await txBuilder.build();\n          tx.toBroadcastFormat().should.be.a.String();\n        }\n      });\n    });\n  });\n\n  describe('Two-Phase Signing Flow', () => {\n    describe('Import In P - Two-phase signing', () => {\n      it('should correctly preserve addressesIndex through parse-sign-parse-sign flow', async () => {\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        const unsignedTx = await builder1.build();\n        const unsignedHex = unsignedTx.toBroadcastFormat();\n        unsignedTx.toJson().signatures.length.should.equal(0);\n\n        const builder2 = newFactory().from(unsignedHex);\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        const halfSignedHex = halfSignedTx.toBroadcastFormat();\n        halfSignedTx.toJson().signatures.length.should.equal(1);\n\n        const builder3 = newFactory().from(halfSignedHex);\n        builder3.sign({ key: importPTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n\n        fullSignedTx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n        fullSignedTx.id.should.equal(importPTestData.txhash);\n      });\n\n      it('should produce same result when signing in single phase vs two phases', async () => {\n        const singlePhaseBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        singlePhaseBuilder.sign({ key: importPTestData.privateKeys[2] });\n        singlePhaseBuilder.sign({ key: importPTestData.privateKeys[0] });\n        const singlePhaseTx = await singlePhaseBuilder.build();\n\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        const unsignedTx = await builder1.build();\n        const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder3.sign({ key: importPTestData.privateKeys[0] });\n        const twoPhasesTx = await builder3.build();\n\n        singlePhaseTx.toBroadcastFormat().should.equal(twoPhasesTx.toBroadcastFormat());\n        singlePhaseTx.id.should.equal(twoPhasesTx.id);\n      });\n\n      it('should handle signing from parsed unsigned tx directly', async () => {\n        const builder = newFactory().from(importPTestData.unsignedHex);\n        builder.sign({ key: importPTestData.privateKeys[2] });\n        builder.sign({ key: importPTestData.privateKeys[0] });\n        const tx = await builder.build();\n\n        tx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n        tx.id.should.equal(importPTestData.txhash);\n      });\n\n      it('should handle signing from parsed half-signed tx', async () => {\n        const builder = newFactory().from(importPTestData.halfSigntxHex);\n        builder.sign({ key: importPTestData.privateKeys[0] });\n        const tx = await builder.build();\n\n        tx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n        tx.id.should.equal(importPTestData.txhash);\n      });\n    });\n\n    describe('Import In C - Two-phase signing', () => {\n      it('should correctly handle two-phase signing for C-chain import', async () => {\n        const builder1 = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(importCTestData.utxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        const unsignedTx = await builder1.build();\n        const unsignedHex = unsignedTx.toBroadcastFormat();\n\n        const builder2 = newFactory().from(unsignedHex);\n        builder2.sign({ key: importCTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        const halfSignedHex = halfSignedTx.toBroadcastFormat();\n\n        const builder3 = newFactory().from(halfSignedHex);\n        builder3.sign({ key: importCTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n\n        fullSignedTx.toBroadcastFormat().should.equal(importCTestData.fullSigntxHex);\n        fullSignedTx.id.should.equal(importCTestData.txhash);\n      });\n\n      it('should handle multiple UTXOs in two-phase signing', async () => {\n        const builder1 = newFactory().from(importCTestData.unsignedHex);\n        const unsignedTx = await builder1.build();\n        unsignedTx.toJson().signatures.length.should.equal(0);\n\n        const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());\n        builder2.sign({ key: importCTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        halfSignedTx.toJson().signatures.length.should.equal(1);\n\n        const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder3.sign({ key: importCTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n      });\n    });\n\n    describe('Export In P - Two-phase signing with mixed thresholds', () => {\n      it('should correctly handle two-phase signing with threshold=1 and threshold=2 UTXOs', async () => {\n        const builder1 = newFactory()\n          .getExportInPBuilder()\n          .threshold(exportPTestData.threshold)\n          .locktime(exportPTestData.locktime)\n          .fromPubKey(exportPTestData.pAddresses)\n          .amount(exportPTestData.amount)\n          .externalChainId(exportPTestData.sourceChainId)\n          .feeState(exportPTestData.feeState)\n          .context(exportPTestData.context)\n          .decodedUtxos(exportPTestData.utxos);\n\n        const unsignedTx = await builder1.build();\n        const unsignedHex = unsignedTx.toBroadcastFormat();\n\n        const builder2 = newFactory().from(unsignedHex);\n        builder2.sign({ key: exportPTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        const halfSignedHex = halfSignedTx.toBroadcastFormat();\n\n        const builder3 = newFactory().from(halfSignedHex);\n        builder3.sign({ key: exportPTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n\n        fullSignedTx.toBroadcastFormat().should.equal(exportPTestData.fullSigntxHex);\n        fullSignedTx.id.should.equal(exportPTestData.txhash);\n      });\n    });\n  });\n\n  describe('Signature Slot Ordering', () => {\n    describe('Credential creation with embedded addresses', () => {\n      it('should embed correct address in unsigned tx signature slots', async () => {\n        const builder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        const tx = await builder.build();\n        const hex = tx.toBroadcastFormat();\n\n        hex.should.equal(importPTestData.unsignedHex);\n      });\n\n      it('should replace embedded address with actual signature after signing', async () => {\n        const builder1 = newFactory().from(importPTestData.unsignedHex);\n        builder1.sign({ key: importPTestData.privateKeys[2] });\n        const halfSignedTx = await builder1.build();\n\n        halfSignedTx.toBroadcastFormat().should.equal(importPTestData.halfSigntxHex);\n\n        const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder2.sign({ key: importPTestData.privateKeys[0] });\n        const fullSignedTx = await builder2.build();\n\n        fullSignedTx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n      });\n    });\n\n    describe('Signing order independence', () => {\n      it('should produce valid signatures regardless of which key signs first (fresh build)', async () => {\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        builder1.sign({ key: importPTestData.privateKeys[2] });\n        builder1.sign({ key: importPTestData.privateKeys[0] });\n        const tx1 = await builder1.build();\n\n        const builder2 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        builder2.sign({ key: importPTestData.privateKeys[0] });\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        const tx2 = await builder2.build();\n\n        tx1.toJson().signatures.length.should.equal(2);\n        tx2.toJson().signatures.length.should.equal(2);\n\n        tx1.id.should.be.a.String();\n        tx1.id.length.should.be.greaterThan(0);\n        tx2.id.should.be.a.String();\n        tx2.id.length.should.be.greaterThan(0);\n      });\n\n      it('should produce identical tx when signing in expected slot order', async () => {\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        builder1.sign({ key: importPTestData.privateKeys[2] });\n        builder1.sign({ key: importPTestData.privateKeys[0] });\n        const tx1 = await builder1.build();\n\n        const builder2 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        builder2.sign({ key: importPTestData.privateKeys[0] });\n        const tx2 = await builder2.build();\n\n        tx1.toBroadcastFormat().should.equal(tx2.toBroadcastFormat());\n        tx1.id.should.equal(tx2.id);\n      });\n    });\n  });\n\n  describe('Edge Cases', () => {\n    describe('Transaction recovery and rebuild', () => {\n      it('should preserve transaction structure when parsing and rebuilding unsigned tx', async () => {\n        const builder = newFactory().from(importPTestData.unsignedHex);\n        const tx = await builder.build();\n        tx.toBroadcastFormat().should.equal(importPTestData.unsignedHex);\n      });\n\n      it('should preserve transaction structure when parsing and rebuilding half-signed tx', async () => {\n        const builder = newFactory().from(importPTestData.halfSigntxHex);\n        const tx = await builder.build();\n        tx.toBroadcastFormat().should.equal(importPTestData.halfSigntxHex);\n      });\n\n      it('should preserve transaction structure when parsing and rebuilding fully-signed tx', async () => {\n        const builder = newFactory().from(importPTestData.signedHex);\n        const tx = await builder.build();\n        tx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n        tx.id.should.equal(importPTestData.txhash);\n      });\n    });\n\n    describe('Signature count validation', () => {\n      it('should have 0 signatures for unsigned tx', async () => {\n        const builder = newFactory().from(importPTestData.unsignedHex);\n        const tx = await builder.build();\n        tx.toJson().signatures.length.should.equal(0);\n      });\n\n      it('should have 1 signature for half-signed tx', async () => {\n        const builder = newFactory().from(importPTestData.halfSigntxHex);\n        const tx = await builder.build();\n        tx.toJson().signatures.length.should.equal(1);\n      });\n\n      it('should have 2 signatures for fully-signed tx', async () => {\n        const builder = newFactory().from(importPTestData.signedHex);\n        const tx = await builder.build();\n        tx.toJson().signatures.length.should.equal(2);\n      });\n    });\n\n    describe('Multiple UTXOs with different address orderings', () => {\n      it('should handle multiple UTXOs where each has different address order', async () => {\n        const mixedOrderUtxos = [\n          {\n            ...importCTestData.utxos[0],\n            addresses: [importCTestData.pAddresses[2], importCTestData.pAddresses[0], importCTestData.pAddresses[1]],\n          },\n          {\n            ...importCTestData.utxos[1],\n            addresses: [importCTestData.pAddresses[0], importCTestData.pAddresses[1], importCTestData.pAddresses[2]],\n          },\n          {\n            ...importCTestData.utxos[2],\n            addresses: [importCTestData.pAddresses[1], importCTestData.pAddresses[2], importCTestData.pAddresses[0]],\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(mixedOrderUtxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.signatures.length.should.equal(2);\n        tx.toBroadcastFormat().should.be.a.String();\n      });\n    });\n\n    describe('Cross-builder consistency', () => {\n      it('should use same addressesIndex logic across all atomic builders', async () => {\n        const utxoAddresses = [\n          importPTestData.pAddresses[2],\n          importPTestData.pAddresses[0],\n          importPTestData.pAddresses[1],\n        ];\n\n        // ImportInP\n        const importPBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos([{ ...importPTestData.utxos[0], addresses: utxoAddresses }]);\n\n        importPBuilder.sign({ key: importPTestData.privateKeys[2] });\n        const importPTx = await importPBuilder.build();\n        importPTx.toJson().signatures.length.should.equal(1);\n\n        const importCBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos([{ ...importCTestData.utxos[0], addresses: utxoAddresses }])\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        importCBuilder.sign({ key: importCTestData.privateKeys[2] });\n        const importCTx = await importCBuilder.build();\n        importCTx.toJson().signatures.length.should.equal(1);\n\n        const exportPBuilder = newFactory()\n          .getExportInPBuilder()\n          .threshold(exportPTestData.threshold)\n          .locktime(exportPTestData.locktime)\n          .fromPubKey(exportPTestData.pAddresses)\n          .amount('20000000')\n          .externalChainId(exportPTestData.sourceChainId)\n          .feeState(exportPTestData.feeState)\n          .context(exportPTestData.context)\n          .decodedUtxos([{ ...exportPTestData.utxos[1], addresses: utxoAddresses }]);\n\n        exportPBuilder.sign({ key: exportPTestData.privateKeys[2] });\n        const exportPTx = await exportPBuilder.build();\n        exportPTx.toJson().signatures.length.should.equal(1);\n      });\n    });\n  });\n\n  describe('Real-world Scenario: Failed Transaction Fix Verification', () => {\n    it('should correctly sign when UTXO addresses are in IMS order (not BitGo order)', async () => {\n      const imsOrderUtxos = [\n        {\n          ...importPTestData.utxos[0],\n          addresses: [importPTestData.pAddresses[1], importPTestData.pAddresses[2], importPTestData.pAddresses[0]],\n        },\n      ];\n\n      const wpBuilder = newFactory()\n        .getImportInPBuilder()\n        .threshold(importPTestData.threshold)\n        .locktime(importPTestData.locktime)\n        .fromPubKey(importPTestData.corethAddresses)\n        .to(importPTestData.pAddresses)\n        .externalChainId(importPTestData.sourceChainId)\n        .feeState(importPTestData.feeState)\n        .context(importPTestData.context)\n        .decodedUtxos(imsOrderUtxos);\n\n      const unsignedTx = await wpBuilder.build();\n      const unsignedHex = unsignedTx.toBroadcastFormat();\n\n      const ovc1Builder = newFactory().from(unsignedHex);\n      ovc1Builder.sign({ key: importPTestData.privateKeys[2] });\n      const halfSignedTx = await ovc1Builder.build();\n      const halfSignedHex = halfSignedTx.toBroadcastFormat();\n\n      halfSignedTx.toJson().signatures.length.should.equal(1);\n\n      const ovc2Builder = newFactory().from(halfSignedHex);\n      ovc2Builder.sign({ key: importPTestData.privateKeys[0] });\n      const fullSignedTx = await ovc2Builder.build();\n\n      fullSignedTx.toJson().signatures.length.should.equal(2);\n\n      const txId = fullSignedTx.id;\n      txId.should.be.a.String();\n      txId.length.should.be.greaterThan(0);\n    });\n\n    it('should handle the exact UTXO configuration from the failed production transaction', async () => {\n      const builder1 = newFactory()\n        .getImportInPBuilder()\n        .threshold(importPTestData.threshold)\n        .locktime(importPTestData.locktime)\n        .fromPubKey(importPTestData.corethAddresses)\n        .to(importPTestData.pAddresses)\n        .externalChainId(importPTestData.sourceChainId)\n        .feeState(importPTestData.feeState)\n        .context(importPTestData.context)\n        .decodedUtxos(importPTestData.utxos);\n\n      const unsignedTx = await builder1.build();\n\n      const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());\n      builder2.sign({ key: importPTestData.privateKeys[2] });\n      const halfSignedTx = await builder2.build();\n\n      const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());\n      builder3.sign({ key: importPTestData.privateKeys[0] });\n      const fullSignedTx = await builder3.build();\n\n      fullSignedTx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n      fullSignedTx.id.should.equal(importPTestData.txhash);\n    });\n  });\n\n  /**\n   * Test suite for UTXO reordering fix.\n   *\n   * FlareJS's newImportTx/newExportTx functions sort inputs by UTXO ID (txid + outputidx)\n   * for deterministic transaction building. The SDK must match inputs back to UTXOs\n   * by UTXO ID, not by array index, to ensure credentials are created for the correct inputs.\n   *\n   * These tests verify that transactions with multiple UTXOs work correctly regardless\n   * of the order in which UTXOs are provided.\n   */\n  describe('UTXO Reordering Fix - Multiple UTXOs with Different txids', () => {\n    describe('ImportInC with reordered UTXOs', () => {\n      it('should correctly handle multiple UTXOs that may get reordered by FlareJS', async () => {\n        const reorderedUtxos = [importCTestData.utxos[4], importCTestData.utxos[0]];\n\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(reorderedUtxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n\n        txJson.signatures.length.should.equal(2);\n        tx.toBroadcastFormat().should.be.a.String();\n        txJson.inputs.length.should.equal(2);\n      });\n\n      it('should correctly sign in parse-sign-parse-sign flow with multiple UTXOs', async () => {\n        const reorderedUtxos = [importCTestData.utxos[3], importCTestData.utxos[1]];\n\n        const builder1 = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(reorderedUtxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        const unsignedTx = await builder1.build();\n        unsignedTx.toJson().signatures.length.should.equal(0);\n\n        const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());\n        builder2.sign({ key: importCTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        halfSignedTx.toJson().signatures.length.should.equal(1);\n\n        const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder3.sign({ key: importCTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n\n        fullSignedTx.toBroadcastFormat().should.be.a.String();\n        fullSignedTx.id.should.be.a.String();\n      });\n\n      it('should handle 3+ UTXOs with different ordering', async () => {\n        const mixedUtxos = [importCTestData.utxos[2], importCTestData.utxos[4], importCTestData.utxos[0]];\n\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(mixedUtxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        tx.toJson().signatures.length.should.equal(2);\n        tx.toJson().inputs.length.should.equal(3);\n      });\n\n      it('should handle all 5 UTXOs from test data', async () => {\n        const allUtxosReversed = [...importCTestData.utxos].reverse();\n\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(allUtxosReversed)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        tx.toJson().signatures.length.should.equal(2);\n        tx.toJson().inputs.length.should.equal(5);\n      });\n    });\n\n    describe('ImportInP with multiple UTXOs', () => {\n      it('should correctly handle multiple UTXOs with different outputidx', async () => {\n        const multipleUtxos = [\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '1',\n            amount: '25000000',\n          },\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '0',\n            amount: '25000000',\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(multipleUtxos);\n\n        txBuilder.sign({ key: importPTestData.privateKeys[2] });\n        txBuilder.sign({ key: importPTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        tx.toJson().signatures.length.should.equal(2);\n        tx.toJson().inputs.length.should.equal(2);\n      });\n\n      it('should correctly sign in parse-sign-parse-sign flow with multiple UTXOs', async () => {\n        const multipleUtxos = [\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '1',\n            amount: '25000000',\n          },\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '0',\n            amount: '25000000',\n          },\n        ];\n\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(multipleUtxos);\n\n        const unsignedTx = await builder1.build();\n\n        const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n\n        const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder3.sign({ key: importPTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n        fullSignedTx.toBroadcastFormat().should.be.a.String();\n      });\n    });\n\n    describe('ExportInP with multiple UTXOs', () => {\n      it('should correctly handle multiple UTXOs that may get reordered', async () => {\n        const reorderedUtxos = [\n          {\n            ...exportPTestData.utxos[1],\n            outputidx: '1',\n          },\n          {\n            ...exportPTestData.utxos[1],\n            outputidx: '0',\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getExportInPBuilder()\n          .threshold(exportPTestData.threshold)\n          .locktime(exportPTestData.locktime)\n          .fromPubKey(exportPTestData.pAddresses)\n          .amount('20000000')\n          .externalChainId(exportPTestData.sourceChainId)\n          .feeState(exportPTestData.feeState)\n          .context(exportPTestData.context)\n          .decodedUtxos(reorderedUtxos);\n\n        txBuilder.sign({ key: exportPTestData.privateKeys[2] });\n        txBuilder.sign({ key: exportPTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        tx.toJson().signatures.length.should.equal(2);\n      });\n\n      it('should correctly sign in parse-sign-parse-sign flow with multiple UTXOs', async () => {\n        const reorderedUtxos = [\n          {\n            ...exportPTestData.utxos[1],\n            outputidx: '1',\n          },\n          {\n            ...exportPTestData.utxos[1],\n            outputidx: '0',\n          },\n        ];\n\n        const builder1 = newFactory()\n          .getExportInPBuilder()\n          .threshold(exportPTestData.threshold)\n          .locktime(exportPTestData.locktime)\n          .fromPubKey(exportPTestData.pAddresses)\n          .amount('20000000')\n          .externalChainId(exportPTestData.sourceChainId)\n          .feeState(exportPTestData.feeState)\n          .context(exportPTestData.context)\n          .decodedUtxos(reorderedUtxos);\n\n        const unsignedTx = await builder1.build();\n\n        const builder2 = newFactory().from(unsignedTx.toBroadcastFormat());\n        builder2.sign({ key: exportPTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n\n        const builder3 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder3.sign({ key: exportPTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n        fullSignedTx.toBroadcastFormat().should.be.a.String();\n      });\n    });\n\n    describe('Edge cases for UTXO matching', () => {\n      it('should match UTXOs by both txid AND outputidx', async () => {\n        const sameIdUtxos = [\n          {\n            ...importCTestData.utxos[0],\n            outputidx: '2',\n          },\n          {\n            ...importCTestData.utxos[0],\n            outputidx: '0',\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(sameIdUtxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        tx.toJson().signatures.length.should.equal(2);\n        tx.toJson().inputs.length.should.equal(2);\n      });\n\n      it('should work correctly when UTXOs are already in sorted order', async () => {\n        const sortedUtxos = [importCTestData.utxos[0], importCTestData.utxos[1]];\n\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(sortedUtxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        txBuilder.sign({ key: importCTestData.privateKeys[2] });\n        txBuilder.sign({ key: importCTestData.privateKeys[0] });\n\n        const tx = await txBuilder.build();\n        tx.toJson().signatures.length.should.equal(2);\n      });\n    });\n  });\n\n  /**\n   * Tests specifically for the sigIndices fix.\n   *\n   * Background: FLRP import to P transactions were failing with:\n   * - \"could not parse transaction\" (HSM error)\n   * - \"wrong signature\" (on-chain error)\n   *\n   * Root cause: Mismatch between SDK's assumed credential order and FlareJS's\n   * actual sigIndices order. When UTXO addresses are sorted differently than\n   * sender addresses, the credentials must follow FlareJS's sigIndices order\n   * (ascending by UTXO position), not the SDK's sender address order.\n   *\n   * The fix reads actual sigIndices from FlareJS-built transaction inputs\n   * and creates credentials in that exact order.\n   *\n   * Real-world failure examples:\n   * 1. Wallet 697738a870cd159b6ab80f7071e3146a - HSM error \"could not parse transaction\"\n   *    - UTXO addresses: [r6gzm4acz..., x3u4xeal7..., l4f9rrc7w...]\n   *    - Sender addresses: [l4f9rrc7w..., x3u4xeal7..., r6gzm4acz...]\n   *\n   * 2. Wallet 69773884a565c4dbaf680e360b920c9e - On-chain \"wrong signature\"\n   *    - UTXO addresses: [t37m2e8fa..., urz6r3jy2..., 7r4k0nqne...]\n   *    - Sender addresses: [urz6r3jy2..., 7r4k0nqne..., t37m2e8fa...]\n   */\n  describe('SigIndices Fix Verification', () => {\n    describe('Credential ordering matches FlareJS sigIndices', () => {\n      it('should create credentials in correct order when UTXO addresses differ from sender order', async () => {\n        // Test data where UTXO addresses are in different order than pAddresses\n        // UTXO addresses: [xv5mulgpe..., 06gc5h5qs..., cueygd7fd...]\n        // pAddresses:     [06gc5h5qs..., cueygd7fd..., xv5mulgpe...]\n        //\n        // FlareJS will compute sigIndices based on which addresses are signing\n        // and their positions in the UTXO's address list (sorted by address bytes)\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        const tx = await txBuilder.build();\n        const hex = tx.toBroadcastFormat();\n\n        // The fix ensures the unsigned tx has credentials ordered correctly\n        // Before fix: credentials were in sender address order\n        // After fix: credentials are in sigIndices order (ascending UTXO position)\n        hex.should.equal(importPTestData.unsignedHex);\n\n        // Verify we can sign and the signatures go in the correct slots\n        const builder1 = newFactory().from(hex);\n        builder1.sign({ key: importPTestData.privateKeys[2] }); // user key\n        const halfSignedTx = await builder1.build();\n\n        halfSignedTx.toBroadcastFormat().should.equal(importPTestData.halfSigntxHex);\n\n        const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder2.sign({ key: importPTestData.privateKeys[0] }); // bitgo key\n        const fullSignedTx = await builder2.build();\n\n        fullSignedTx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n      });\n\n      it('should produce valid signatures when signing keys are provided in any order', async () => {\n        // This tests that the fix properly handles the address mapping\n        // regardless of which key signs first\n        const txBuilder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        // Sign user first, then bitgo\n        txBuilder1.sign({ key: importPTestData.privateKeys[2] });\n        txBuilder1.sign({ key: importPTestData.privateKeys[0] });\n        const tx1 = await txBuilder1.build();\n\n        const txBuilder2 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        // Sign bitgo first, then user\n        txBuilder2.sign({ key: importPTestData.privateKeys[0] });\n        txBuilder2.sign({ key: importPTestData.privateKeys[2] });\n        const tx2 = await txBuilder2.build();\n\n        // Both should produce the same valid transaction\n        tx1.toBroadcastFormat().should.equal(tx2.toBroadcastFormat());\n        tx1.toJson().signatures.length.should.equal(2);\n        tx2.toJson().signatures.length.should.equal(2);\n      });\n\n      it('should handle Export P transaction with correct sigIndices order', async () => {\n        const txBuilder = newFactory()\n          .getExportInPBuilder()\n          .threshold(exportPTestData.threshold)\n          .locktime(exportPTestData.locktime)\n          .fromPubKey(exportPTestData.pAddresses)\n          .externalChainId(exportPTestData.sourceChainId)\n          .feeState(exportPTestData.feeState)\n          .context(exportPTestData.context)\n          .decodedUtxos(exportPTestData.utxos)\n          .amount(exportPTestData.amount);\n\n        const tx = await txBuilder.build();\n        const hex = tx.toBroadcastFormat();\n\n        hex.should.equal(exportPTestData.unsignedHex);\n\n        // Verify signing flow\n        const builder1 = newFactory().from(hex);\n        builder1.sign({ key: exportPTestData.privateKeys[2] });\n        const halfSignedTx = await builder1.build();\n\n        halfSignedTx.toBroadcastFormat().should.equal(exportPTestData.halfSigntxHex);\n      });\n\n      it('should handle Import C transaction with correct sigIndices order', async () => {\n        const txBuilder = newFactory()\n          .getImportInCBuilder()\n          .threshold(importCTestData.threshold)\n          .fromPubKey(importCTestData.pAddresses)\n          .decodedUtxos(importCTestData.utxos)\n          .to(importCTestData.to)\n          .fee(importCTestData.fee)\n          .context(importCTestData.context);\n\n        const tx = await txBuilder.build();\n        const hex = tx.toBroadcastFormat();\n\n        hex.should.equal(importCTestData.unsignedHex);\n\n        // Verify signing flow\n        const builder1 = newFactory().from(hex);\n        builder1.sign({ key: importCTestData.privateKeys[2] });\n        const halfSignedTx = await builder1.build();\n\n        halfSignedTx.toBroadcastFormat().should.equal(importCTestData.halfSigntxHex);\n      });\n    });\n\n    describe('Two-phase signing flow (mimics HSM flow)', () => {\n      it('should support build -> serialize -> parse -> sign -> serialize -> parse -> sign flow for Import P', async () => {\n        // Phase 1: Build unsigned transaction\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(importPTestData.utxos);\n\n        const unsignedTx = await builder1.build();\n        const unsignedHex = unsignedTx.toBroadcastFormat();\n\n        // Phase 2: Parse unsigned and add first signature (user/backup)\n        const builder2 = newFactory().from(unsignedHex);\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        const halfSignedTx = await builder2.build();\n        const halfSignedHex = halfSignedTx.toBroadcastFormat();\n\n        halfSignedTx.toJson().signatures.length.should.equal(1);\n\n        // Phase 3: Parse half-signed and add second signature (bitgo)\n        const builder3 = newFactory().from(halfSignedHex);\n        builder3.sign({ key: importPTestData.privateKeys[0] });\n        const fullSignedTx = await builder3.build();\n\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n        fullSignedTx.toBroadcastFormat().should.equal(importPTestData.signedHex);\n      });\n    });\n\n    describe('Failed transaction scenarios (real-world cases)', () => {\n      /**\n       * This test simulates the exact failure pattern from wallet 697738a870cd159b6ab80f7071e3146a\n       * which failed at HSM with \"could not parse transaction\".\n       *\n       * The failure occurred because:\n       * - UTXO addresses were in order: [addr0, addr1, addr2]\n       * - Sender addresses were in order: [addr2, addr1, addr0] (reversed)\n       * - FlareJS computed sigIndices based on UTXO positions\n       * - SDK was creating credentials based on sender positions (wrong)\n       *\n       * After the fix, credentials are created in the order specified by FlareJS sigIndices.\n       */\n      it('should handle address ordering where UTXO order differs significantly from sender order', async () => {\n        // Simulate the failed case pattern:\n        // UTXO addresses: [pAddresses[2], pAddresses[1], pAddresses[0]]\n        // Sender addresses: [pAddresses[0], pAddresses[1], pAddresses[2]]\n        const reorderedUtxos = [\n          {\n            ...importPTestData.utxos[0],\n            addresses: [\n              importPTestData.pAddresses[2], // backup at UTXO position 0\n              importPTestData.pAddresses[1], // bitgo at UTXO position 1\n              importPTestData.pAddresses[0], // user at UTXO position 2\n            ],\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(reorderedUtxos);\n\n        const tx = await txBuilder.build();\n        const hex = tx.toBroadcastFormat();\n\n        // Verify transaction can be built without errors\n        hex.should.be.a.String();\n        hex.length.should.be.greaterThan(0);\n\n        // Verify we can parse and sign the transaction\n        const builder1 = newFactory().from(hex);\n        builder1.sign({ key: importPTestData.privateKeys[2] }); // user key\n        const halfSignedTx = await builder1.build();\n\n        halfSignedTx.toJson().signatures.length.should.equal(1);\n\n        const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder2.sign({ key: importPTestData.privateKeys[0] }); // bitgo key\n        const fullSignedTx = await builder2.build();\n\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n\n        // Both signatures should be present and valid\n        const signatures = fullSignedTx.toJson().signatures;\n        signatures.forEach((sig: string) => {\n          sig.should.be.a.String();\n          sig.length.should.be.greaterThan(0);\n        });\n      });\n\n      /**\n       * This test simulates scenarios with multiple UTXOs where each has different\n       * address orderings, similar to the failed transaction with 4 UTXOs.\n       */\n      it('should handle multiple UTXOs with varying address orderings', async () => {\n        // Create multiple UTXOs with different address orderings\n        // Use same txid but different outputidx to create valid unique UTXOs\n        const multipleUtxos = [\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '0',\n            addresses: [\n              importPTestData.pAddresses[2], // backup first\n              importPTestData.pAddresses[0], // user second\n              importPTestData.pAddresses[1], // bitgo third\n            ],\n          },\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '1',\n            addresses: [\n              importPTestData.pAddresses[1], // bitgo first\n              importPTestData.pAddresses[2], // backup second\n              importPTestData.pAddresses[0], // user third\n            ],\n          },\n          {\n            ...importPTestData.utxos[0],\n            outputidx: '2',\n            addresses: [\n              importPTestData.pAddresses[0], // user first\n              importPTestData.pAddresses[1], // bitgo second\n              importPTestData.pAddresses[2], // backup third\n            ],\n          },\n        ];\n\n        const txBuilder = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(multipleUtxos);\n\n        const tx = await txBuilder.build();\n        const hex = tx.toBroadcastFormat();\n\n        // Verify transaction builds successfully\n        hex.should.be.a.String();\n        tx.toJson().inputs.length.should.equal(3);\n\n        // Verify full signing flow works\n        const builder1 = newFactory().from(hex);\n        builder1.sign({ key: importPTestData.privateKeys[2] });\n        const halfSignedTx = await builder1.build();\n\n        const builder2 = newFactory().from(halfSignedTx.toBroadcastFormat());\n        builder2.sign({ key: importPTestData.privateKeys[0] });\n        const fullSignedTx = await builder2.build();\n\n        // Each input should have its own credential\n        fullSignedTx.toJson().signatures.length.should.equal(2);\n      });\n\n      /**\n       * This test verifies that signing order doesn't matter even with\n       * complex address orderings - the fix ensures signatures go to\n       * the correct slots based on FlareJS sigIndices.\n       */\n      it('should produce identical results regardless of signing order with reordered addresses', async () => {\n        const reorderedUtxos = [\n          {\n            ...importPTestData.utxos[0],\n            addresses: [importPTestData.pAddresses[2], importPTestData.pAddresses[1], importPTestData.pAddresses[0]],\n          },\n        ];\n\n        // Sign user first, then bitgo\n        const builder1 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(reorderedUtxos);\n\n        builder1.sign({ key: importPTestData.privateKeys[2] });\n        builder1.sign({ key: importPTestData.privateKeys[0] });\n        const tx1 = await builder1.build();\n\n        // Sign bitgo first, then user\n        const builder2 = newFactory()\n          .getImportInPBuilder()\n          .threshold(importPTestData.threshold)\n          .locktime(importPTestData.locktime)\n          .fromPubKey(importPTestData.corethAddresses)\n          .to(importPTestData.pAddresses)\n          .externalChainId(importPTestData.sourceChainId)\n          .feeState(importPTestData.feeState)\n          .context(importPTestData.context)\n          .decodedUtxos(reorderedUtxos);\n\n        builder2.sign({ key: importPTestData.privateKeys[0] });\n        builder2.sign({ key: importPTestData.privateKeys[2] });\n        const tx2 = await builder2.build();\n\n        // Both should produce identical fully signed transactions\n        tx1.toBroadcastFormat().should.equal(tx2.toBroadcastFormat());\n        tx1.toJson().signatures.length.should.equal(2);\n        tx2.toJson().signatures.length.should.equal(2);\n      });\n    });\n  });\n});\n"]}