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

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

@@ -1,13 +1,12 @@
-import { useContext, createContext, useState, useEffect, useMemo, useRef, useCallback } from 'react';
+import { useContext, createContext, useState, useEffect, useRef, useMemo, 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 { Subject, Observable, defer, shareReplay } from 'rxjs';
+import { Observable, defer, shareReplay } from 'rxjs';
 import { ChainConnector } from '@talismn/chain-connector';
 import { ChainConnectorEvm } from '@talismn/chain-connector-evm';
 
@@ -45,15 +44,13 @@ const useBalanceModulesProvider = ({
 const [BalanceModulesProvider, useBalanceModules] = provideContext(useBalanceModulesProvider);
 
 function useChaindataProvider(options = {}) {
-  const [onfinalityApiKey, setOnfinalityApiKey] = useState(options.onfinalityApiKey);
-
-  // make sure we recreate provider only when the onfinalityApiKey changes
+  const [chaindata, setChaindata] = useState();
   useEffect(() => {
-    if (options.onfinalityApiKey !== onfinalityApiKey) setOnfinalityApiKey(options.onfinalityApiKey);
-  }, [options.onfinalityApiKey, onfinalityApiKey]);
-  return useMemo(() => new ChaindataProviderExtension({
-    onfinalityApiKey
-  }), [onfinalityApiKey]);
+    setChaindata(new ChaindataProviderExtension({
+      onfinalityApiKey: options.onfinalityApiKey
+    }));
+  }, [options.onfinalityApiKey]);
+  return chaindata;
 }
 const [ChaindataProvider, useChaindata] = provideContext(useChaindataProvider);
 
@@ -129,7 +126,9 @@ const consolidateDbCache = (chainsMap, evmNetworksMap, tokensMap, tokenRates, al
     balances
   };
 };
-const useDbCacheProvider = () => {
+const useDbCacheProvider = ({
+  useTestnets = false
+}) => {
   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]);
@@ -141,7 +140,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]);
+  }, 500, [chainList, evmNetworkList, tokenList, rawBalances, tokenRates, useTestnets]);
   const refInitialized = useRef(false);
 
   // force an update as soon as all datasources are fetched, so UI can display data ASAP
@@ -150,14 +149,14 @@ const useDbCacheProvider = () => {
       setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates, rawBalances));
       refInitialized.current = true;
     }
-  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates]);
+  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates, useTestnets]);
   return dbData;
 };
 const [DbCacheProvider, useDbCache] = provideContext(useDbCacheProvider);
 
 var packageJson = {
 	name: "@talismn/balances-react",
-	version: "0.0.0-pr587-20230301175306",
+	version: "0.0.0-pr589-20230302073822",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "UNLICENSED",
@@ -190,7 +189,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",
@@ -221,95 +219,6 @@ 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.
  *
@@ -351,191 +260,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] = 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);
 
 /**
  * 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 = useCallback(() => {
+  const [subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances] = useSubscriptions();
+  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 = 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 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;
 }
-
-/**
- * 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 = 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;
+}
+function useSubscribeBalances() {
   const balanceModules = useBalanceModules();
   const chaindataProvider = useChaindata();
   const chainConnectors = useChainConnectors();
   const [allAddresses] = useAllAddresses();
-  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(({
+  const tokens = useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
+  const tokenIds = useMemo(() => Object.values(tokens ?? {}).map(({
     id
-  }) => 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);
+  }) => 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;
     });
-    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;
-};
+    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
@@ -567,7 +478,7 @@ function useEvmNetwork(evmNetworkId, withTestnets) {
 
 function useTokenRates() {
   // keep db data up to date
-  useDbCacheTokenRatesSubscription();
+  useDbCacheSubscription("tokenRates");
   const {
     tokenRatesMap
   } = useDbCache();
@@ -578,10 +489,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);
@@ -596,7 +518,7 @@ const useBalancesHydrate = () => {
 
 function useBalances(addressesByToken) {
   // keep db data up to date
-  useDbCacheBalancesSubscription();
+  useDbCacheSubscription("balances");
   const balanceModules = useBalanceModules();
   const {
     balances
@@ -627,18 +549,18 @@ function useBalances(addressesByToken) {
 const BalancesProvider = ({
   balanceModules,
   onfinalityApiKey,
-  withTestnets,
+  useTestnets,
   children
-}) => /*#__PURE__*/jsx(WithTestnetsProvider, {
-  withTestnets: withTestnets,
-  children: /*#__PURE__*/jsx(ChaindataProvider, {
+}) => /*#__PURE__*/jsx(ChaindataProvider, {
+  onfinalityApiKey: onfinalityApiKey,
+  children: /*#__PURE__*/jsx(ChainConnectorsProvider, {
     onfinalityApiKey: onfinalityApiKey,
-    children: /*#__PURE__*/jsx(ChainConnectorsProvider, {
-      onfinalityApiKey: onfinalityApiKey,
-      children: /*#__PURE__*/jsx(AllAddressesProvider, {
-        children: /*#__PURE__*/jsx(BalanceModulesProvider, {
-          balanceModules: balanceModules,
-          children: /*#__PURE__*/jsx(DbCacheProvider, {
+    children: /*#__PURE__*/jsx(AllAddressesProvider, {
+      children: /*#__PURE__*/jsx(BalanceModulesProvider, {
+        balanceModules: balanceModules,
+        children: /*#__PURE__*/jsx(DbCacheProvider, {
+          useTestnets: useTestnets,
+          children: /*#__PURE__*/jsx(SubscriptionsProvider, {
             children: children
           })
         })
@@ -647,4 +569,4 @@ const BalancesProvider = ({
   })
 });
 
-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 };
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances-react",
-  "version": "0.0.0-pr587-20230301175306",
+  "version": "0.0.0-pr589-20230302073822",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "UNLICENSED",
@@ -26,14 +26,13 @@
     "clean": "rm -rf dist && rm -rf .turbo rm -rf node_modules"
   },
   "dependencies": {
-    "@talismn/balances": "^0.0.0-pr587-20230301175306",
+    "@talismn/balances": "^0.0.0-pr589-20230302073822",
     "@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-pr587-20230301175306",
+    "@talismn/token-rates": "^0.0.0-pr589-20230302073822",
     "anylogger": "^1.0.11",
-    "blueimp-md5": "2.19.0",
     "dexie": "^3.2.3",
     "dexie-react-hooks": "^1.1.1",
     "react-use": "^17.4.0",

package/dist/declarations/src/hooks/useWithTestnets.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="react" />
-export declare const WithTestnetsProvider: import("react").FC<{
-    withTestnets?: boolean | undefined;
-} & {
-    children?: import("react").ReactNode;
-}>, useWithTestnets: () => {
-    withTestnets: boolean | undefined;
-};

package/dist/declarations/src/util/useSharedSubscription.d.ts

@@ -1,9 +0,0 @@
-type UnsubscribeFn = () => void;
-type InitSubscriptionCallback = () => UnsubscribeFn;
-/**
- * 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
- */
-export declare const useSharedSubscription: (key: string, subscribe: InitSubscriptionCallback) => void;
-export {};