@talismn/balances-react 0.0.0-pr589-20230302073822 → 0.0.0-pr593-20230306050934

package/dist/talismn-balances-react.cjs.prod.js

@@ -9,6 +9,7 @@ var tokenRates = require('@talismn/token-rates');
 var dexieReactHooks = require('dexie-react-hooks');
 var reactUse = require('react-use');
 var chaindataProviderExtension = require('@talismn/chaindata-provider-extension');
+var md5 = require('blueimp-md5');
 var anylogger = require('anylogger');
 var rxjs = require('rxjs');
 var chainConnector = require('@talismn/chain-connector');
@@ -16,6 +17,7 @@ var chainConnectorEvm = require('@talismn/chain-connector-evm');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
+var md5__default = /*#__PURE__*/_interopDefault(md5);
 var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
 
 const provideContext = useProviderContext => {
@@ -52,13 +54,15 @@ const useBalanceModulesProvider = ({
 const [BalanceModulesProvider, useBalanceModules] = provideContext(useBalanceModulesProvider);
 
 function useChaindataProvider(options = {}) {
-  const [chaindata, setChaindata] = react.useState();
+  const [onfinalityApiKey, setOnfinalityApiKey] = react.useState(options.onfinalityApiKey);
+
+  // make sure we recreate provider only when the onfinalityApiKey changes
   react.useEffect(() => {
-    setChaindata(new chaindataProviderExtension.ChaindataProviderExtension({
-      onfinalityApiKey: options.onfinalityApiKey
-    }));
-  }, [options.onfinalityApiKey]);
-  return chaindata;
+    if (options.onfinalityApiKey !== onfinalityApiKey) setOnfinalityApiKey(options.onfinalityApiKey);
+  }, [options.onfinalityApiKey, onfinalityApiKey]);
+  return react.useMemo(() => new chaindataProviderExtension.ChaindataProviderExtension({
+    onfinalityApiKey
+  }), [onfinalityApiKey]);
 }
 const [ChaindataProvider, useChaindata] = provideContext(useChaindataProvider);
 
@@ -134,9 +138,7 @@ const consolidateDbCache = (chainsMap, evmNetworksMap, tokensMap, tokenRates, al
     balances
   };
 };
-const useDbCacheProvider = ({
-  useTestnets = false
-}) => {
+const useDbCacheProvider = () => {
   const chaindataProvider = useChaindata();
   const chainList = dexieReactHooks.useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.chains(), [chaindataProvider]);
   const evmNetworkList = dexieReactHooks.useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.evmNetworks(), [chaindataProvider]);
@@ -148,7 +150,7 @@ const useDbCacheProvider = ({
   // debounce every 500ms to prevent hammering UI with updates
   reactUse.useDebounce(() => {
     setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates$1, rawBalances));
-  }, 500, [chainList, evmNetworkList, tokenList, rawBalances, tokenRates$1, useTestnets]);
+  }, 500, [chainList, evmNetworkList, tokenList, rawBalances, tokenRates$1]);
   const refInitialized = react.useRef(false);
 
   // force an update as soon as all datasources are fetched, so UI can display data ASAP
@@ -157,14 +159,14 @@ const useDbCacheProvider = ({
       setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates$1, rawBalances));
       refInitialized.current = true;
     }
