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

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/pushnotificationsservice.ts

@@ -47,10 +47,10 @@ const PUSHNOTIFICATIONS_TYPES = {
     dataOnly: true,
     broadcastToActiveUsers: true
   },
-  NewBlock: {
-    dataOnly: true,
-    broadcastToActiveUsers: true
-  },
+  // NewBlock: {
+  //   dataOnly: true,
+  //   broadcastToActiveUsers: true
+  // },
   TxProposalAcceptedBy: {
     dataOnly: true
   },
@@ -713,15 +713,15 @@ export class PushNotificationsService {
 
   private coinGeckoGetCredentials() {
     if (!config.coinGecko) throw new Error('coinGecko missing credentials');
- 
+
     const credentials = {
       API: config.coinGecko.api,
       API_KEY: config.coinGecko.apiKey,
     };
- 
+
     return credentials;
   }
- 
+
   getTokenData(chain: string): Promise<Array<{
     chainId: number;
     address: string;
@@ -733,11 +733,11 @@ export class PushNotificationsService {
     return new Promise((resolve, reject) => {
       const cacheKey = `cgTokenList:${chain}`;
       const credentials = this.coinGeckoGetCredentials();
- 
+
       this.storage.checkAndUseGlobalCache(cacheKey, Defaults.COIN_GECKO_CACHE_DURATION, (err, values, oldvalues) => {
         if (err) logger.warn('Cache check failed', err);
         if (values) return resolve(values);
- 
+
         const assetPlatformMap = {
           eth: 'ethereum',
           matic: 'polygon-pos',
@@ -747,17 +747,17 @@ export class PushNotificationsService {
           op: 'optimistic-ethereum',
           sol: 'solana',
         };
- 
+
         const assetId = assetPlatformMap[chain];
         if (!assetId) return reject(new Error(`Unsupported chain '${chain}'`));
- 
+
         const URL: string = `${credentials.API}/v3/token_lists/${assetId}/all.json`;
         const headers = {
           'Content-Type': 'application/json',
           'Accept': 'application/json',
           'x-cg-pro-api-key': credentials.API_KEY
         };
- 
+
         this.request.get(
           URL,
           {

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: {