@talismn/balances-react 0.0.0-pr587-20230302015709 → 0.0.0-pr589-20230302073822

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

@@ -9,7 +9,6 @@ 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');
@@ -17,7 +16,6 @@ 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 => {
@@ -54,15 +52,13 @@ const useBalanceModulesProvider = ({
 const [BalanceModulesProvider, useBalanceModules] = provideContext(useBalanceModulesProvider);
 
 function useChaindataProvider(options = {}) {
-  const [onfinalityApiKey, setOnfinalityApiKey] = react.useState(options.onfinalityApiKey);
-
-  // make sure we recreate provider only when the onfinalityApiKey changes
+  const [chaindata, setChaindata] = react.useState();
   react.useEffect(() => {
-    if (options.onfinalityApiKey !== onfinalityApiKey) setOnfinalityApiKey(options.onfinalityApiKey);
-  }, [options.onfinalityApiKey, onfinalityApiKey]);
-  return react.useMemo(() => new chaindataProviderExtension.ChaindataProviderExtension({
-    onfinalityApiKey
-  }), [onfinalityApiKey]);
+    setChaindata(new chaindataProviderExtension.ChaindataProviderExtension({
+      onfinalityApiKey: options.onfinalityApiKey
+    }));
+  }, [options.onfinalityApiKey]);
+  return chaindata;
 }
 const [ChaindataProvider, useChaindata] = provideContext(useChaindataProvider);
 
@@ -138,7 +134,9 @@ const consolidateDbCache = (chainsMap, evmNetworksMap, tokensMap, tokenRates, al
     balances
   };
 };
-const useDbCacheProvider = () => {
+const useDbCacheProvider = ({
+  useTestnets = false
+}) => {
   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]);
@@ -150,7 +148,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]);
+  }, 500, [chainList, evmNetworkList, tokenList, rawBalances, tokenRates$1, useTestnets]);
   const refInitialized = react.useRef(false);
 
   // force an update as soon as all datasources are fetched, so UI can display data ASAP
@@ -159,14 +157,14 @@ const useDbCacheProvider = () => {
       setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates$1, rawBalances));
       refInitialized.current = true;
     }
-  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates$1]);
+  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates$1, useTestnets]);
   return dbData;
 };
 const [DbCacheProvider, useDbCache] = provideContext(useDbCacheProvider);
 
 var packageJson = {
 	name: "@talismn/balances-react",
-	version: "0.0.0-pr587-20230302015709",
+	version: "0.0.0-pr589-20230302073822",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "UNLICENSED",
@@ -199,7 +197,6 @@ 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",
@@ -230,95 +227,6 @@ 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.
  *
@@ -360,193 +268,193 @@ const createMulticastSubscription = upstream => {
   return subscribe;
 };
 
-const useWithTestnetsProvider = ({
-  withTestnets
-}) => {
-  return {
-    withTestnets
-  };
-};
-const [WithTestnetsProvider, useWithTestnets] = provideContext(useWithTestnetsProvider);
+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);
 
 /**
  * This hook is responsible for fetching the data used for balances and inserting it into the db.
  */
 const useDbCacheSubscription = subscribeTo => {
-  const provider = useChaindata();
-
-  // can't handle balances & tokenRates here as they have other dependencies, it would trigger to many subscriptions
-  const subscribe = react.useCallback(() => {
+  const [subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances] = useSubscriptions();
+  react.useEffect(() => {
     switch (subscribeTo) {
       case "chains":
-        return subscribeChainDataHydrate(provider, "chains");
+        return subscribeHydrateChains();
       case "evmNetworks":
-        return subscribeChainDataHydrate(provider, "evmNetworks");
+        return subscribeHydrateEvmNetworks();
       case "tokens":
-        return subscribeChainDataHydrate(provider, "tokens");
+        return subscribeHydrateTokens();
+      case "tokenRates":
+        return subscribeTokenRates();
+      case "balances":
+        return subscribeBalances();
     }
-  }, [provider, subscribeTo]);
-  useSharedSubscription(subscribeTo, subscribe);
+  }, [subscribeTo, subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances]);
 };
