@talismn/balances-react 0.0.0-pr447-20230214040957 → 0.0.0-pr447-20230222115452

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

@@ -2,23 +2,169 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
 var balances = require('@talismn/balances');
-var chainConnector = require('@talismn/chain-connector');
-var chainConnectorEvm = require('@talismn/chain-connector-evm');
+var tokenRates = require('@talismn/token-rates');
 var dexieReactHooks = require('dexie-react-hooks');
-var react = require('react');
 var reactUse = require('react-use');
-var anylogger = require('anylogger');
 var chaindataProviderExtension = require('@talismn/chaindata-provider-extension');
-var tokenRates = require('@talismn/token-rates');
+var anylogger = require('anylogger');
+var rxjs = require('rxjs');
+var chainConnector = require('@talismn/chain-connector');
+var chainConnectorEvm = require('@talismn/chain-connector-evm');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
 var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
 
+const provideContext = useProviderContext => {
+  // automatic typing based on our hook's return type
+
+  const Context = /*#__PURE__*/react.createContext({
+    __provideContextInteralDefaultValue: true
+  });
+  const Provider = ({
+    children,
+    ...props
+  }) => {
+    const ctx = useProviderContext(props);
+    return /*#__PURE__*/jsxRuntime.jsx(Context.Provider, {
+      value: ctx,
+      children: children
+    });
+  };
+  const useProvidedContext = () => {
+    const context = react.useContext(Context);
+    if (typeof context === "object" && context && "__provideContextInteralDefaultValue" in context) throw new Error("This hook requires a provider to be present above it in the tree");
+    return context;
+  };
+  const result = [Provider, useProvidedContext];
+  return result;
+};
+
+const useAllAddressesProvider = () => react.useState([]);
+const [AllAddressesProvider, useAllAddresses] = provideContext(useAllAddressesProvider);
+
+const useBalanceModulesProvider = ({
+  balanceModules
+}) => balanceModules;
+const [BalanceModulesProvider, useBalanceModules] = provideContext(useBalanceModulesProvider);
+
+function useChaindataProvider(options = {}) {
+  const [chaindata, setChaindata] = react.useState();
+  react.useEffect(() => {
+    setChaindata(new chaindataProviderExtension.ChaindataProviderExtension({
+      onfinalityApiKey: options.onfinalityApiKey
+    }));
+  }, [options.onfinalityApiKey]);
+  return chaindata;
+}
+const [ChaindataProvider, useChaindata] = provideContext(useChaindataProvider);
+
+const filterNoTestnet = ({
+  isTestnet
+}) => isTestnet === false;
+const DEFAULT_VALUE = {
+  chainsWithTestnets: [],
+  chainsWithoutTestnets: [],
+  evmNetworksWithTestnets: [],
+  evmNetworksWithoutTestnets: [],
+  tokensWithTestnets: [],
+  tokensWithoutTestnets: [],
+  chainsWithTestnetsMap: {},
+  chainsWithoutTestnetsMap: {},
+  evmNetworksWithTestnetsMap: {},
+  evmNetworksWithoutTestnetsMap: {},
+  tokensWithTestnetsMap: {},
+  tokensWithoutTestnetsMap: {},
+  tokenRatesMap: {},
+  balances: []
+};
+const consolidateDbCache = (chainsMap, evmNetworksMap, tokensMap, tokenRates, allBalances) => {
+  if (!chainsMap || !evmNetworksMap || !tokensMap || !tokenRates || !allBalances) return DEFAULT_VALUE;
+
+  // BEGIN: temp hack to indicate that
+  //          - EVM GLMR is a mirror of substrate GLMR
+  //          - EVM MOVR is a mirror of substrate MOVR
+  //          - EVM DEV is a mirror of substrate DEV
+  //          - EVM ACA is a mirror of substrate ACA
+  const mirrorTokenIds = {
+    "1284-evm-native-glmr": "moonbeam-substrate-native-glmr",
+    "1285-evm-native-movr": "moonriver-substrate-native-movr",
+    "1287-evm-native-dev": "moonbase-alpha-testnet-substrate-native-dev",
+    "787-evm-native-aca": "acala-substrate-native-aca"
+  };
+  Object.entries(mirrorTokenIds).filter(([mirrorToken]) => tokensMap[mirrorToken]).forEach(([mirrorToken, mirrorOf]) => tokensMap[mirrorToken].mirrorOf = mirrorOf);
+  // END: temp hack
+
+  const chainsWithTestnets = Object.values(chainsMap);
+  const chainsWithoutTestnets = chainsWithTestnets.filter(filterNoTestnet);
+  const chainsWithoutTestnetsMap = Object.fromEntries(chainsWithoutTestnets.map(network => [network.id, network]));
+  const evmNetworksWithTestnets = Object.values(evmNetworksMap);
+  const evmNetworksWithoutTestnets = evmNetworksWithTestnets.filter(filterNoTestnet);
+  const evmNetworksWithoutTestnetsMap = Object.fromEntries(evmNetworksWithoutTestnets.map(network => [network.id, network]));
+
+  // ensure that we have corresponding network for each token
+  const tokensWithTestnets = Object.values(tokensMap).filter(token => token.chain && chainsMap[token.chain.id] || token.evmNetwork && evmNetworksMap[token.evmNetwork.id]);
+  const tokensWithoutTestnets = tokensWithTestnets.filter(filterNoTestnet).filter(token => token.chain && chainsWithoutTestnetsMap[token.chain.id] || token.evmNetwork && evmNetworksWithoutTestnetsMap[token.evmNetwork.id]);
+  const tokensWithTestnetsMap = Object.fromEntries(tokensWithTestnets.map(token => [token.id, token]));
+  const tokensWithoutTestnetsMap = Object.fromEntries(tokensWithoutTestnets.map(token => [token.id, token]));
+  const tokenRatesMap = Object.fromEntries(tokenRates.map(({
+    tokenId,
+    rates
+  }) => [tokenId, rates]));
+
+  // return only balances for which we have a token
+  const balances = allBalances.filter(b => tokensWithTestnetsMap[b.tokenId]);
+  return {
+    chainsWithTestnets,
+    chainsWithoutTestnets,
+    evmNetworksWithTestnets,
+    evmNetworksWithoutTestnets,
+    tokensWithTestnets,
+    tokensWithoutTestnets,
+    chainsWithTestnetsMap: chainsMap,
+    chainsWithoutTestnetsMap,
+    evmNetworksWithTestnetsMap: evmNetworksMap,
+    evmNetworksWithoutTestnetsMap,
+    tokensWithTestnetsMap,
+    tokensWithoutTestnetsMap,
+    tokenRatesMap,
+    balances
+  };
+};
+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]);
+  const tokenList = dexieReactHooks.useLiveQuery(() => chaindataProvider === null || chaindataProvider === void 0 ? void 0 : chaindataProvider.tokens(), [chaindataProvider]);
+  const tokenRates$1 = dexieReactHooks.useLiveQuery(() => tokenRates.db.tokenRates.toArray(), []);
+  const rawBalances = dexieReactHooks.useLiveQuery(() => balances.db.balances.toArray(), []);
+  const [dbData, setDbData] = react.useState(DEFAULT_VALUE);
+
+  // 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]);
+  const refInitialized = react.useRef(false);
+
+  // force an update as soon as all datasources are fetched, so UI can display data ASAP
+  react.useEffect(() => {
+    if (!refInitialized.current && chainList && evmNetworkList && tokenList && tokenRates$1 && rawBalances) {
+      setDbData(consolidateDbCache(chainList, evmNetworkList, tokenList, tokenRates$1, rawBalances));
+      refInitialized.current = true;
+    }
+  }, [chainList, evmNetworkList, rawBalances, tokenList, tokenRates$1, useTestnets]);
+  return dbData;
+};
+const [DbCacheProvider, useDbCache] = provideContext(useDbCacheProvider);
+
 var packageJson = {
 	name: "@talismn/balances-react",
-	version: "0.0.0-pr447-20230214040957",
+	version: "0.0.0-pr447-20230222115452",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "UNLICENSED",
@@ -51,9 +197,10 @@ var packageJson = {
 		"@talismn/chaindata-provider-extension": "workspace:^",
 		"@talismn/token-rates": "workspace:^",
 		anylogger: "^1.0.11",
-		dexie: "^3.2.2",
+		dexie: "^3.2.3",
 		"dexie-react-hooks": "^1.1.1",
-		"react-use": "^17.4.0"
+		"react-use": "^17.4.0",
+		rxjs: "^7.8.0"
 	},
 	devDependencies: {
 		"@talismn/eslint-config": "workspace:^",
@@ -80,138 +227,312 @@ var packageJson = {
 
 var log = anylogger__default["default"](packageJson.name);
 
-// TODO: Allow user to call useChaindata from multiple places
+/**
+ * Creates a subscription function that can be used to subscribe to a multicast observable created from an upstream source.
+ *
+ * An example of when this is useful is when we want to subscribe to some data from multiple components, but we only want
+ * to actively keep that data hydrated when at least one component is subscribed to it.
+ *
+ * When the first component subscribes, the `upstream` function will be called. It should then set up a subscription and return a teardown function.
+ * When subsequent components subscribe, they will be added to the existing subscription.
+ * When the last component unsubscribes, the teardown function returned from the `upstream` function will be called.
+ *
+ * @param upstream A function that takes a "next" callback function as an argument, and returns either an unsubscribe function or void.
+ * @returns A subscription function that can be used to subscribe to the multicast observable.
+ */
+const useMulticastSubscription = upstream => {
+  const subscribe = react.useMemo(() => createMulticastSubscription(upstream), [upstream]);
+  return subscribe;
+};
+const createMulticastSubscription = upstream => {
+  // Create an upstream observable using the provided function.
+  const upstreamObservable = new rxjs.Observable(subscriber => {
+    const unsubscribe = upstream(val => subscriber.next(val));
+    return () => {
+      typeof unsubscribe === "function" && unsubscribe();
+    };
+  });
+
+  // Create a multicast observable from the upstream observable, using the shareReplay operator.
+  const multicastObservable = rxjs.defer(() => upstreamObservable).pipe(rxjs.shareReplay({
+    bufferSize: 1,
+    refCount: true
+  }));
+
+  // Create a subscription function that subscribes to the multicast observable and returns an unsubscribe function.
+  const subscribe = callback => {
+    const subscription = multicastObservable.subscribe(callback);
+    const unsubscribe = () => subscription.unsubscribe();
+    return unsubscribe;
+  };
+  return subscribe;
+};
+
+function useChainConnectorsProvider(options) {
+  // chaindata dependency
+  const chaindata = useChaindata();
 
-function useChaindata() {
-  const [chaindataProvider, setChaindataProvider] = react.useState(null);
+  // substrate connector
+  const [substrate, setSubstrate] = react.useState();
+  react.useEffect(() => {
+    if (!chaindata) return;
+    setSubstrate(new chainConnector.ChainConnector(chaindata));
+  }, [chaindata]);
 
-  // this number is incremented each time the chaindataProvider has fetched new data
-  const [generation, setGeneration] = react.useState(0);
+  // evm connector
+  const [evm, setEvm] = react.useState();
   react.useEffect(() => {
-    const chaindataProvider = new chaindataProviderExtension.ChaindataProviderExtension();
-    let shouldHydrate = true;
-    const timer = 300_000; // 300_000ms = 300s = 5 minutes
+    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 [subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances] = useSubscriptions();
+  react.useEffect(() => {
+    switch (subscribeTo) {
+      case "chains":
+        return subscribeHydrateChains();
+      case "evmNetworks":
+        return subscribeHydrateEvmNetworks();
+      case "tokens":
+        return subscribeHydrateTokens();
+      case "tokenRates":
+        return subscribeTokenRates();
+      case "balances":
+        return subscribeBalances();
+    }
+  }, [subscribeTo, subscribeHydrateChains, subscribeHydrateEvmNetworks, subscribeHydrateTokens, subscribeTokenRates, subscribeBalances]);
+};
+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 (!shouldHydrate) return;
+      if (!active) return;
       try {
-        const updated = await chaindataProvider.hydrate();
-        if (updated) setGeneration(generation => (generation + 1) % Number.MAX_SAFE_INTEGER);
-        setTimeout(hydrate, timer);
+        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);
       }
     };
-    setChaindataProvider(chaindataProvider);
     hydrate();
     return () => {
-      shouldHydrate = false;
+      active = false;
     };
-  }, []);
-  if (chaindataProvider) chaindataProvider.generation = generation;
-  return chaindataProvider;
+  }, [chaindata, type]);
+  const subscribe = useMulticastSubscription(createSubscription);
+  return subscribe;
 }
