@toruslabs/ethereum-controllers 7.2.1 → 7.4.0

package/dist/ethereumControllers.cjs.js

@@ -22455,23 +22455,6 @@ class src_TokenRatesController extends src_base_controllers_namespaceObject.Base
 
 
 
-function src_getObjectFromArrayBasedonKey(oldArray, key) {
-  return oldArray.reduce((acc, x) => {
-    const xkey = x[key];
-    if (typeof xkey === "boolean") return acc;
-    acc[xkey] = x;
-    return acc;
-  }, {});
-}
-const src_mergeTokenArrays = (oldArray, newArray) => {
-  const oldMap = src_getObjectFromArrayBasedonKey(oldArray || [], "tokenAddress");
-  const newMap = src_getObjectFromArrayBasedonKey(newArray || [], "tokenAddress");
-  const finalArr = newArray;
-  Object.keys(oldMap).forEach(x => {
-    if (!newMap[x] && oldMap[x].isEtherScan) finalArr.push(oldMap[x]);
-  });
-  return finalArr;
-};
 const src_TokensController_DEFAULT_INTERVAL = 180 * 1000;
 class src_TokensController extends src_base_controllers_namespaceObject.BaseController {
   constructor({
@@ -22624,45 +22607,58 @@ class src_TokensController extends src_base_controllers_namespaceObject.BaseCont
     const userAddress = this.userSelectedAddress;
     if (userAddress === "") return;
     const oldTokens = [...this.userTokens];
-    const tokenAddresses = oldTokens.map(x => x.tokenAddress);
-    const nonZeroTokens = [];
+    // - fetch from Etherscan, if failed then fetch from TokenHandler
+    // - if there are remaining tokens, fetch either from SingleAddressContract (if failed then use TokenHandler) or TokenHandler
     try {
+      const nonZeroTokens = [];
       const currentChainId = this.config.chainId;
       if (src_ETHERSCAN_SUPPORTED_CHAINS.includes(currentChainId)) {
         const etherscanBalances = await this.getEtherScanTokens(userAddress, currentChainId, skipCache);
         nonZeroTokens.push(...etherscanBalances);
       }
-      if (tokenAddresses.length > 0) {
+
+      // only fetch balances for tokens that are not already in the nonZeroTokens array
+      const remainingTokens = oldTokens.filter(x => !nonZeroTokens.find(y => {
+        var _y$tokenAddress, _x$tokenAddress;
+        return ((_y$tokenAddress = y.tokenAddress) === null || _y$tokenAddress === void 0 ? void 0 : _y$tokenAddress.toLocaleLowerCase()) === ((_x$tokenAddress = x.tokenAddress) === null || _x$tokenAddress === void 0 ? void 0 : _x$tokenAddress.toLocaleLowerCase());
+      }));
+      if (remainingTokens.length > 0) {
+        const remainingTokensAddresses = remainingTokens.map(x => x.tokenAddress);
         const currentSingleCallAddress = src_SINGLE_CALL_BALANCES_ADDRESSES[currentChainId];
         if (currentSingleCallAddress) {
           const ethContract = new src_external_ethers_namespaceObject.Contract(currentSingleCallAddress, src_singleBalanceCheckerAbi, this.ethersProvider);
-          const result = await ethContract.balances([userAddress], tokenAddresses);
-          tokenAddresses.forEach((_, index) => {
+          const result = await ethContract.balances([userAddress], remainingTokensAddresses);
+          remainingTokensAddresses.forEach((_, index) => {
             const balance = (0,src_external_ethers_namespaceObject.toQuantity)(result[index]);
             if (balance && balance !== "0x0") {
-              nonZeroTokens.push(src_objectSpread2_default()(src_objectSpread2_default()({}, oldTokens[index]), {}, {
+              nonZeroTokens.push(src_objectSpread2_default()(src_objectSpread2_default()({}, remainingTokens[index]), {}, {
                 balance,
                 chainId: currentChainId
               }));
             }
           });
         } else {
-          this.getTokenBalancesUsingHandler(oldTokens);
+          const fetchedRemainingTokens = await this.getTokenBalancesUsingHandler(remainingTokens);
+          nonZeroTokens.push(...fetchedRemainingTokens);
         }
       }
+      this.update({
+        tokens: {
+          [userAddress]: nonZeroTokens
+        }
+      });
     } catch (error) {
       src_external_loglevel_default().error(error, "unable to fetch token balances using single call balance address");
-      this.getTokenBalancesUsingHandler(oldTokens);
-    } finally {
+      const fetchedTokens = await this.getTokenBalancesUsingHandler(oldTokens);
       this.update({
         tokens: {
-          [userAddress]: nonZeroTokens
+          [userAddress]: fetchedTokens
         }
       });
     }
   }
   async getTokenBalancesUsingHandler(customTokens) {
-    if (!this.userSelectedAddress) return;
+    if (!this.userSelectedAddress) return [];
     const currentNetworkTokens = customTokens;
     const promiseSettledResult = await Promise.allSettled(currentNetworkTokens.map(async x => {
       try {
@@ -22695,11 +22691,7 @@ class src_TokensController extends src_base_controllers_namespaceObject.BaseCont
       if (x.status === "fulfilled" && x.value) acc.push(x.value);
       return acc;
     }, []);
-    this.update({
-      tokens: {
-        [this.userSelectedAddress]: src_mergeTokenArrays(this.userTokens, nonZeroTokens)
-      }
-    });
+    return nonZeroTokens;
   }
 }
 ;// ./src/Transaction/NonceTracker.ts

package/dist/ethereumControllers.esm.js

@@ -4815,23 +4815,6 @@ class TokenRatesController extends BaseController {
   }
 }
 
-function getObjectFromArrayBasedonKey(oldArray, key) {
-  return oldArray.reduce((acc, x) => {
-    const xkey = x[key];
-    if (typeof xkey === "boolean") return acc;
-    acc[xkey] = x;
-    return acc;
-  }, {});
-}
-const mergeTokenArrays = (oldArray, newArray) => {
-  const oldMap = getObjectFromArrayBasedonKey(oldArray || [], "tokenAddress");
-  const newMap = getObjectFromArrayBasedonKey(newArray || [], "tokenAddress");
-  const finalArr = newArray;
-  Object.keys(oldMap).forEach(x => {
-    if (!newMap[x] && oldMap[x].isEtherScan) finalArr.push(oldMap[x]);
-  });
-  return finalArr;
-};
 const DEFAULT_INTERVAL = 180 * 1000;
 class TokensController extends BaseController {
   constructor({
@@ -4984,45 +4967,58 @@ class TokensController extends BaseController {
     const userAddress = this.userSelectedAddress;
     if (userAddress === "") return;
     const oldTokens = [...this.userTokens];
-    const tokenAddresses = oldTokens.map(x => x.tokenAddress);
-    const nonZeroTokens = [];
+    // - fetch from Etherscan, if failed then fetch from TokenHandler
+    // - if there are remaining tokens, fetch either from SingleAddressContract (if failed then use TokenHandler) or TokenHandler
     try {
+      const nonZeroTokens = [];
       const currentChainId = this.config.chainId;
       if (ETHERSCAN_SUPPORTED_CHAINS.includes(currentChainId)) {
         const etherscanBalances = await this.getEtherScanTokens(userAddress, currentChainId, skipCache);
         nonZeroTokens.push(...etherscanBalances);
       }
-      if (tokenAddresses.length > 0) {
+
+      // only fetch balances for tokens that are not already in the nonZeroTokens array
+      const remainingTokens = oldTokens.filter(x => !nonZeroTokens.find(y => {
+        var _y$tokenAddress, _x$tokenAddress;
+        return ((_y$tokenAddress = y.tokenAddress) === null || _y$tokenAddress === void 0 ? void 0 : _y$tokenAddress.toLocaleLowerCase()) === ((_x$tokenAddress = x.tokenAddress) === null || _x$tokenAddress === void 0 ? void 0 : _x$tokenAddress.toLocaleLowerCase());
+      }));
+      if (remainingTokens.length > 0) {
+        const remainingTokensAddresses = remainingTokens.map(x => x.tokenAddress);
         const currentSingleCallAddress = SINGLE_CALL_BALANCES_ADDRESSES[currentChainId];
         if (currentSingleCallAddress) {
           const ethContract = new Contract(currentSingleCallAddress, singleBalanceCheckerAbi, this.ethersProvider);
-          const result = await ethContract.balances([userAddress], tokenAddresses);
-          tokenAddresses.forEach((_, index) => {
+          const result = await ethContract.balances([userAddress], remainingTokensAddresses);
+          remainingTokensAddresses.forEach((_, index) => {
             const balance = toQuantity(result[index]);
             if (balance && balance !== "0x0") {
-              nonZeroTokens.push(_objectSpread(_objectSpread({}, oldTokens[index]), {}, {
+              nonZeroTokens.push(_objectSpread(_objectSpread({}, remainingTokens[index]), {}, {
                 balance,
                 chainId: currentChainId
               }));
             }
           });
         } else {
-          this.getTokenBalancesUsingHandler(oldTokens);
+          const fetchedRemainingTokens = await this.getTokenBalancesUsingHandler(remainingTokens);
+          nonZeroTokens.push(...fetchedRemainingTokens);
         }
       }
+      this.update({
+        tokens: {
+          [userAddress]: nonZeroTokens
+        }
+      });
     } catch (error) {
       log.error(error, "unable to fetch token balances using single call balance address");
-      this.getTokenBalancesUsingHandler(oldTokens);
-    } finally {
+      const fetchedTokens = await this.getTokenBalancesUsingHandler(oldTokens);
       this.update({
         tokens: {
-          [userAddress]: nonZeroTokens
+          [userAddress]: fetchedTokens
         }
       });
     }
   }
   async getTokenBalancesUsingHandler(customTokens) {
-    if (!this.userSelectedAddress) return;
+    if (!this.userSelectedAddress) return [];
     const currentNetworkTokens = customTokens;
     const promiseSettledResult = await Promise.allSettled(currentNetworkTokens.map(async x => {
       try {
@@ -5055,11 +5051,7 @@ class TokensController extends BaseController {
       if (x.status === "fulfilled" && x.value) acc.push(x.value);
       return acc;
     }, []);
-    this.update({
-      tokens: {
-        [this.userSelectedAddress]: mergeTokenArrays(this.userTokens, nonZeroTokens)
-      }
-    });
+    return nonZeroTokens;
   }
 }