@talismn/balances-react 0.0.0-pr584-20230301012058 → 0.0.0-pr587-20230301175306

package/dist/talismn-balances-react.esm.js

@@ -1,12 +1,13 @@
-import { useContext, createContext, useState, useEffect, useRef, useMemo, useCallback } from 'react';
+import { useContext, createContext, useState, useEffect, useMemo, useRef, useCallback } from 'react';
 import { jsx } from 'react/jsx-runtime';
 import { db as db$1, balances, Balances } from '@talismn/balances';
 import { db, fetchTokenRates } from '@talismn/token-rates';
 import { useLiveQuery } from 'dexie-react-hooks';
 import { useDebounce } from 'react-use';
 import { ChaindataProviderExtension } from '@talismn/chaindata-provider-extension';
+import md5 from 'blueimp-md5';
 import anylogger from 'anylogger';
-import { Observable, defer, shareReplay } from 'rxjs';
+import { Subject, Observable, defer, shareReplay } from 'rxjs';
 import { ChainConnector } from '@talismn/chain-connector';
 import { ChainConnectorEvm } from '@talismn/chain-connector-evm';
 
@@ -44,13 +45,15 @@ const useBalanceModulesProvider = ({
 const [BalanceModulesProvider, useBalanceModules] = provideContext(useBalanceModulesProvider);
 
 function useChaindataProvider(options = {}) {
-  const [chaindata, setChaindata] = useState();
+  const [onfinalityApiKey, setOnfinalityApiKey] = useState(options.onfinalityApiKey);
+
+  // make sure we recreate provider only when the onfinalityApiKey changes
   useEffect(() => {
-    setChaindata(new ChaindataProviderExtension({
-      onfinalityApiKey: options.onfinalityApiKey
-    }));
-  }, [options.onfinalityApiKey]);
-  return chaindata;
+    if (options.onfinalityApiKey !== onfinalityApiKey) setOnfinalityApiKey(options.onfinalityApiKey);
+  }, [options.onfinalityApiKey, onfinalityApiKey]);
+  return useMemo(() => new ChaindataProviderExtension({
+    onfinalityApiKey
+  }), [onfinalityApiKey]);
 }
 const [ChaindataProvider, useChaindata] = provideContext(useChaindataProvider);
 
@@ -126,9 +129,7 @@ const consolidateDbCache = (chainsMap, evmNetworksMap, tokensMap, tokenRates, al
     balances
   };
 };
-const useDbCacheProvider = ({
-  useTestnets = false
-}) => {
+const useDbCacheProvider = () => {
   const chaindataProvider = useChaindata();
   const chainList = useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.chains(), [chaindataProvider]);
   const evmNetworkList = useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.evmNetworks(), [chaindataProvider]);
@@ -140,7 +141,7 @@ const useDbCacheProvider = ({
   // debounce every 500ms to prevent hammering UI with updates
   useDebounce(() => {
     setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates, rawBalances));
-  }, 500, [chainList, evmNetworkList, tokenList, rawBalances, tokenRates, useTestnets]);
+  }, 500, [chainList, evmNetworkList, tokenList, rawBalances, tokenRates]);
   const refInitialized = useRef(false);
 
   // force an update as soon as all datasources are fetched, so UI can display data ASAP
@@ -149,14 +150,14 @@ const useDbCacheProvider = ({
       setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates, rawBalances));
       refInitialized.current = true;
     }
