@bitpay-labs/bitcore-wallet-service 11.6.0 → 11.6.2

package/src/lib/common/utils.ts

@@ -375,61 +375,66 @@ export const Utils = {
 
   /**
    * Sort array by keys in ascending order
-   * @param {Array<any>} arr Array to be sorted
-   * @param {...string|Array<string>} keys Keys to sort by in order. If a key is an array, it will be treated as a nested key.
+   * @param {Array<T>} arr Array to be sorted
+   * @param {...(string|string[])} keys Keys to sort by in order. If a key is an array, it will be treated as a nested key.
    *  e.g.: sortAsc(arr, 'a', 'b', ['c', 'd']) will sort by a, then b, then c.d
    * @returns 
    */
-  sortAsc(arr, ...keys) {
-    function transformVals(val1, val2) {
-      if (val1 === undefined) {
-        val1 = '\uFFFF'; // highest possible string value, otherwise 'undefined' < 'xyz'
-      } else if (val1 === null || val1 === false || val1.toString() === 'NaN') {
-        val1 = '0';
-      } else if (val1 === true) {
-        val1 = '1';
+  sortAsc<T = any>(arr: Array<T>, ...keys: (string | string[])[]): Array<T> {
+    function normalizeVal(v) {
+      if (v === undefined) return '\uFFFF'; // highest possible value, sorts last
+      if (v === null || v === false || v?.toString() === 'NaN') return 0;
+      if (v === true) return 1;
+      return v;
+    }
+
+    function compareVals(a, b): number {
+      a = normalizeVal(a);
+      b = normalizeVal(b);
+
+      // Compare bigints directly to avoid loss of precision via Number()
+      if (typeof a === 'bigint' && typeof b === 'bigint') {
+        return a < b ? -1 : a > b ? 1 : 0;
       }
 
-      if (val2 === undefined) {
-        val2 = '\uFFFF'; // highest possible string value, otherwise 'undefined' < 'xyz'
-      } else if (val2 === null || val2 === false || val2.toString() === 'NaN') {
-        val2 = '0';
-      } else if (val2 === true) {
-        val2 = '1';
+      // Numeric comparison for numbers, bigints, and non-empty numeric strings
+      const aIsNumeric = typeof a !== 'string' ? !isNaN(Number(a)) : a.trim() !== '' && !isNaN(Number(a));
+      const bIsNumeric = typeof b !== 'string' ? !isNaN(Number(b)) : b.trim() !== '' && !isNaN(Number(b));
+      if (aIsNumeric && bIsNumeric) {
+        const na = Number(a);
+        const nb = Number(b);
+        return na < nb ? -1 : na > nb ? 1 : 0;
       }
 
-      return [Buffer.from(val1.toString()), Buffer.from(val2.toString())];
-    };
+      // String comparison fallback
+      const sa = String(a);
+      const sb = String(b);
+      return sa < sb ? -1 : sa > sb ? 1 : 0;
+    }
 
     if (!keys.length) {
-      return arr.sort((a, b) => { const [_a, _b] = transformVals(a, b); return _a.compare(_b); });
-    } else if (keys.length === 1 && !Array.isArray(keys[0])) {
-      return arr.sort((a, b) => { const [_a, _b] = transformVals(a[keys[0]], b[keys[0]]); return _a.compare(_b); });
+      return arr.sort((a, b) => compareVals(a, b));
     }
+
     return arr.sort((a, b) => {
-      // compare concatenated strings for multiple key sorting
-      let aVal = '';
-      let bVal = '';
       for (const k of keys) {
-        const [aTemp, bTemp] = transformVals(
+        const cmp = compareVals(
           Array.isArray(k) ? k.reduce((val, key) => val[key], a) : a[k],
           Array.isArray(k) ? k.reduce((val, key) => val[key], b) : b[k]
         );
-
-        aVal += aTemp.toString();
-        bVal += bTemp.toString();
+        if (cmp !== 0) return cmp;
       }
-      return Buffer.from(aVal).compare(Buffer.from(bVal));
+      return 0;
     });
   },
 
   /**
    * Sort array by keys in descending order
-   * @param {Array<any>} arr Array to be sorted
-   * @param {...string|Array<string>} keys Keys to sort by in order. If a key is an array, it will be treated as a nested key.
+   * @param {Array<T>} arr Array to be sorted
+   * @param {...(string|string[])} keys Keys to sort by in order. If a key is an array, it will be treated as a nested key.
    *  e.g.: sortDesc(arr, 'a', 'b', ['c', 'd']) will sort by a, then b, then c.d
    */
-  sortDesc(arr: Array<any>, ...keys: string[]) {
+  sortDesc<T = any>(arr: Array<T>, ...keys: (string | string[])[]): Array<T> {
     return Utils.sortAsc(arr, ...keys).reverse();
   },
 

package/src/lib/tss.ts

@@ -185,12 +185,14 @@ class TssKeyGenClass {
     id: string;
     message: {
       publicKey: ITssKeyMessageObject['publicKey'];
+      /** unused */
       encryptedKeyChain: string;
     };
+    /** unused - only needed for storing the encryptedKeyChain */
     copayerId: string;
   }) {
-    const { id, message, copayerId } = params;
-    const { publicKey, encryptedKeyChain } = message;
+    const { id, message } = params;
+    const { publicKey } = message;
     if (!publicKey) {
       throw Errors.TSS_GENERIC_ERROR.withMessage('No public key provided');
     }
@@ -210,15 +212,21 @@ class TssKeyGenClass {
       }
     }
 
-    if (encryptedKeyChain) {
-      const partyId = session.participants.indexOf(copayerId);
-      const result = await storage.storeTssKeyShare({ id, partyId, encryptedKeyChain });
+    /**
+     * 2026-03-10:
+     *  Removing this feature until we decide to support keychain backup to our DB (probably never).
+     *  If we ever decide to do this, we may need to add support in BWC for restoring it.
+     */
 
-      if (!result.result.ok) {
-        logger.error('Failed to store TSS key generation public key %o %o', id, result);
-        throw Errors.TSS_GENERIC_ERROR.withMessage('Failed to store TSS key generation public key');
-      }
-    }
+    // if (encryptedKeyChain) {
+    //   const partyId = session.participants.indexOf(copayerId);
+    //   const result = await storage.storeTssKeyShare({ id, partyId, encryptedKeyChain });
+
+    //   if (!result.result.ok) {
+    //     logger.error('Failed to store TSS key generation public key %o %o', id, result);
+    //     throw Errors.TSS_GENERIC_ERROR.withMessage('Failed to store TSS key generation public key');
+    //   }
+    // }
   }
 
   async storeBwsJoinSecret(params: {