@talismn/balances-react 0.0.0-pr2075-20250710131942 → 0.0.0-pr2076-20250703120513

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

@@ -2,26 +2,29 @@
 
 var jotai = require('jotai');
 var react = require('react');
+var balances = require('@talismn/balances');
 var tokenRates = require('@talismn/token-rates');
 var jsxRuntime = require('react/jsx-runtime');
 var chaindataProvider = require('@talismn/chaindata-provider');
-var balances = require('@talismn/balances');
+var util = require('@talismn/util');
 var jotaiEffect = require('jotai-effect');
-var lodashEs = require('lodash-es');
+var utils = require('jotai/utils');
+var lodash = require('lodash');
+var rxjs = require('rxjs');
+var anylogger = require('anylogger');
 var chainConnector = require('@talismn/chain-connector');
 var chainConnectorEvm = require('@talismn/chain-connector-evm');
 var connectionMeta = require('@talismn/connection-meta');
-var util = require('@talismn/util');
-var utils = require('jotai/utils');
-var rxjs = require('rxjs');
 var dexie = require('dexie');
-var anylogger = require('anylogger');
+var isEqual = require('lodash/isEqual');
 var utilCrypto = require('@polkadot/util-crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
+var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
 
+const balanceModuleCreatorsAtom = jotai.atom(balances.defaultBalanceModules);
 const innerCoinsApiConfigAtom = jotai.atom(tokenRates.DEFAULT_COINSAPI_CONFIG);
 const coinsApiConfigAtom = jotai.atom(get => get(innerCoinsApiConfigAtom), (_get, set, options) => set(innerCoinsApiConfigAtom, {
   apiUrl: options.apiUrl ?? tokenRates.DEFAULT_COINSAPI_CONFIG.apiUrl
@@ -33,6 +36,55 @@ const enabledTokensAtom = jotai.atom(undefined);
 /** Sets the list of addresses for which token balances will be fetched by the balances subscription */
 const allAddressesAtom = jotai.atom([]);
 
+var packageJson = {
+	name: "@talismn/balances-react"};
+
+var log = anylogger__default.default(packageJson.name);
+
+/** 
+// Persistence backend for indexedDB
+// Add a new backend by implementing the BalancesPersistBackend interface
+// configureStore can be called with a different indexedDB table
+*/
+const {
+  persistData,
+  retrieveData
+} = balances.configureStore();
+
+/** 
+// Persistence backend for localStorage
+*/
+const localStoragePersist = async balances$1 => {
+  const storedBalances = balances$1.map(b => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const {
+      status,
+      ...rest
+    } = b;
+    return rest;
+  });
+  const deflated = balances.compress(storedBalances);
+  localStorage.setItem("talismanBalances", deflated.toString());
+};
+const localStorageRetrieve = async () => {
+  const deflated = localStorage.getItem("talismanBalances");
+  if (deflated) {
+    // deflated will be a long string of numbers separated by commas
+    const deflatedArray = deflated.split(",").map(n => parseInt(n, 10));
+    const deflatedBytes = new Uint8Array(deflatedArray.length);
+    deflatedArray.forEach((n, i) => deflatedBytes[i] = n);
+    return balances.decompress(deflatedBytes).map(b => ({
+      ...b,
+      status: "cache"
+    }));
+  }
+  return [];
+};
+const localStorageBalancesPersistBackend = {
+  persist: localStoragePersist,
+  retrieve: localStorageRetrieve
+};
+
 const chaindataProviderAtom = jotai.atom(() => {
   return new chaindataProvider.ChaindataProvider({});
 });
@@ -47,44 +99,19 @@ const chainConnectorsAtom = jotai.atom(get => {
   };
 });
 
-const balancesProviderAtom = jotai.atom(get => {
-  return new balances.BalancesProvider(get(chaindataProviderAtom), get(chainConnectorsAtom)) // TODO pass storage
-  ;
-});
-
-const chaindataAtom = utils.atomWithObservable(get => {
-  return rxjs.combineLatest({
-    networks: get(chaindataProviderAtom).networks$,
-    tokens: get(chaindataProviderAtom).tokens$
-  }).pipe(util.firstThenDebounce(1_000));
-});
-const filteredChaindataAtom = jotai.atom(async get => {
-  const enabledNetworkIds = get(enabledChainsAtom);
-  const enabledTokenIds = get(enabledTokensAtom);
-  const enableTestnets = get(enableTestnetsAtom);
-  const chaindata = await get(chaindataAtom);
-  const networks = chaindata.networks.filter(n => (enabledNetworkIds?.includes(n.id) || n.isDefault) && (enableTestnets || !n.isTestnet));
-  const networkById = lodashEs.keyBy(networks, n => n.id);
-  const tokens = chaindata.tokens.filter(token => (enabledTokenIds?.includes(token.id) || token.isDefault) && networkById[token.networkId]);
-  return {
-    networks,
-    tokens
-  };
-});
-const tokensAtom = jotai.atom(async get => {
-  const chaindata = await get(filteredChaindataAtom);
-  return chaindata.tokens;
-});
-const networksAtom = jotai.atom(async get => {
-  const chaindata = await get(filteredChaindataAtom);
-  return chaindata.networks;
+const balanceModulesAtom = jotai.atom(get => {
+  const balanceModuleCreators = get(balanceModuleCreatorsAtom);
+  const chainConnectors = get(chainConnectorsAtom);
+  const chaindataProvider = get(chaindataProviderAtom);
+  if (!chainConnectors.substrate) return [];
+  if (!chainConnectors.evm) return [];
+  if (!chaindataProvider) return [];
+  return balanceModuleCreators.map(mod => mod({
+    chainConnectors,
+    chaindataProvider
+  }));
 });
 
-var packageJson = {
-	name: "@talismn/balances-react"};
-
-var log = anylogger__default.default(packageJson.name);
-
 /**
  * Converts a dexie Observable into an rxjs Observable.
  */
@@ -98,6 +125,54 @@ function dexieToRxjs(o) {
   });
 }
 
+const chainsAtom = jotai.atom(async get => (await get(chaindataAtom)).chains);
+const chainsByIdAtom = jotai.atom(async get => (await get(chaindataAtom)).chainsById);
+const chainsByGenesisHashAtom = jotai.atom(async get => (await get(chaindataAtom)).chainsByGenesisHash);
+const evmNetworksAtom = jotai.atom(async get => (await get(chaindataAtom)).evmNetworks);
+const evmNetworksByIdAtom = jotai.atom(async get => (await get(chaindataAtom)).evmNetworksById);
+const tokensAtom = jotai.atom(async get => (await get(chaindataAtom)).tokens);
+const tokensByIdAtom = jotai.atom(async get => (await get(chaindataAtom)).tokensById);
+const miniMetadatasAtom = jotai.atom(async get => (await get(chaindataAtom)).miniMetadatas);
+const chaindataAtom = utils.atomWithObservable(get => {
+  const enableTestnets = get(enableTestnetsAtom);
+  const filterTestnets = items => enableTestnets ? items : items.filter(({
+    isTestnet
+  }) => !isTestnet);
+  const filterMapTestnets = items => enableTestnets ? items : Object.fromEntries(Object.entries(items).filter(([, {
+    isTestnet
+  }]) => !isTestnet));
+  const filterEnabledTokens = tokens => tokens.filter(token => token.isDefault || "isCustom" in token && token.isCustom);
+  const filterMapEnabledTokens = tokensById => Object.fromEntries(Object.entries(tokensById).filter(([, token]) => token.isDefault || "isCustom" in token && token.isCustom));
+  const distinctUntilIsEqual = rxjs.distinctUntilChanged((a, b) => isEqual__default.default(a, b));
+  const chains = get(chaindataProviderAtom).getNetworks$("polkadot").pipe(distinctUntilIsEqual, rxjs.map(filterTestnets), distinctUntilIsEqual);
+  const chainsById = get(chaindataProviderAtom).getNetworksMapById$("polkadot").pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
+  const chainsByGenesisHash = get(chaindataProviderAtom).getNetworksMapByGenesisHash$().pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
+  const evmNetworks = get(chaindataProviderAtom).getNetworks$("ethereum").pipe(distinctUntilIsEqual, rxjs.map(filterTestnets), distinctUntilIsEqual);
+  const networks = get(chaindataProviderAtom).getNetworks$().pipe(distinctUntilIsEqual, rxjs.map(filterTestnets), distinctUntilIsEqual);
+  const evmNetworksById = get(chaindataProviderAtom).getNetworksMapById$("ethereum").pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
+  const networksById = get(chaindataProviderAtom).getNetworksMapById$().pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
+  const tokens = get(chaindataProviderAtom).tokens$.pipe(distinctUntilIsEqual, rxjs.map(filterEnabledTokens), distinctUntilIsEqual);
+  const tokensById = get(chaindataProviderAtom).getTokensMapById$().pipe(distinctUntilIsEqual, rxjs.map(filterMapEnabledTokens), distinctUntilIsEqual);
+  const miniMetadatasObservable = dexieToRxjs(dexie.liveQuery(() => balances.db.miniMetadatas.toArray()));
+  const miniMetadatas = rxjs.combineLatest([miniMetadatasObservable.pipe(distinctUntilIsEqual), chainsById]).pipe(rxjs.map(([miniMetadatas, chainsById]) => miniMetadatas.filter(m => chainsById[m.chainId])), distinctUntilIsEqual);
+  return rxjs.combineLatest({
+    networks,
+    networksById,
+    chains,
+    chainsById,
+    chainsByGenesisHash,
+    evmNetworks,
+    evmNetworksById,
+    tokens,
+    tokensById,
+    miniMetadatas
+  }).pipe(
+  // debounce to prevent hammering UI with updates
+  util.firstThenDebounce(1_000), distinctUntilIsEqual);
+});
+
+const cryptoWaitReadyAtom = jotai.atom(async () => await utilCrypto.cryptoWaitReady());
+
 const tokenRatesAtom = jotai.atom(async get => {
   // runs a timer to keep tokenRates up to date
   get(tokenRatesFetcherAtomEffect);
@@ -118,9 +193,9 @@ const tokenRatesFetcherAtomEffect = jotaiEffect.atomEffect(get => {
 
   // we have to get these synchronously so that jotai knows to restart our timer when they change
   const coinsApiConfig = get(coinsApiConfigAtom);
-  const tokensPromise = get(tokensAtom);
+  const tokensByIdPromise = get(tokensByIdAtom);
   (async () => {
-    const tokensById = lodashEs.keyBy(await tokensPromise, "id");
+    const tokensById = await tokensByIdPromise;
     const tokenIds = Object.keys(tokensById);
     const loopMs = 300_000; // 300_000ms = 300s = 5 minutes
     const retryTimeout = 5_000; // 5_000ms = 5 seconds
@@ -161,42 +236,213 @@ const tokenRatesFetcherAtomEffect = jotaiEffect.atomEffect(get => {
   return () => abort.abort("Unsubscribed");
 });
 
-const addressesByTokenIdAtom = jotai.atom(async get => {
-  const [tokens, addresses] = await Promise.all([get(tokensAtom), get(allAddressesAtom)]);
-  return lodashEs.fromPairs(tokens.map(token => [token.id, addresses]));
+const allBalancesAtom = jotai.atom(async get => {
+  // set up our subscription to fetch balances from the various blockchains
+  get(balancesSubscriptionAtomEffect);
+  const [balances$1, hydrateData] = await Promise.all([get(balancesObservableAtom), get(balancesHydrateDataAtom)]);
+  return new balances.Balances(Object.values(balances$1).filter(balance => !!hydrateData?.tokens?.[balance.tokenId]),
+  // hydrate balance chains, evmNetworks, tokens and tokenRates
+  hydrateData);
 });
-const rawBalancesAtom = jotai.atom([]);
-const subscribeBalancesAtom = jotaiEffect.atomEffect((get, set) => {
-  const unsub = (async () => {
-    const balancesProvider = get(balancesProviderAtom);
-    const addressesByTokenId = await get(addressesByTokenIdAtom);
-    const sub = balancesProvider.getBalances$(addressesByTokenId).subscribe(balances => {
-      set(rawBalancesAtom, balances.balances);
-    });
-    return () => {
-      return sub.unsubscribe();
-    };
-  })();
-  return () => {
-    unsub.then(unsubscribe => unsubscribe());
-  };
+const balancesObservable = new rxjs.BehaviorSubject({});
+const balancesObservableAtom = utils.atomWithObservable(() => balancesObservable);
+const balancesPersistBackendAtom = jotai.atom(localStorageBalancesPersistBackend);
+const hydrateBalancesObservableAtom = jotai.atom(async get => {
+  const persistBackend = get(balancesPersistBackendAtom);
+  const balances$1 = await persistBackend.retrieve();
+  balancesObservable.next(Object.fromEntries(balances$1.map(b => [balances.getBalanceId(b), {
+    ...b,
+    status: "cache"
+  }])));
 });
 const balancesHydrateDataAtom = jotai.atom(async get => {
-  const [chaindata, tokenRates] = await Promise.all([get(chaindataAtom), get(tokenRatesAtom)]);
-  const networksById = lodashEs.keyBy(chaindata.networks, "id");
-  const tokensById = lodashEs.keyBy(chaindata.tokens, "id");
+  const [{
+    networksById,
+    tokensById
+  }, tokenRates] = await Promise.all([get(chaindataAtom), get(tokenRatesAtom)]);
   return {
     networks: networksById,
     tokens: tokensById,
     tokenRates
   };
 });
-const balancesAtom = jotai.atom(async get => {
-  // subscribe to balancesProvider getBalance with addressesByTokenIdAtom as param
-  get(subscribeBalancesAtom);
-  const hydrate = await get(balancesHydrateDataAtom);
-  const rawBalances = get(rawBalancesAtom);
-  return new balances.Balances(rawBalances, hydrate);
+const balancesSubscriptionAtomEffect = jotaiEffect.atomEffect(get => {
+  // lets us tear down the existing subscriptions when the atomEffect is restarted
+  const abort = new AbortController();
+
+  // we have to specify these synchronously, otherwise jotai won't know
+  // that it needs to restart our subscriptions when they change
+  const atomDependencies = Promise.all([get(cryptoWaitReadyAtom), get(balanceModulesAtom), get(allAddressesAtom), get(chainsAtom), get(chainsByIdAtom), get(evmNetworksAtom), get(evmNetworksByIdAtom), get(tokensAtom), get(tokensByIdAtom), get(miniMetadatasAtom), get(enabledChainsAtom), get(enabledTokensAtom), get(hydrateBalancesObservableAtom)]);
+  const persistBackend = get(balancesPersistBackendAtom);
+  const unsubsPromise = (async () => {
+    const [_cryptoReady, balanceModules, allAddresses, chains, chainsById, evmNetworks, evmNetworksById, tokens, tokensById, _miniMetadatas, enabledChainsConfig, enabledTokensConfig] = await atomDependencies;
+    if (abort.signal.aborted) return;
+
+    // persist data every thirty seconds
+    balancesObservable.pipe(rxjs.debounceTime(10000)).subscribe(balancesUpdate => {
+      persistBackend.persist(Object.values(balancesUpdate));
+    });
+    const updateBalances = async balancesUpdates => {
+      if (abort.signal.aborted) return;
+      const updatesWithIds = new balances.Balances(balancesUpdates);
+      const existing = balancesObservable.value;
+
+      // update initialising set here - before filtering out zero balances
+      // while this may include stale balances, the important thing is that the balance is no longer "initialising"
+      // balancesUpdates.forEach((b) => this.#initialising.delete(getBalanceId(b)))
+
+      const newlyZeroBalances = [];
+      const changedBalances = Object.fromEntries(updatesWithIds.each.filter(newB => {
+        const isZero = newB.total.tokens === "0";
+        // Keep new balances which are not zeros
+        const existingB = existing[newB.id];
+        if (!existingB && !isZero) return true;
+        const hasChanged = !lodash.isEqual(existingB, newB.toJSON());
+        // Collect balances now confirmed to be zero separately, so they can be filtered out from the main set
+        if (existingB && hasChanged && isZero) newlyZeroBalances.push(newB.id);
+        // Keep changed balances, which are not known zeros
+        return hasChanged && !isZero;
+      }).map(b => [b.id, b.toJSON()]));
+      if (Object.keys(changedBalances).length === 0 && newlyZeroBalances.length === 0) return;
+      const nonZeroBalances = newlyZeroBalances.length > 0 ? Object.fromEntries(Object.entries(existing).filter(([id]) => !newlyZeroBalances.includes(id))) : existing;
+      const newBalancesState = {
+        ...nonZeroBalances,
+        ...changedBalances
+      };
+      if (Object.keys(newBalancesState).length === 0) return;
+      balancesObservable.next(newBalancesState);
+    };
+    const deleteBalances = async balancesFilter => {
+      if (abort.signal.aborted) return;
+      const balancesToKeep = Object.fromEntries(new balances.Balances(Object.values(await get(balancesObservableAtom))).each.filter(b => !balancesFilter(b)).map(b => [b.id, b.toJSON()]));
+      balancesObservable.next(balancesToKeep);
+    };
+    const enabledChainIds = enabledChainsConfig?.map(genesisHash => chains.find(chain => chain.genesisHash === genesisHash)?.id);
+    const enabledChainsFilter = enabledChainIds ? token => token.platform === "polkadot" && enabledChainIds?.includes(token.networkId) : () => true;
+    const enabledTokensFilter = enabledTokensConfig ? token => enabledTokensConfig.includes(token.id) : () => true;
+    const enabledTokenIds = tokens.filter(enabledChainsFilter).filter(enabledTokensFilter).map(({
+      id
+    }) => id);
+    if (enabledTokenIds.length < 1 || allAddresses.length < 1) return;
+    const addressesByTokenByModule = {};
+    enabledTokenIds.flatMap(tokenId => tokensById[tokenId]).forEach(token => {
+      // filter out tokens on chains/evmNetworks which have no rpcs
+      const hasRpcs = token.networkId && (chainsById[token.networkId]?.rpcs?.length ?? 0) > 0 || token.networkId && (evmNetworksById[token.networkId]?.rpcs?.length ?? 0) > 0;
+      if (!hasRpcs) return;
+      if (!addressesByTokenByModule[token.type]) addressesByTokenByModule[token.type] = {};
+      addressesByTokenByModule[token.type][token.id] = allAddresses.filter(address => {
+        // for each address, fetch balances only from compatible chains
+        return util.isEthereumAddress(address) ? token.networkId || chainsById[token.networkId ?? ""]?.account === "secp256k1" : token.networkId && chainsById[token.networkId ?? ""]?.account !== "secp256k1";
+      });
+    });
+
+    // Delete invalid cached balances
+    const chainIds = new Set(chains.map(chain => chain.id));
+    const evmNetworkIds = new Set(evmNetworks.map(evmNetwork => evmNetwork.id));
+    await deleteBalances(balance => {
+      // delete cached balances for accounts which don't exist anymore
+      if (!balance.address || !allAddresses.includes(balance.address)) return true;
+
+      // delete cached balances when chain/evmNetwork doesn't exist
+      if (!chainIds.has(balance.networkId) && !evmNetworkIds.has(balance.networkId)) return true;
+
+      // delete cached balance when token doesn't exist / is disabled
+      if (!enabledTokenIds.includes(balance.tokenId)) return true;
+
+      // delete cached balance when module doesn't exist
+      if (!balanceModules.find(module => module.type === balance.source)) return true;
+
+      // delete cached balance for accounts on incompatible chains
+      // (substrate accounts shouldn't have evm balances)
+      // (evm accounts shouldn't have substrate balances (unless the chain uses secp256k1 accounts))
+      const chain = chains.find(({
+        id
+      }) => id === balance.networkId) || null;
+      const hasChain = chainIds.has(balance.networkId);
+      const hasEvmNetwork = evmNetworkIds.has(balance.networkId);
+      const chainUsesSecp256k1Accounts = chain?.account === "secp256k1";
+      if (!util.isEthereumAddress(balance.address)) {
+        if (!hasChain) return true;
+        if (chainUsesSecp256k1Accounts) return true;
+      }
+      if (util.isEthereumAddress(balance.address)) {
+        if (!hasEvmNetwork && !chainUsesSecp256k1Accounts) return true;
+      }
+
+      // keep balance
+      return false;
+    });
+    if (abort.signal.aborted) return;
+
+    // after 30 seconds, change the status of all balances still initializing to stale
+    setTimeout(() => {
+      if (abort.signal.aborted) return;
+      const staleObservable = balancesObservable.pipe(rxjs.map(val => Object.values(val).filter(({
+        status
+      }) => status === "cache").map(balance => ({
+        ...balance,
+        status: "stale"
+      }))));
+      rxjs.firstValueFrom(staleObservable).then(v => {
+        if (v.length) updateBalances(v);
+      });
+    }, 30_000);
+    return balanceModules.map(balanceModule => {
+      const unsub = balances.balances(balanceModule, addressesByTokenByModule[balanceModule.type] ?? {}, (error, balances) => {
+        // log errors
+        if (error) {
+          if (error?.type === "STALE_RPC_ERROR" || error?.type === "WEBSOCKET_ALLOCATION_EXHAUSTED_ERROR") {
+            const addressesByModuleToken = addressesByTokenByModule[balanceModule.type] ?? {};
+            const staleObservable = balancesObservable.pipe(rxjs.map(val => Object.values(val).filter(balance => {
+              const {
+                tokenId,
+                address,
+                source
+              } = balance;
+              const chainComparison = error.chainId ? "chainId" in balance && error.chainId === balance.chainId : error.evmNetworkId ? "evmNetworkId" in balance && error.evmNetworkId === balance.evmNetworkId : true;
+              return chainComparison && addressesByModuleToken[tokenId]?.includes(address) && source === balanceModule.type;
+            }).map(balance => ({
+              ...balance,
+              status: "stale"
+            }))));
+            rxjs.firstValueFrom(staleObservable).then(v => {
+              if (v.length) updateBalances(v);
+            });
+          }
+          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 (abort.signal.aborted) return;
+
+        // good balances
+        if (balances) {
+          if ("status" in balances) {
+            // For modules using the new SubscriptionResultWithStatus pattern
+            //TODO fix initialisin
+            // if (result.status === "initialising") this.#initialising.add(balanceModule.type)
+            // else this.#initialising.delete(balanceModule.type)
+            updateBalances(balances.data);
+          } else {
+            // add good ones to initialisedBalances
+            updateBalances(Object.values(balances.toJSON()));
+          }
+        }
+      });
+      return () => unsub.then(unsubscribe => unsubscribe());
+    });
+  })();
+
+  // close the existing subscriptions when our effect unmounts
+  // (wait 2 seconds before actually unsubscribing, to allow the websocket to be reused in that time)
+  const unsubscribe = () => unsubsPromise.then(unsubs => {
+    persistBackend.persist(Object.values(balancesObservable.value));
+    unsubs?.forEach(unsub => unsub());
+  });
+  abort.signal.addEventListener("abort", () => setTimeout(unsubscribe, 2_000));
+  return () => abort.abort("Unsubscribed");
 });
 
 const useSetBalancesAddresses = addresses => {
@@ -213,8 +459,10 @@ const useSetBalancesAddresses = addresses => {
  * @returns a Balances object containing the current balances state.
  */
 
-const useBalances = () => {
-  return jotai.useAtomValue(balancesAtom);
+const useBalances = persistBackend => {
+  const [, setPersistBackend] = jotai.useAtom(balancesPersistBackendAtom);
+  if (persistBackend) setPersistBackend(persistBackend);
+  return jotai.useAtomValue(allBalancesAtom);
 };
 
 // TODO: Extract to shared definition between extension and @talismn/balances-react
@@ -251,41 +499,30 @@ const useChainConnectors = () => jotai.useAtomValue(chainConnectorsAtom);
 
 const useChaindataProvider = () => jotai.useAtomValue(chaindataProviderAtom);
 const useChaindata = () => jotai.useAtomValue(chaindataAtom);
-const useNetworks = () => useChaindata().networks;
-const useNetworksById = () => {
-  const {
-    networks
-  } = useChaindata();
-  return react.useMemo(() => lodashEs.keyBy(networks, n => n.id), [networks]);
-};
-const useNetwork = networkId => {
-  const networksById = useNetworksById();
-  return networksById[networkId ?? ""] ?? null;
-};
-const useTokens = () => useChaindata().tokens;
-const useTokensById = () => {
-  const {
-    tokens
-  } = useChaindata();
-  return react.useMemo(() => lodashEs.keyBy(tokens, t => t.id), [tokens]);
-};
-const useToken = tokenId => {
-  const tokensById = useTokensById();
-  return tokensById[tokenId ?? ""] ?? null;
-};
+const useChains = () => jotai.useAtomValue(chainsByIdAtom);
+const useChainsByGenesisHash = () => jotai.useAtomValue(chainsByGenesisHashAtom);
+const useEvmNetworks = () => jotai.useAtomValue(evmNetworksByIdAtom);
+const useTokens = () => jotai.useAtomValue(tokensByIdAtom);
+const useMiniMetadatas = () => jotai.useAtomValue(miniMetadatasAtom);
+const useChain = chainId => useChains()[chainId ?? ""] ?? undefined;
+const useEvmNetwork = evmNetworkId => useEvmNetworks()[evmNetworkId ?? ""] ?? undefined;
+const useToken = tokenId => useTokens()[tokenId ?? ""] ?? undefined;
 
 const useTokenRates = () => jotai.useAtomValue(tokenRatesAtom);
 const useTokenRate = tokenId => useTokenRates()[tokenId ?? ""] ?? undefined;
 
-const cryptoWaitReadyAtom = jotai.atom(async () => await utilCrypto.cryptoWaitReady());
-
 const BalancesProvider = ({
+  balanceModules,
   coinsApiUrl,
   withTestnets,
   enabledChains,
   enabledTokens,
   children
 }) => {
+  const setBalanceModules = jotai.useSetAtom(balanceModuleCreatorsAtom);
+  react.useEffect(() => {
+    if (balanceModules !== undefined) setBalanceModules(balanceModules);
+  }, [balanceModules, setBalanceModules]);
   const setCoinsApiConfig = jotai.useSetAtom(coinsApiConfigAtom);
   react.useEffect(() => {
     setCoinsApiConfig({
@@ -335,30 +572,41 @@ Object.defineProperty(exports, "subTokensTokenId", {
 });
 exports.BalancesProvider = BalancesProvider;
 exports.allAddressesAtom = allAddressesAtom;
-exports.balancesAtom = balancesAtom;
+exports.allBalancesAtom = allBalancesAtom;
+exports.balanceModuleCreatorsAtom = balanceModuleCreatorsAtom;
+exports.balanceModulesAtom = balanceModulesAtom;
+exports.balancesPersistBackendAtom = balancesPersistBackendAtom;
 exports.chainConnectorsAtom = chainConnectorsAtom;
 exports.chaindataAtom = chaindataAtom;
 exports.chaindataProviderAtom = chaindataProviderAtom;
+exports.chainsAtom = chainsAtom;
+exports.chainsByGenesisHashAtom = chainsByGenesisHashAtom;
+exports.chainsByIdAtom = chainsByIdAtom;
 exports.coinsApiConfigAtom = coinsApiConfigAtom;
 exports.cryptoWaitReadyAtom = cryptoWaitReadyAtom;
 exports.enableTestnetsAtom = enableTestnetsAtom;
 exports.enabledChainsAtom = enabledChainsAtom;
 exports.enabledTokensAtom = enabledTokensAtom;
+exports.evmNetworksAtom = evmNetworksAtom;
+exports.evmNetworksByIdAtom = evmNetworksByIdAtom;
 exports.getStaleChains = getStaleChains;
-exports.networksAtom = networksAtom;
+exports.miniMetadatasAtom = miniMetadatasAtom;
 exports.tokenRatesAtom = tokenRatesAtom;
 exports.tokensAtom = tokensAtom;
+exports.tokensByIdAtom = tokensByIdAtom;
 exports.useBalances = useBalances;
 exports.useBalancesStatus = useBalancesStatus;
+exports.useChain = useChain;
 exports.useChainConnectors = useChainConnectors;
 exports.useChaindata = useChaindata;
 exports.useChaindataProvider = useChaindataProvider;
-exports.useNetwork = useNetwork;
-exports.useNetworks = useNetworks;
-exports.useNetworksById = useNetworksById;
+exports.useChains = useChains;
+exports.useChainsByGenesisHash = useChainsByGenesisHash;
+exports.useEvmNetwork = useEvmNetwork;
+exports.useEvmNetworks = useEvmNetworks;
+exports.useMiniMetadatas = useMiniMetadatas;
 exports.useSetBalancesAddresses = useSetBalancesAddresses;
 exports.useToken = useToken;
 exports.useTokenRate = useTokenRate;
 exports.useTokenRates = useTokenRates;
 exports.useTokens = useTokens;
-exports.useTokensById = useTokensById;