-  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates, useTestnets]);
+  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates]);
   return dbData;
 };
 const [DbCacheProvider, useDbCache] = provideContext(useDbCacheProvider);
 
 var packageJson = {
 	name: "@talismn/balances-react",
-	version: "0.0.0-pr584-20230301012058",
+	version: "0.0.0-pr587-20230301175306",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "UNLICENSED",
@@ -189,6 +190,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",
@@ -219,6 +221,95 @@ var packageJson = {
 
 var log = anylogger(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 Subject()
+  };
+  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
+  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] = useState(options.onfinalityApiKey);
+
+  // make sure we recreate provider only when the onfinalityApiKey changes
+  useEffect(() => {
+    if (options.onfinalityApiKey !== onfinalityApiKey) setOnfinalityApiKey(options.onfinalityApiKey);
+  }, [options.onfinalityApiKey, onfinalityApiKey]);
+
+  // chaindata dependency
+  const chaindata = useChaindata();
+
+  // substrate connector
+  const substrate = useMemo(() => new ChainConnector(chaindata), [chaindata]);
+
+  // evm connector
+  const evm = useMemo(() => new ChainConnectorEvm(chaindata, {
+    onfinalityApiKey
+  }), [chaindata, onfinalityApiKey]);
+  return 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.
  *
@@ -260,193 +351,191 @@ const createMulticastSubscription = upstream => {
   return subscribe;
 };
 
-function useChainConnectorsProvider(options) {
-  // chaindata dependency
-  const chaindata = useChaindata();
-
-  // substrate connector
-  const [substrate, setSubstrate] = useState();
-  useEffect(() => {
-    if (!chaindata) return;
-    setSubstrate(new ChainConnector(chaindata));
-  }, [chaindata]);
-
-  // evm connector
-  const [evm, setEvm] = useState();
-  useEffect(() => {
-    if (!chaindata) return;
-    setEvm(new ChainConnectorEvm(chaindata, {
-      onfinalityApiKey: options.onfinalityApiKey
-    }));
-  }, [chaindata, options.onfinalityApiKey]);
-  return 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();
-  useEffect(() => {
+  const provider = useChaindata();
+
+  // can't handle balances & tokenRates here as they have other dependencies, it would trigger to many subscriptions
+  const subscribe = 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 = 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 = useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
-  const generationRef = useRef(0);
-  const createSubscription = 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 = await fetchTokenRates(tokens);
-        if (!active) return;
-        if (generationRef.current !== generation) return;
-        const putTokenRates = Object.entries(tokenRates).map(([tokenId, rates]) => ({
-          tokenId,
-          rates
-        }));
-        db.transaction("rw", db.tokenRates, async () => await 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 = 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(key)}`;
+  }, [tokens]);
+  const subscription = 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 = useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
-  const tokenIds = useMemo(() => Object.values(tokens ?? {}).map(({
+  const tokens = useTokens(withTestnets);
+  const subscriptionKey = 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(key)}`;
+  }, [allAddresses, balanceModules, chainConnectors, chaindataProvider, tokens]);
+  const subscription = 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 = await fetchTokenRates(tokens);
+      const putTokenRates = Object.entries(tokenRates).map(([tokenId, rates]) => ({
+        tokenId,
+        rates
+      }));
+      db.transaction("rw", db.tokenRates, async () => await 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 = useMemo(() => Object.fromEntries(tokenIds.map(tokenId => [tokenId, allAddresses])), [allAddresses, tokenIds]);
-  const generationRef = useRef(0);
-  const createSubscription = 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(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
-          db$1.transaction("rw", db$1.balances, async () => await db$1.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 => {
-        const putBalances = Object.entries(balances.toJSON()).map(([id, balance]) => ({
-          id,
-          ...balance
-        }));
-        db$1.transaction("rw", db$1.balances, async () => await db$1.balances.bulkPut(putBalances));
-      });
-      return unsubscribe;
+  }) => id);
+  const addressesByToken = Object.fromEntries(tokenIds.map(tokenId => [tokenId, addresses]));
+  const updateDb = balances => {
+    const putBalances = Object.entries(balances.toJSON()).map(([id, balance]) => ({
+      id,
+      ...balance
+    }));
+    db$1.transaction("rw", db$1.balances, async () => await db$1.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(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 () => {
+      // TODO should we add a timeout before unsubscribe to prevent closing sockets to quickly ?
+      unsub.then(unsubscribe => unsubscribe());
+      db$1.transaction("rw", db$1.balances, async () => await db$1.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
@@ -478,7 +567,7 @@ function useEvmNetwork(evmNetworkId, withTestnets) {
 
 function useTokenRates() {
   // keep db data up to date
-  useDbCacheSubscription("tokenRates");
+  useDbCacheTokenRatesSubscription();
   const {
     tokenRatesMap
   } = useDbCache();
@@ -489,21 +578,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);
@@ -518,7 +596,7 @@ const useBalancesHydrate = withTestnets => {
 
 function useBalances(addressesByToken) {
   // keep db data up to date
-  useDbCacheSubscription("balances");
+  useDbCacheBalancesSubscription();
   const balanceModules = useBalanceModules();
   const {
     balances
@@ -549,18 +627,18 @@ function useBalances(addressesByToken) {
 const BalancesProvider = ({
   balanceModules,
   onfinalityApiKey,
-  useTestnets,
+  withTestnets,
   children
-}) => /*#__PURE__*/jsx(ChaindataProvider, {
-  onfinalityApiKey: onfinalityApiKey,
-  children: /*#__PURE__*/jsx(ChainConnectorsProvider, {
+}) => /*#__PURE__*/jsx(WithTestnetsProvider, {
+  withTestnets: withTestnets,
+  children: /*#__PURE__*/jsx(ChaindataProvider, {
     onfinalityApiKey: onfinalityApiKey,
-    children: /*#__PURE__*/jsx(AllAddressesProvider, {
-      children: /*#__PURE__*/jsx(BalanceModulesProvider, {
-        balanceModules: balanceModules,
-        children: /*#__PURE__*/jsx(DbCacheProvider, {
-          useTestnets: useTestnets,
-          children: /*#__PURE__*/jsx(SubscriptionsProvider, {
+    children: /*#__PURE__*/jsx(ChainConnectorsProvider, {
+      onfinalityApiKey: onfinalityApiKey,
+      children: /*#__PURE__*/jsx(AllAddressesProvider, {
+        children: /*#__PURE__*/jsx(BalanceModulesProvider, {
+          balanceModules: balanceModules,
+          children: /*#__PURE__*/jsx(DbCacheProvider, {
             children: children
           })
         })
@@ -569,4 +647,4 @@ const BalancesProvider = ({
   })
 });
 
-export { AllAddressesProvider, BalanceModulesProvider, BalancesProvider, ChainConnectorsProvider, ChaindataProvider, DbCacheProvider, SubscriptionsProvider, createMulticastSubscription, provideContext, useAllAddresses, useBalanceModules, useBalances, useBalancesHydrate, useChain, useChainConnectors, useChaindata, useChains, useDbCache, useDbCacheSubscription, useEvmNetwork, useEvmNetworks, useMulticastSubscription, useSubscriptions, useToken, useTokenRate, useTokenRates, useTokens };
+export { AllAddressesProvider, BalanceModulesProvider, BalancesProvider, ChainConnectorsProvider, ChaindataProvider, DbCacheProvider, WithTestnetsProvider, createMulticastSubscription, provideContext, useAllAddresses, useBalanceModules, useBalances, useBalancesHydrate, useChain, useChainConnectors, useChaindata, useChains, useDbCache, useDbCacheBalancesSubscription, useDbCacheSubscription, useDbCacheTokenRatesSubscription, useEvmNetwork, useEvmNetworks, useMulticastSubscription, useToken, useTokenRate, useTokenRates, useTokens, useWithTestnets };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances-react",
-  "version": "0.0.0-pr584-20230301012058",
+  "version": "0.0.0-pr587-20230301175306",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "UNLICENSED",
@@ -26,13 +26,14 @@
     "clean": "rm -rf dist && rm -rf .turbo rm -rf node_modules"
   },
   "dependencies": {
-    "@talismn/balances": "^0.0.0-pr584-20230301012058",
+    "@talismn/balances": "^0.0.0-pr587-20230301175306",
     "@talismn/chain-connector": "^0.4.2",
     "@talismn/chain-connector-evm": "^0.4.2",
     "@talismn/chaindata-provider": "^0.4.2",
     "@talismn/chaindata-provider-extension": "^0.4.2",
-    "@talismn/token-rates": "^0.0.0-pr584-20230301012058",
+    "@talismn/token-rates": "^0.0.0-pr587-20230301175306",
     "anylogger": "^1.0.11",
+    "blueimp-md5": "2.19.0",
     "dexie": "^3.2.3",
     "dexie-react-hooks": "^1.1.1",
     "react-use": "^17.4.0",