-
-/**
- * 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 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;
 }
-
-/**
- * This hook is responsible for fetching the data used for balances and inserting it into the db.
- */
-function useDbCacheBalancesSubscription() {
-  const {
-    withTestnets
-  } = useWithTestnets();
+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;
+}
+function useSubscribeBalances() {
   const balanceModules = useBalanceModules();
   const chaindataProvider = useChaindata();
   const chainConnectors = useChainConnectors();
   const [allAddresses] = useAllAddresses();
-  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(({
+  const tokens = dexieReactHooks.useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
+  const tokenIds = react.useMemo(() => Object.values(tokens ?? {}).map(({
     id
-  }) => 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);
-    });
-    return () => {
-      // wait 2 seconds before actually unsubscribing, allowing for websocket to be reused
-      unsub.then(unsubscribe => {
-        setTimeout(unsubscribe, 2_000);
+  }) => 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"
+          }));
+        };
       });
-      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;
-};
+      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;
+    });
+    const unsubscribeAll = () => unsubs.forEach(unsub => unsub());
+    return unsubscribeAll;
+  }, [addressesByToken, balanceModules, chainConnectors, chaindataProvider, tokens]);
+  const subscribe = useMulticastSubscription(createSubscription);
+  return subscribe;
+}
 
 function useChains(withTestnets) {
   // keep db data up to date
@@ -578,7 +486,7 @@ function useEvmNetwork(evmNetworkId, withTestnets) {
 
 function useTokenRates() {
   // keep db data up to date
-  useDbCacheTokenRatesSubscription();
+  useDbCacheSubscription("tokenRates");
   const {
     tokenRatesMap
   } = useDbCache();
@@ -589,10 +497,21 @@ function useTokenRate(tokenId) {
   return tokenId ? tokenRates[tokenId] : undefined;
 }
 
-const useBalancesHydrate = () => {
+function useTokens(withTestnets) {
+  // keep db data up to date
+  useDbCacheSubscription("tokens");
   const {
-    withTestnets
-  } = useWithTestnets();
+    tokensWithTestnetsMap,
+    tokensWithoutTestnetsMap
+  } = useDbCache();
+  return withTestnets ? tokensWithTestnetsMap : tokensWithoutTestnetsMap;
+}
+function useToken(tokenId, withTestnets) {
+  const tokens = useTokens(withTestnets);
+  return tokenId ? tokens[tokenId] : undefined;
+}
+
+const useBalancesHydrate = withTestnets => {
   const chains = useChains(withTestnets);
   const evmNetworks = useEvmNetworks(withTestnets);
   const tokens = useTokens(withTestnets);
@@ -607,7 +526,7 @@ const useBalancesHydrate = () => {
 
 function useBalances(addressesByToken) {
   // keep db data up to date
-  useDbCacheBalancesSubscription();
+  useDbCacheSubscription("balances");
   const balanceModules = useBalanceModules();
   const {
     balances: balances$1
@@ -638,18 +557,18 @@ function useBalances(addressesByToken) {
 const BalancesProvider = ({
   balanceModules,
   onfinalityApiKey,
-  withTestnets,
+  useTestnets,
   children
-}) => /*#__PURE__*/jsxRuntime.jsx(WithTestnetsProvider, {
-  withTestnets: withTestnets,
-  children: /*#__PURE__*/jsxRuntime.jsx(ChaindataProvider, {
+}) => /*#__PURE__*/jsxRuntime.jsx(ChaindataProvider, {
+  onfinalityApiKey: onfinalityApiKey,
+  children: /*#__PURE__*/jsxRuntime.jsx(ChainConnectorsProvider, {
     onfinalityApiKey: onfinalityApiKey,
-    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: /*#__PURE__*/jsxRuntime.jsx(AllAddressesProvider, {
+      children: /*#__PURE__*/jsxRuntime.jsx(BalanceModulesProvider, {
+        balanceModules: balanceModules,
+        children: /*#__PURE__*/jsxRuntime.jsx(DbCacheProvider, {
+          useTestnets: useTestnets,
+          children: /*#__PURE__*/jsxRuntime.jsx(SubscriptionsProvider, {
             children: children
           })
         })
@@ -664,7 +583,7 @@ exports.BalancesProvider = BalancesProvider;
 exports.ChainConnectorsProvider = ChainConnectorsProvider;
 exports.ChaindataProvider = ChaindataProvider;
 exports.DbCacheProvider = DbCacheProvider;
-exports.WithTestnetsProvider = WithTestnetsProvider;
+exports.SubscriptionsProvider = SubscriptionsProvider;
 exports.createMulticastSubscription = createMulticastSubscription;
 exports.provideContext = provideContext;
 exports.useAllAddresses = useAllAddresses;
@@ -676,14 +595,12 @@ 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;