-function useChains(chaindata) {
-  const [chains, setChains] = react.useState();
-  react.useEffect(() => {
-    if (!chaindata) return;
-    const thisGeneration = chaindata.generation;
-    chaindata.chains().then(chains => {
-      if (thisGeneration !== chaindata.generation) return;
-      setChains(chains);
-    });
-  }, [chaindata === null || chaindata === void 0 ? void 0 : chaindata.generation]);
-  return chains || {};
-}
-function useChain(chaindata, chainId) {
-  const [chain, setChain] = react.useState();
-  react.useEffect(() => {
-    if (chaindata === null) return;
-    if (!chainId) return;
-    chaindata.getChain(chainId).then(setChain);
-  }, [chaindata === null || chaindata === void 0 ? void 0 : chaindata.generation]);
-  return chain;
+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 useEvmNetworks(chaindata) {
-  const [evmNetworks, setEvmNetworks] = react.useState();
-  react.useEffect(() => {
-    if (!chaindata) return;
-    const thisGeneration = chaindata.generation;
-    chaindata.evmNetworks().then(evmNetworks => {
-      if (thisGeneration !== chaindata.generation) return;
-      setEvmNetworks(evmNetworks);
+function useSubscribeBalances() {
+  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(({
+    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;
     });
-  }, [chaindata === null || chaindata === void 0 ? void 0 : chaindata.generation]);
-  return evmNetworks || {};
+    const unsubscribeAll = () => unsubs.forEach(unsub => unsub());
+    return unsubscribeAll;
+  }, [addressesByToken, balanceModules, chainConnectors, chaindataProvider, tokens]);
+  const subscribe = useMulticastSubscription(createSubscription);
+  return subscribe;
 }
-function useEvmNetwork(chaindata, evmNetworkId) {
-  const [evmNetwork, setEvmNetwork] = react.useState();
-  react.useEffect(() => {
-    if (chaindata === null) return;
-    if (!evmNetworkId) return;
-    chaindata.getEvmNetwork(evmNetworkId).then(setEvmNetwork);
-  }, [chaindata === null || chaindata === void 0 ? void 0 : chaindata.generation]);
-  return evmNetwork;
+
+function useChains(withTestnets) {
+  // keep db data up to date
+  useDbCacheSubscription("chains");
+  const {
+    chainsWithTestnetsMap,
+    chainsWithoutTestnetsMap
+  } = useDbCache();
+  return withTestnets ? chainsWithTestnetsMap : chainsWithoutTestnetsMap;
 }
-function useTokens(chaindata) {
-  const [tokens, setTokens] = react.useState();
-  react.useEffect(() => {
-    if (!chaindata) return;
-    const thisGeneration = chaindata.generation;
-    chaindata.tokens().then(tokens => {
-      if (thisGeneration !== chaindata.generation) return;
-      setTokens(tokens);
-    });
-  }, [chaindata === null || chaindata === void 0 ? void 0 : chaindata.generation]);
-  return tokens || {};
+function useChain(chainId, withTestnets) {
+  const chains = useChains(withTestnets);
+  return chainId ? chains[chainId] : undefined;
 }
-function useToken(chaindata, tokenId) {
-  const [token, setToken] = react.useState();
-  react.useEffect(() => {
-    if (chaindata === null) return;
-    if (!tokenId) return;
-    chaindata.getToken(tokenId).then(setToken);
-  }, [chaindata === null || chaindata === void 0 ? void 0 : chaindata.generation]);
-  return token;
+
+function useEvmNetworks(withTestnets) {
+  // keep db data up to date
+  useDbCacheSubscription("evmNetworks");
+  const {
+    evmNetworksWithTestnetsMap,
+    evmNetworksWithoutTestnetsMap
+  } = useDbCache();
+  return withTestnets ? evmNetworksWithTestnetsMap : evmNetworksWithoutTestnetsMap;
+}
+function useEvmNetwork(evmNetworkId, withTestnets) {
+  const evmNetworks = useEvmNetworks(withTestnets);
+  return evmNetworkId ? evmNetworks[evmNetworkId] : undefined;
 }
 
-function useTokenRates(tokens) {
-  const generation = react.useRef(0);
-  const [tokenRates$1, setTokenRates] = react.useState();
-  react.useEffect(() => {
-    if (!tokens) return;
-    if (Object.keys(tokens).length < 1) return;
+function useTokenRates() {
+  // keep db data up to date
+  useDbCacheSubscription("tokenRates");
+  const {
+    tokenRatesMap
+  } = useDbCache();
+  return tokenRatesMap;
+}
+function useTokenRate(tokenId) {
+  const tokenRates = useTokenRates();
+  return tokenId ? tokenRates[tokenId] : undefined;
+}
 
-    // 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
-    generation.current = (generation.current + 1) % Number.MAX_SAFE_INTEGER;
-    const thisGeneration = generation.current;
-    tokenRates.fetchTokenRates(tokens).then(tokenRates => {
-      if (thisGeneration !== generation.current) return;
-      setTokenRates(tokenRates);
-    });
-  }, [tokens]);
-  return tokenRates$1 || {};
+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;
+}
+
+const useBalancesHydrate = withTestnets => {
+  const chains = useChains(withTestnets);
+  const evmNetworks = useEvmNetworks(withTestnets);
+  const tokens = useTokens(withTestnets);
+  const tokenRates = useTokenRates();
+  return react.useMemo(() => ({
+    chains,
+    evmNetworks,
+    tokens,
+    tokenRates
+  }), [chains, evmNetworks, tokens, tokenRates]);
+};
 
-// TODO: Add the equivalent functionalty of `useDbCache` directly to this library.
-//
-//       How it will work:
-//
-//       useChains/useEvmNetworks/useTokens/useTokenRates will all make use of a
-//       useCachedDb hook, which internally subscribes to all of the db tables
-//       for everything, and then filters the subscribed data based on what params
-//       the caller of useChains/useTokens/etc has provided.
-function useBalances(
-// TODO: Make this array of BalanceModules more type-safe
-balanceModules, chaindataProvider, addressesByToken) {
-  useBalancesSubscriptions(balanceModules, chaindataProvider, addressesByToken);
-  const chains = useChains(chaindataProvider);
-  const evmNetworks = useEvmNetworks(chaindataProvider);
-  const tokens = useTokens(chaindataProvider);
-  const tokenRates = useTokenRates(tokens);
-  const balances$1 = dexieReactHooks.useLiveQuery(async () => new balances.Balances(await balances.db.balances.filter(balance => {
+function useBalances(addressesByToken) {
+  // keep db data up to date
+  useDbCacheSubscription("balances");
+  const balanceModules = useBalanceModules();
+  const {
+    balances: balances$1
+  } = useDbCache();
+  const hydrate = useBalancesHydrate();
+  return react.useMemo(() => new balances.Balances(balances$1.filter(balance => {
     // check that this balance is included in our queried balance modules
     if (!balanceModules.map(({
       type
@@ -228,143 +549,58 @@ balanceModules, chaindataProvider, addressesByToken) {
 
     // keep this balance
     return true;
-  }).toArray(),
+  }),
   // hydrate balance chains, evmNetworks, tokens and tokenRates
-  {
-    chains,
-    evmNetworks,
-    tokens,
-    tokenRates
-  }), [balanceModules, addressesByToken, chains, evmNetworks, tokens, tokenRates]);
-
-  // debounce every 100ms to prevent hammering UI with updates
-  const [debouncedBalances, setDebouncedBalances] = react.useState(balances$1);
-  reactUse.useDebounce(() => balances$1 && setDebouncedBalances(balances$1), 100, [balances$1]);
-  return debouncedBalances;
+  hydrate), [balances$1, hydrate, balanceModules, addressesByToken]);
 }
 
-// TODO: Turn into react context
-const subscriptions = {};
-
-// This hook is responsible for allowing us to call useBalances
-// from multiple components, without setting up unnecessary
-// balance subscriptions
-function useBalancesSubscriptions(
-// TODO: Make this array of BalanceModules more type-safe
-balanceModules, chaindataProvider, addressesByToken) {
-  // const subscriptions = useRef<
-  //   Record<string, { unsub: Promise<() => void>; refcount: number; generation: number }>
-  // >({})
-
-  const addSubscription = (key, balanceModule, chainConnectors, chaindataProvider, addressesByToken) => {
-    // create subscription if it doesn't already exist
-    if (!subscriptions[key] || subscriptions[key].refcount === 0) {
-      var _subscriptions$key;
-      const generation = ((((_subscriptions$key = subscriptions[key]) === null || _subscriptions$key === void 0 ? void 0 : _subscriptions$key.generation) || 0) + 1) % Number.MAX_SAFE_INTEGER;
-      const unsub = balances.balances(balanceModule, chainConnectors, chaindataProvider, addressesByToken, (error, balances$1) => {
-        if (error) return log.error(`Failed to fetch ${balanceModule.type} balances`, error);
-        if (!balances$1) return;
-
-        // ignore balances from old subscriptions which are still in the process of unsubscribing
-        if (subscriptions[key].generation !== generation) return;
-        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));
-      });
-      subscriptions[key] = {
-        unsub,
-        refcount: 0,
-        generation
-      };
-    }
-
-    // bump up the refcount by 1
-    subscriptions[key].refcount += 1;
-  };
-  const removeSubscription = (key, balanceModule, addressesByToken) => {
-    // ignore dead subscriptions
-    if (!subscriptions[key] || subscriptions[key].refcount === 0) return;
-
-    // drop the refcount by one
-    subscriptions[key].refcount -= 1;
-
-    // unsubscribe if refcount is now 0 (nobody wants this subcription anymore)
-    if (subscriptions[key].refcount < 1) {
-      // remove subscription
-      subscriptions[key].unsub.then(unsub => unsub());
-      delete subscriptions[key];
-
-      // 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(addressesByToken).includes(balance.tokenId)) return false;
-        if (!addressesByToken[balance.tokenId].includes(balance.address)) return false;
-        return true;
-      }).modify({
-        status: "cache"
-      }));
-    }
-  };
-  const chainConnector = useChainConnector(chaindataProvider);
-  const chainConnectorEvm = useChainConnectorEvm(chaindataProvider);
-  const tokens = useTokens(chaindataProvider);
-  react.useEffect(() => {
-    if (chainConnector === null) return;
-    if (chainConnectorEvm === null) return;
-    if (chaindataProvider === null) return;
-    if (addressesByToken === null) return;
-    const unsubs = balanceModules.map(balanceModule => {
-      const subscriptionKey = `${balanceModule.type}-${JSON.stringify(addressesByToken)}`;
-
-      // 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)));
-
-      // add balance subscription for this module
-      addSubscription(subscriptionKey, balanceModule, {
-        substrate: chainConnector,
-        evm: chainConnectorEvm
-      }, chaindataProvider, addressesByModuleToken);
-
-      // return an unsub method, to be called when this effect unmounts
-      return () => removeSubscription(subscriptionKey, balanceModule, addressesByToken);
-    });
-    const unsubAll = () => unsubs.forEach(unsub => unsub());
-    return unsubAll;
-  }, [addressesByToken, chainConnector, chainConnectorEvm, chaindataProvider, tokens]);
-}
-
-// TODO: Allow advanced users of this library to provide their own chain connector
-function useChainConnector(chaindataProvider) {
-  const [chainConnector$1, setChainConnector] = react.useState(null);
-  react.useEffect(() => {
-    if (chaindataProvider === null) return;
-    setChainConnector(new chainConnector.ChainConnector(chaindataProvider));
-  }, [chaindataProvider]);
-  return chainConnector$1;
-}
-// TODO: Allow advanced users of this library to provide their own chain connector
-function useChainConnectorEvm(chaindataProvider) {
-  const [chainConnectorEvm$1, setChainConnectorEvm] = react.useState(null);
-  react.useEffect(() => {
-    if (chaindataProvider === null) return;
-    setChainConnectorEvm(new chainConnectorEvm.ChainConnectorEvm(chaindataProvider));
-  }, [chaindataProvider]);
-  return chainConnectorEvm$1;
-}
+const BalancesProvider = ({
+  balanceModules,
+  onfinalityApiKey,
+  useTestnets,
+  children
+}) => /*#__PURE__*/jsxRuntime.jsx(ChaindataProvider, {
+  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, {
+          useTestnets: useTestnets,
+          children: /*#__PURE__*/jsxRuntime.jsx(SubscriptionsProvider, {
+            children: children
+          })
+        })
+      })
+    })
+  })
+});
 