-  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates$1, useTestnets]);
+  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates$1]);
   return dbData;
 };
 const [DbCacheProvider, useDbCache] = provideContext(useDbCacheProvider);
 
 var packageJson = {
 	name: "@talismn/balances-react",
-	version: "0.0.0-pr589-20230302073822",
+	version: "0.0.0-pr593-20230306050934",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "UNLICENSED",
@@ -197,6 +199,7 @@ var packageJson = {
 		"@talismn/chaindata-provider-extension": "workspace:^",
 		"@talismn/token-rates": "workspace:^",
 		anylogger: "^1.0.11",
+		"blueimp-md5": "2.19.0",
 		dexie: "^3.2.3",
 		"dexie-react-hooks": "^1.1.1",
 		"react-use": "^17.4.0",
@@ -227,6 +230,95 @@ var packageJson = {
 
 var log = anylogger__default["default"](packageJson.name);
 
+// global data store containing all subscriptions
+const subscriptions = {};
+
+/**
+ * This hook ensures a subscription is created only once, and unsubscribe automatically as soon as there is no consumer to the hook
+ * @param key key that is unique to the subscription's parameters
+ * @param subscribe // subscribe function that will be shared by all consumers of the key
+ */
+const useSharedSubscription = (key, subscribe) => {
+  // create the rxJS subject if it doesn't exist
+  if (!subscriptions[key]) subscriptions[key] = {
+    subject: new rxjs.Subject()
+  };
+  react.useEffect(() => {
+    // subscribe to subject.
+    // it won't change but we need to count subscribers, to unsubscribe main subscription when no more observers
+    const s = subscriptions[key].subject.subscribe();
+    return () => {
+      // unsubscribe from our local observable updates to prevent memory leaks
+      s.unsubscribe();
+      const {
+        subject,
+        unsubscribe
+      } = subscriptions[key];
+      if (!subject.observed && unsubscribe) {
+        log.debug(`[useSharedSubscription] unsubscribing ${key}`);
+
+        // unsubscribe from backend updates to prevent unnecessary network connections
+        unsubscribe();
+        delete subscriptions[key].unsubscribe;
+      }
+    };
+  }, [key]);
+
+  // Initialize subscription
+  react.useEffect(() => {
+    const {
+      unsubscribe
+    } = subscriptions[key];
+    // launch the subscription if it's a new key
+    if (!unsubscribe) {
+      const cb = subscribe();
+      log.debug(`[useSharedSubscription] subscribing ${key}`);
+      if (cb) subscriptions[key].unsubscribe = cb;
+      // this error should only happen when developping a new hook, let it bubble up
+      else throw new Error(`${key} subscribe did not return an unsubscribe callback`);
+    }
+  }, [key, subscribe]);
+};
+
+function useChainConnectorsProvider(options) {
+  const [onfinalityApiKey, setOnfinalityApiKey] = react.useState(options.onfinalityApiKey);
+
+  // make sure we recreate provider only when the onfinalityApiKey changes
+  react.useEffect(() => {
+    if (options.onfinalityApiKey !== onfinalityApiKey) setOnfinalityApiKey(options.onfinalityApiKey);
+  }, [options.onfinalityApiKey, onfinalityApiKey]);
+
+  // chaindata dependency
+  const chaindata = useChaindata();
+
+  // substrate connector
+  const substrate = react.useMemo(() => new chainConnector.ChainConnector(chaindata), [chaindata]);
+
+  // evm connector
+  const evm = react.useMemo(() => new chainConnectorEvm.ChainConnectorEvm(chaindata, {
+    onfinalityApiKey
+  }), [chaindata, onfinalityApiKey]);
+  return react.useMemo(() => ({
+    substrate,
+    evm
+  }), [substrate, evm]);
+}
+const [ChainConnectorsProvider, useChainConnectors] = provideContext(useChainConnectorsProvider);
+
+function useTokens(withTestnets) {
+  // keep db data up to date
+  useDbCacheSubscription("tokens");
+  const {
+    tokensWithTestnetsMap,
+    tokensWithoutTestnetsMap
+  } = useDbCache();
+  return withTestnets ? tokensWithTestnetsMap : tokensWithoutTestnetsMap;
+}
+function useToken(tokenId, withTestnets) {
+  const tokens = useTokens(withTestnets);
+  return tokenId ? tokens[tokenId] : undefined;
+}
+
 /**
  * Creates a subscription function that can be used to subscribe to a multicast observable created from an upstream source.
  *
@@ -268,193 +360,193 @@ const createMulticastSubscription = upstream => {
   return subscribe;
 };
 
-function useChainConnectorsProvider(options) {
-  // chaindata dependency
-  const chaindata = useChaindata();
-
-  // substrate connector
-  const [substrate, setSubstrate] = react.useState();
-  react.useEffect(() => {
-    if (!chaindata) return;
-    setSubstrate(new chainConnector.ChainConnector(chaindata));
-  }, [chaindata]);
-
-  // evm connector
-  const [evm, setEvm] = react.useState();
-  react.useEffect(() => {
-    if (!chaindata) return;
-    setEvm(new chainConnectorEvm.ChainConnectorEvm(chaindata, {
-      onfinalityApiKey: options.onfinalityApiKey
-    }));
-  }, [chaindata, options.onfinalityApiKey]);
-  return react.useMemo(() => ({
-    substrate,
-    evm
-  }), [substrate, evm]);
-}
-const [ChainConnectorsProvider, useChainConnectors] = provideContext(useChainConnectorsProvider);
-
-const useSubscriptionsProvider = () => [useSubscribeChaindataHydrate("chains"), useSubscribeChaindataHydrate("evmNetworks"), useSubscribeChaindataHydrate("tokens"), useSubscribeTokenRates(), useSubscribeBalances()];
-const [SubscriptionsProvider, useSubscriptions] = provideContext(useSubscriptionsProvider);
+const useWithTestnetsProvider = ({
+  withTestnets
+}) => {
+  return {
+    withTestnets
+  };
+};
+const [WithTestnetsProvider, useWithTestnets] = provideContext(useWithTestnetsProvider);
 
 /**
  * This hook is responsible for fetching the data used for balances and inserting it into the db.
  */
 const useDbCacheSubscription = subscribeTo => {
-  const [subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances] = useSubscriptions();
-  react.useEffect(() => {
+  const provider = useChaindata();
+
+  // can't handle balances & tokenRates here as they have other dependencies, it would trigger to many subscriptions
+  const subscribe = react.useCallback(() => {
     switch (subscribeTo) {
       case "chains":
-        return subscribeHydrateChains();
+        return subscribeChainDataHydrate(provider, "chains");
       case "evmNetworks":
-        return subscribeHydrateEvmNetworks();
+        return subscribeChainDataHydrate(provider, "evmNetworks");
       case "tokens":
-        return subscribeHydrateTokens();
-      case "tokenRates":
-        return subscribeTokenRates();
-      case "balances":
-        return subscribeBalances();
+        return subscribeChainDataHydrate(provider, "tokens");
     }
-  }, [subscribeTo, subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances]);
+  }, [provider, subscribeTo]);
+  useSharedSubscription(subscribeTo, subscribe);
 };
-function useSubscribeChaindataHydrate(type) {
-  const chaindata =
-  // cheeky hack to give us access to the hydrate methods
-  useChaindata();
-  const createSubscription = react.useCallback(() => {
-    if (!chaindata) return;
-    let active = true;
-    const interval = 300_000; // 300_000ms = 300s = 5 minutes
-
-    const hydrate = async () => {
-      if (!active) return;
-      try {
-        if (type === "chains") await chaindata.hydrateChains();
-        if (type === "evmNetworks") await chaindata.hydrateEvmNetworks();
-        if (type === "tokens") await chaindata.hydrateTokens();
-        setTimeout(hydrate, interval);
-      } catch (error) {
-        const retryTimeout = 5_000; // 5_000ms = 5 seconds
-        log.error(`Failed to fetch chaindata, retrying in ${Math.round(retryTimeout / 1000)} seconds`, error);
-        setTimeout(hydrate, retryTimeout);
-      }
-    };
-    hydrate();
-    return () => {
-      active = false;
-    };
-  }, [chaindata, type]);
-  const subscribe = useMulticastSubscription(createSubscription);
-  return subscribe;
-}
-function useSubscribeTokenRates() {
-  const chaindataProvider = useChaindata();
-  const tokens = dexieReactHooks.useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
-  const generationRef = react.useRef(0);
-  const createSubscription = react.useCallback(() => {
-    if (!chaindataProvider) return;
-    if (!tokens) return;
-    if (Object.keys(tokens).length < 1) return;
-
-    // when we make a new request, we want to ignore any old requests which haven't yet completed
-    // otherwise we risk replacing the most recent data with older data
-    const generation = (generationRef.current + 1) % Number.MAX_SAFE_INTEGER;
-    generationRef.current = generation;
-    let active = true;
-    const REFRESH_INTERVAL = 300_000; // 300_000ms = 5 minutes
-    const RETRY_INTERVAL = 5_000; // 5_000ms = 5 seconds
-
-    const hydrate = async () => {
-      if (!active) return;
-      if (generationRef.current !== generation) return;
-      try {
-        const tokenRates$1 = await tokenRates.fetchTokenRates(tokens);
-        if (!active) return;
-        if (generationRef.current !== generation) return;
-        const putTokenRates = Object.entries(tokenRates$1).map(([tokenId, rates]) => ({
-          tokenId,
-          rates
-        }));
-        tokenRates.db.transaction("rw", tokenRates.db.tokenRates, async () => await tokenRates.db.tokenRates.bulkPut(putTokenRates));
-        setTimeout(hydrate, REFRESH_INTERVAL);
-      } catch (error) {
-        log.error(`Failed to fetch tokenRates, retrying in ${Math.round(RETRY_INTERVAL / 1000)} seconds`, error);
-        setTimeout(hydrate, RETRY_INTERVAL);
-      }
-    };
-    hydrate();
-    return () => {
-      active = false;
-    };
-  }, [chaindataProvider, tokens]);
-  const subscribe = useMulticastSubscription(createSubscription);
-  return subscribe;
+
+/**
+ * This hook is responsible for fetching the data used for token rates and inserting it into the db.
+ */
+function useDbCacheTokenRatesSubscription() {
+  const {
+    withTestnets
+  } = useWithTestnets();
+  const tokens = useTokens(withTestnets);
+  const subscriptionKey = react.useMemo(
+  // not super sexy but we need key to change based on this stuff
+  () => {
+    const key = Object.values(tokens ?? {}).map(({
+      id
+    }) => id).sort().join();
+    return `tokenRates-${md5__default["default"](key)}`;
+  }, [tokens]);
+  const subscription = react.useCallback(() => {
+    if (!Object.values(tokens ?? {}).length) return () => {};
+    return subscribeTokenRates(tokens);
+  }, [tokens]);
+  useSharedSubscription(subscriptionKey, subscription);
 }
-function useSubscribeBalances() {
+
+/**
+ * This hook is responsible for fetching the data used for balances and inserting it into the db.
+ */
+function useDbCacheBalancesSubscription() {
+  const {
+    withTestnets
+  } = useWithTestnets();
   const balanceModules = useBalanceModules();
   const chaindataProvider = useChaindata();
   const chainConnectors = useChainConnectors();
   const [allAddresses] = useAllAddresses();
-  const tokens = dexieReactHooks.useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
-  const tokenIds = react.useMemo(() => Object.values(tokens ?? {}).map(({
+  const tokens = useTokens(withTestnets);
+  const subscriptionKey = react.useMemo(
+  // not super sexy but we need key to change based on this stuff
+  () => {
+    const key = allAddresses.sort().join().concat(...Object.values(tokens ?? {}).map(({
+      id
+    }) => id).sort()).concat(`evm:${!!chainConnectors.evm}`, `sub:${!!chainConnectors.substrate}`, ...balanceModules.map(m => m.type).sort(), `cd:${!!chaindataProvider}`);
+    return `balances-${md5__default["default"](key)}`;
+  }, [allAddresses, balanceModules, chainConnectors, chaindataProvider, tokens]);
+  const subscription = react.useCallback(() => {
+    if (!Object.values(tokens ?? {}).length || !allAddresses.length) return () => {};
+    return subscribeBalances(tokens ?? {}, allAddresses, chainConnectors, chaindataProvider, balanceModules);
+  }, [allAddresses, balanceModules, chainConnectors, chaindataProvider, tokens]);
+  useSharedSubscription(subscriptionKey, subscription);
+}
+const subscribeChainDataHydrate = (provider, type) => {
+  const chaindata = provider;
+  const delay = 300_000; // 300_000ms = 300s = 5 minutes
+
+  let timeout = null;
+  const hydrate = async () => {
+    try {
+      if (type === "chains") await chaindata.hydrateChains();
+      if (type === "evmNetworks") await chaindata.hydrateEvmNetworks();
+      if (type === "tokens") await chaindata.hydrateTokens();
+      timeout = setTimeout(hydrate, delay);
+    } catch (error) {
+      const retryTimeout = 5_000; // 5_000ms = 5 seconds
+      log.error(`Failed to fetch chaindata, retrying in ${Math.round(retryTimeout / 1000)} seconds`, error);
+      timeout = setTimeout(hydrate, retryTimeout);
+    }
+  };
+
+  // launch the loop
+  hydrate();
+  return () => {
+    if (timeout) clearTimeout(timeout);
+  };
+};
+const subscribeTokenRates = tokens => {
+  const REFRESH_INTERVAL = 300_000; // 6 minutes
+  const RETRY_INTERVAL = 5_000; // 5 sec
+
+  let timeout = null;
+  const refreshTokenRates = async () => {
+    try {
+      if (timeout) clearTimeout(timeout);
+      const tokenRates$1 = await tokenRates.fetchTokenRates(tokens);
+      const putTokenRates = Object.entries(tokenRates$1).map(([tokenId, rates]) => ({
+        tokenId,
+        rates
+      }));
+      tokenRates.db.transaction("rw", tokenRates.db.tokenRates, async () => await tokenRates.db.tokenRates.bulkPut(putTokenRates));
+      timeout = setTimeout(() => {
+        refreshTokenRates();
+      }, REFRESH_INTERVAL);
+    } catch (error) {
+      log.error(`Failed to fetch tokenRates, retrying in ${Math.round(RETRY_INTERVAL / 1000)} seconds`, error);
+      setTimeout(async () => {
+        refreshTokenRates();
+      }, RETRY_INTERVAL);
+    }
+  };
+
+  // launch the loop
+  refreshTokenRates();
+  return () => {
+    if (timeout) clearTimeout(timeout);
+  };
+};
+const subscribeBalances = (tokens, addresses, chainConnectors, provider, balanceModules) => {
+  const tokenIds = Object.values(tokens).map(({
     id
-  }) => id), [tokens]);
-  const addressesByToken = react.useMemo(() => Object.fromEntries(tokenIds.map(tokenId => [tokenId, allAddresses])), [allAddresses, tokenIds]);
-  const generationRef = react.useRef(0);
-  const createSubscription = react.useCallback(() => {
-    if (!chainConnectors.substrate) return;
-    if (!chainConnectors.evm) return;
-    if (!chaindataProvider) return;
-    const generation = (generationRef.current + 1) % Number.MAX_SAFE_INTEGER;
-    generationRef.current = generation;
-    const unsubs = balanceModules.map(balanceModule => {
-      // filter out tokens to only include those which this module knows how to fetch balances for
-      const moduleTokenIds = Object.values(tokens ?? {}).filter(({
-        type
-      }) => type === balanceModule.type).map(({
-        id
-      }) => id);
-      const addressesByModuleToken = Object.fromEntries(Object.entries(addressesByToken).filter(([tokenId]) => moduleTokenIds.includes(tokenId)));
-      const subscribe = createMulticastSubscription(next => {
-        const unsub = balances.balances(balanceModule, chainConnectors, chaindataProvider, addressesByModuleToken, (error, balances) => {
-          // log errors
-          if (error) return log.error(`Failed to fetch ${balanceModule.type} balances`, error);
-          // ignore empty balance responses
-          if (!balances) return;
-          // ignore balances from old subscriptions which are still in the process of unsubscribing
-          if (generationRef.current !== generation) return;
-          next(balances);
-        });
-        return () => {
-          // unsubscribe from upstream
-          unsub.then(unsubscribe => unsubscribe());
-
-          // set this subscription's balances in the store to status: cache
-          balances.db.transaction("rw", balances.db.balances, async () => await balances.db.balances.filter(balance => {
-            if (balance.source !== balanceModule.type) return false;
-            if (!Object.keys(addressesByModuleToken).includes(balance.tokenId)) return false;
-            if (!addressesByModuleToken[balance.tokenId].includes(balance.address)) return false;
-            return true;
-          }).modify({
-            status: "cache"
-          }));
-        };
-      });
-      const unsubscribe = subscribe(balances$1 => {
-        const putBalances = Object.entries(balances$1.toJSON()).map(([id, balance]) => ({
-          id,
-          ...balance
-        }));
-        balances.db.transaction("rw", balances.db.balances, async () => await balances.db.balances.bulkPut(putBalances));
-      });
-      return unsubscribe;
+  }) => id);
+  const addressesByToken = Object.fromEntries(tokenIds.map(tokenId => [tokenId, addresses]));
+  const updateDb = balances$1 => {
+    const putBalances = Object.entries(balances$1.toJSON()).map(([id, balance]) => ({
+      id,
+      ...balance
+    }));
+    balances.db.transaction("rw", balances.db.balances, async () => await balances.db.balances.bulkPut(putBalances));
+  };
+  let unsubscribed = false;
+
+  // eslint-disable-next-line no-console
+  log.log("subscribing to balance changes for %d tokens and %d addresses", tokenIds.length, addresses.length);
+  const unsubs = balanceModules.map(async balanceModule => {
+    // filter out tokens to only include those which this module knows how to fetch balances for
+    const moduleTokenIds = Object.values(tokens ?? {}).filter(({
+      type
+    }) => type === balanceModule.type).map(({
+      id
+    }) => id);
+    const addressesByModuleToken = Object.fromEntries(Object.entries(addressesByToken).filter(([tokenId]) => moduleTokenIds.includes(tokenId)));
+    const unsub = balances.balances(balanceModule, chainConnectors, provider, addressesByModuleToken, (error, balances) => {
+      // log errors
+      if (error) return log.error(`Failed to fetch ${balanceModule.type} balances`, error);
+      // ignore empty balance responses
+      if (!balances) return;
+      // ignore balances from old subscriptions which are still in the process of unsubscribing
+      if (unsubscribed) return;
+      updateDb(balances);
     });
-    const unsubscribeAll = () => unsubs.forEach(unsub => unsub());
-    return unsubscribeAll;
-  }, [addressesByToken, balanceModules, chainConnectors, chaindataProvider, tokens]);
-  const subscribe = useMulticastSubscription(createSubscription);
-  return subscribe;
-}
+    return () => {
+      // wait 2 seconds before actually unsubscribing, allowing for websocket to be reused
+      unsub.then(unsubscribe => {
+        setTimeout(unsubscribe, 2_000);
+      });
+      balances.db.transaction("rw", balances.db.balances, async () => await balances.db.balances.filter(balance => {
+        if (balance.source !== balanceModule.type) return false;
+        if (!Object.keys(addressesByModuleToken).includes(balance.tokenId)) return false;
+        if (!addressesByModuleToken[balance.tokenId].includes(balance.address)) return false;
+        return true;
+      }).modify({
+        status: "cache"
+      }));
+    };
+  });
+  const unsubscribeAll = () => {
+    unsubscribed = true;
+    unsubs.forEach(unsub => unsub.then(unsubscribe => unsubscribe()));
+  };
+  return unsubscribeAll;
+};
 
 function useChains(withTestnets) {
   // keep db data up to date
@@ -486,7 +578,7 @@ function useEvmNetwork(evmNetworkId, withTestnets) {
 
 function useTokenRates() {
   // keep db data up to date
-  useDbCacheSubscription("tokenRates");
+  useDbCacheTokenRatesSubscription();
   const {
     tokenRatesMap
   } = useDbCache();
@@ -497,21 +589,10 @@ function useTokenRate(tokenId) {
   return tokenId ? tokenRates[tokenId] : undefined;
 }
 
-function useTokens(withTestnets) {
-  // keep db data up to date
-  useDbCacheSubscription("tokens");
+const useBalancesHydrate = () => {
   const {
-    tokensWithTestnetsMap,
-    tokensWithoutTestnetsMap
-  } = useDbCache();
-  return withTestnets ? tokensWithTestnetsMap : tokensWithoutTestnetsMap;
-}
-function useToken(tokenId, withTestnets) {
-  const tokens = useTokens(withTestnets);
-  return tokenId ? tokens[tokenId] : undefined;
-}
-
-const useBalancesHydrate = withTestnets => {
+    withTestnets
+  } = useWithTestnets();
   const chains = useChains(withTestnets);
   const evmNetworks = useEvmNetworks(withTestnets);
   const tokens = useTokens(withTestnets);
@@ -526,7 +607,7 @@ const useBalancesHydrate = withTestnets => {
 
 function useBalances(addressesByToken) {
   // keep db data up to date
-  useDbCacheSubscription("balances");
+  useDbCacheBalancesSubscription();
   const balanceModules = useBalanceModules();
   const {
     balances: balances$1
@@ -557,18 +638,18 @@ function useBalances(addressesByToken) {
 const BalancesProvider = ({
   balanceModules,
   onfinalityApiKey,
-  useTestnets,
+  withTestnets,
   children
-}) => /*#__PURE__*/jsxRuntime.jsx(ChaindataProvider, {
-  onfinalityApiKey: onfinalityApiKey,
-  children: /*#__PURE__*/jsxRuntime.jsx(ChainConnectorsProvider, {
+}) => /*#__PURE__*/jsxRuntime.jsx(WithTestnetsProvider, {
+  withTestnets: withTestnets,
+  children: /*#__PURE__*/jsxRuntime.jsx(ChaindataProvider, {
     onfinalityApiKey: onfinalityApiKey,
-    children: /*#__PURE__*/jsxRuntime.jsx(AllAddressesProvider, {
-      children: /*#__PURE__*/jsxRuntime.jsx(BalanceModulesProvider, {
-        balanceModules: balanceModules,
-        children: /*#__PURE__*/jsxRuntime.jsx(DbCacheProvider, {
-          useTestnets: useTestnets,
-          children: /*#__PURE__*/jsxRuntime.jsx(SubscriptionsProvider, {
+    children: /*#__PURE__*/jsxRuntime.jsx(ChainConnectorsProvider, {
+      onfinalityApiKey: onfinalityApiKey,
+      children: /*#__PURE__*/jsxRuntime.jsx(AllAddressesProvider, {
+        children: /*#__PURE__*/jsxRuntime.jsx(BalanceModulesProvider, {
+          balanceModules: balanceModules,
+          children: /*#__PURE__*/jsxRuntime.jsx(DbCacheProvider, {
             children: children
           })
         })
@@ -583,7 +664,7 @@ exports.BalancesProvider = BalancesProvider;
 exports.ChainConnectorsProvider = ChainConnectorsProvider;
 exports.ChaindataProvider = ChaindataProvider;
 exports.DbCacheProvider = DbCacheProvider;
-exports.SubscriptionsProvider = SubscriptionsProvider;
+exports.WithTestnetsProvider = WithTestnetsProvider;
 exports.createMulticastSubscription = createMulticastSubscription;
 exports.provideContext = provideContext;
 exports.useAllAddresses = useAllAddresses;
@@ -595,12 +676,14 @@ exports.useChainConnectors = useChainConnectors;
 exports.useChaindata = useChaindata;
 exports.useChains = useChains;
 exports.useDbCache = useDbCache;
+exports.useDbCacheBalancesSubscription = useDbCacheBalancesSubscription;
 exports.useDbCacheSubscription = useDbCacheSubscription;
+exports.useDbCacheTokenRatesSubscription = useDbCacheTokenRatesSubscription;
 exports.useEvmNetwork = useEvmNetwork;
 exports.useEvmNetworks = useEvmNetworks;
 exports.useMulticastSubscription = useMulticastSubscription;
-exports.useSubscriptions = useSubscriptions;
 exports.useToken = useToken;
 exports.useTokenRate = useTokenRate;
 exports.useTokenRates = useTokenRates;
 exports.useTokens = useTokens;
+exports.useWithTestnets = useWithTestnets;