fix(sdk-coin-flrp): update AddressMap creation to match UTXO address order

Ticket: WIN-8279

Author: mohd-kashif

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

@@ -92,10 +92,6 @@ export class ImportInPTxBuilder extends AtomicTransactionBuilder {
     }
 
     // Create proper UnsignedTx wrapper with credentials
-    const sortedAddresses = [...this.transaction._fromAddresses].sort((a, b) => Buffer.compare(a, b));
-    const addressMaps = sortedAddresses.map((a, i) => new FlareUtils.AddressMap([[new Address(a), i]]));
-
-    // When credentials were extracted, use them directly to preserve existing signatures
     // Match avaxp behavior: dynamic ordering based on addressesIndex from UTXO
     const txCredentials =
       credentials.length > 0
@@ -142,6 +138,42 @@ export class ImportInPTxBuilder extends AtomicTransactionBuilder {
             }
           });
 
+    // Create AddressMaps based on signature slot order (matching credential order), not sorted addresses
+    // This matches the approach used in credentials: addressesIndex determines signature order
+    // AddressMaps should map addresses to signature slots in the same order as credentials
+    const addressMaps = this.transaction._utxos.map((utxo, utxoIdx) => {
+      const addressMap = new FlareUtils.AddressMap();
+
+      // If UTXO has addresses, compute addressesIndex to determine signature order
+      if (utxo && utxo.addresses && utxo.addresses.length > 0) {
+        const utxoAddresses = utxo.addresses.map((a) => utils.parseAddress(a));
+        const addressesIndex = this.transaction._fromAddresses.map((a) =>
+          utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0)
+        );
+
+        const firstIndex = this.recoverSigner ? 2 : 0;
+        const bitgoIndex = 1;
+
+        // Determine signature slot order based on addressesIndex (same logic as credentials)
+        if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {
+          // Bitgo comes first: slot 0 = bitgo, slot 1 = firstIndex
+          addressMap.set(new Address(this.transaction._fromAddresses[bitgoIndex]), 0);
+          addressMap.set(new Address(this.transaction._fromAddresses[firstIndex]), 1);
+        } else {
+          // User/recovery comes first: slot 0 = firstIndex, slot 1 = bitgo
+          addressMap.set(new Address(this.transaction._fromAddresses[firstIndex]), 0);
+          addressMap.set(new Address(this.transaction._fromAddresses[bitgoIndex]), 1);
+        }
+      } else {
+        // Fallback: map addresses sequentially if no UTXO addresses available
+        this.transaction._fromAddresses.slice(0, this.transaction._threshold).forEach((addr, i) => {
+          addressMap.set(new Address(addr), i);
+        });
+      }
+
+      return addressMap;
+    });
+
     const unsignedTx = new UnsignedTx(importTx, [], new FlareUtils.AddressMaps(addressMaps), txCredentials);
 
     this.transaction.setTransaction(unsignedTx);
@@ -200,8 +232,42 @@ export class ImportInPTxBuilder extends AtomicTransactionBuilder {
       inputs // importedInputs (ins)
     );
 
-    // Create address maps for signing
-    const addressMaps = this.transaction._fromAddresses.map((a, i) => new FlareUtils.AddressMap([[new Address(a), i]]));
+    // Create AddressMaps based on signature slot order (matching credential order), not sorted addresses
+    // This matches the approach used in credentials: addressesIndex determines signature order
+    // AddressMaps should map addresses to signature slots in the same order as credentials
+    const addressMaps = credentials.map((credential, credIdx) => {
+      const addressMap = new FlareUtils.AddressMap();
+      const utxo = this.transaction._utxos[credIdx];
+
+      // If UTXO has addresses, compute addressesIndex to determine signature order
+      if (utxo && utxo.addresses && utxo.addresses.length > 0) {
+        const utxoAddresses = utxo.addresses.map((a) => utils.parseAddress(a));
+        const addressesIndex = this.transaction._fromAddresses.map((a) =>
+          utxoAddresses.findIndex((u) => Buffer.compare(Buffer.from(u), Buffer.from(a)) === 0)
+        );
+
+        const firstIndex = this.recoverSigner ? 2 : 0;
+        const bitgoIndex = 1;
+
+        // Determine signature slot order based on addressesIndex (same logic as credentials)
+        if (addressesIndex[bitgoIndex] < addressesIndex[firstIndex]) {
+          // Bitgo comes first: slot 0 = bitgo, slot 1 = firstIndex
+          addressMap.set(new Address(this.transaction._fromAddresses[bitgoIndex]), 0);
+          addressMap.set(new Address(this.transaction._fromAddresses[firstIndex]), 1);
+        } else {
+          // User/recovery comes first: slot 0 = firstIndex, slot 1 = bitgo
+          addressMap.set(new Address(this.transaction._fromAddresses[firstIndex]), 0);
+          addressMap.set(new Address(this.transaction._fromAddresses[bitgoIndex]), 1);
+        }
+      } else {
+        // Fallback: map addresses sequentially if no UTXO addresses available
+        this.transaction._fromAddresses.slice(0, this.transaction._threshold).forEach((addr, i) => {
+          addressMap.set(new Address(addr), i);
+        });
+      }
+
+      return addressMap;
+    });
 
     // Create unsigned transaction
     const unsignedTx = new UnsignedTx(