+exports.AllAddressesProvider = AllAddressesProvider;
+exports.BalanceModulesProvider = BalanceModulesProvider;
+exports.BalancesProvider = BalancesProvider;
+exports.ChainConnectorsProvider = ChainConnectorsProvider;
+exports.ChaindataProvider = ChaindataProvider;
+exports.DbCacheProvider = DbCacheProvider;
+exports.SubscriptionsProvider = SubscriptionsProvider;
+exports.createMulticastSubscription = createMulticastSubscription;
+exports.provideContext = provideContext;
+exports.useAllAddresses = useAllAddresses;
+exports.useBalanceModules = useBalanceModules;
 exports.useBalances = useBalances;
+exports.useBalancesHydrate = useBalancesHydrate;
 exports.useChain = useChain;
+exports.useChainConnectors = useChainConnectors;
 exports.useChaindata = useChaindata;
 exports.useChains = useChains;
+exports.useDbCache = useDbCache;
+exports.useDbCacheSubscription = useDbCacheSubscription;
 exports.useEvmNetwork = useEvmNetwork;
 exports.useEvmNetworks = useEvmNetworks;
+exports.useMulticastSubscription = useMulticastSubscription;
+exports.useSubscriptions = useSubscriptions;
 exports.useToken = useToken;
+exports.useTokenRate = useTokenRate;
 exports.useTokenRates = useTokenRates;
 exports.useTokens = useTokens;