@talismn/balances-react 0.9.12 → 1.0.0

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

@@ -2,30 +2,26 @@
 
 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 util = require('@talismn/util');
+var chaindataProvider = require('@talismn/chaindata-provider');
+var balances = require('@talismn/balances');
 var jotaiEffect = require('jotai-effect');
-var utils = require('jotai/utils');
-var lodash = require('lodash');
-var rxjs = require('rxjs');
-var anylogger = require('anylogger');
+var lodashEs = require('lodash-es');
 var chainConnector = require('@talismn/chain-connector');
 var chainConnectorEvm = require('@talismn/chain-connector-evm');
 var connectionMeta = require('@talismn/connection-meta');
-var chaindataProvider = require('@talismn/chaindata-provider');
-var utilCrypto = require('@polkadot/util-crypto');
+var util = require('@talismn/util');
+var utils = require('jotai/utils');
+var rxjs = require('rxjs');
 var dexie = require('dexie');
-var isEqual = require('lodash/isEqual');
+var anylogger = require('anylogger');
+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 onfinalityApiKeyAtom = jotai.atom(undefined);
 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
@@ -37,137 +33,58 @@ 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 cryptoWaitReadyAtom = jotai.atom(async () => await utilCrypto.cryptoWaitReady());
-
-const chaindataProviderAtom = jotai.atom(get => {
-  // runs a timer to keep chaindata hydrated
-  get(chaindataHydrateAtomEffect);
-  return new chaindataProvider.ChaindataProvider({
-    onfinalityApiKey: get(onfinalityApiKeyAtom)
-  });
+const chaindataProviderAtom = jotai.atom(() => {
+  return new chaindataProvider.ChaindataProvider({});
 });
-const miniMetadataHydratedAtom = jotai.atom(false);
 
-/** This atomEffect keeps chaindata hydrated (i.e. up to date with the GitHub repo) */
-const chaindataHydrateAtomEffect = jotaiEffect.atomEffect((get, set) => {
+const chainConnectorsAtom = jotai.atom(get => {
   const chaindataProvider = get(chaindataProviderAtom);
-  const miniMetadataUpdater = get(miniMetadataUpdaterAtom);
-  const evmTokenFetcher = get(evmTokenFetcherAtom);
-  const loopMs = 300_000; // 300_000ms = 300s = 5 minutes
-  const retryTimeout = 5_000; // 5_000ms = 5 seconds
-
-  let timeout = null;
-  const hydrate = async () => {
-    try {
-      await get(cryptoWaitReadyAtom);
-      await balances.hydrateChaindataAndMiniMetadata(chaindataProvider, miniMetadataUpdater);
-      await balances.updateCustomMiniMetadata(chaindataProvider, miniMetadataUpdater);
-      await balances.updateEvmTokens(chaindataProvider, evmTokenFetcher);
-      set(miniMetadataHydratedAtom, true);
-      timeout = setTimeout(hydrate, loopMs);
-    } catch (error) {
-      log.error(`Failed to hydrate chaindata, retrying in ${Math.round(retryTimeout / 1000)} seconds`, error);
-      timeout = setTimeout(hydrate, retryTimeout);
-    }
+  const substrate = new chainConnector.ChainConnector(chaindataProvider, connectionMeta.connectionMetaDb);
+  const evm = new chainConnectorEvm.ChainConnectorEvm(chaindataProvider);
+  return {
+    substrate,
+    evm
   };
-
-  // launch the loop
-  hydrate();
-
-  // return an unsub function to shut down the loop
-  return () => timeout && clearTimeout(timeout);
 });
 
-/** MiniMetadataUpdater is a class used for hydrating chaindata */
-const miniMetadataUpdaterAtom = jotai.atom(get => {
-  const chainConnectors = get(chainConnectorsAtom);
-  const chaindataProvider = get(chaindataProviderAtom);
-  const balanceModules = get(balanceModulesAtom);
-  return new balances.MiniMetadataUpdater(chainConnectors, chaindataProvider, balanceModules);
+const balancesProviderAtom = jotai.atom(get => {
+  return new balances.BalancesProvider(get(chaindataProviderAtom), get(chainConnectorsAtom)) // TODO pass storage
+  ;
 });
 
-/** EvmTokenFetcher is a class used for hydrating chaindata */
-const evmTokenFetcherAtom = jotai.atom(get => {
-  const chaindataProvider = get(chaindataProviderAtom);
-  const balanceModules = get(balanceModulesAtom);
-  return new balances.EvmTokenFetcher(chaindataProvider, balanceModules);
+const chaindataAtom = utils.atomWithObservable(get => {
+  return rxjs.combineLatest({
+    networks: get(chaindataProviderAtom).networks$,
+    tokens: get(chaindataProviderAtom).tokens$
+  }).pipe(util.firstThenDebounce(1_000));
 });
-
-const chainConnectorsAtom = jotai.atom(get => {
-  const onfinalityApiKey = get(onfinalityApiKeyAtom);
-  const chaindataProvider = get(chaindataProviderAtom);
-  const substrate = new chainConnector.ChainConnector(chaindataProvider, connectionMeta.connectionMetaDb);
-  const evm = new chainConnectorEvm.ChainConnectorEvm(chaindataProvider, {
-    onfinalityApiKey
-  });
+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 {
-    substrate,
-    evm
+    networks,
+    tokens
   };
 });
-
-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
-  }));
+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;
 });
 
+var packageJson = {
+	name: "@talismn/balances-react"};
+
+var log = anylogger__default.default(packageJson.name);
+
 /**
  * Converts a dexie Observable into an rxjs Observable.
  */
@@ -181,48 +98,6 @@ 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).chainsObservable.pipe(distinctUntilIsEqual, rxjs.map(filterTestnets), distinctUntilIsEqual);
-  const chainsById = get(chaindataProviderAtom).chainsByIdObservable.pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
-  const chainsByGenesisHash = get(chaindataProviderAtom).chainsByGenesisHashObservable.pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
-  const evmNetworks = get(chaindataProviderAtom).evmNetworksObservable.pipe(distinctUntilIsEqual, rxjs.map(filterTestnets), distinctUntilIsEqual);
-  const evmNetworksById = get(chaindataProviderAtom).evmNetworksByIdObservable.pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), distinctUntilIsEqual);
-  const tokens = get(chaindataProviderAtom).tokensObservable.pipe(distinctUntilIsEqual, rxjs.map(filterTestnets), rxjs.map(filterEnabledTokens), distinctUntilIsEqual);
-  const tokensById = get(chaindataProviderAtom).tokensByIdObservable.pipe(distinctUntilIsEqual, rxjs.map(filterMapTestnets), 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({
-    chains,
-    chainsById,
-    chainsByGenesisHash,
-    evmNetworks,
-    evmNetworksById,
-    tokens,
-    tokensById,
-    miniMetadatas
-  }).pipe(
-  // debounce to prevent hammering UI with updates
-  util.firstThenDebounce(1_000), distinctUntilIsEqual);
-});
-
 const tokenRatesAtom = jotai.atom(async get => {
   // runs a timer to keep tokenRates up to date
   get(tokenRatesFetcherAtomEffect);
@@ -243,9 +118,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 tokensByIdPromise = get(tokensByIdAtom);
+  const tokensPromise = get(tokensAtom);
   (async () => {
-    const tokensById = await tokensByIdPromise;
+    const tokensById = lodashEs.keyBy(await tokensPromise, "id");
     const tokenIds = Object.keys(tokensById);
     const loopMs = 300_000; // 300_000ms = 300s = 5 minutes
     const retryTimeout = 5_000; // 5_000ms = 5 seconds
@@ -275,7 +150,7 @@ const tokenRatesFetcherAtomEffect = jotaiEffect.atomEffect(get => {
         const retrying = !abort.signal.aborted;
         const messageParts = ["Failed to fetch tokenRates", retrying && `retrying in ${Math.round(retryTimeout / 1000)} seconds`, !retrying && `giving up (timer no longer needed)`].filter(util.isTruthy);
         log.error(messageParts.join(", "), error);
-        if (abort.signal.aborted) return; // don't schedule retry if aborted
+        if (util.isAbortError(error)) return; // don't schedule retry if aborted
         setTimeout(hydrate, retryTimeout);
       }
     };
@@ -286,218 +161,42 @@ const tokenRatesFetcherAtomEffect = jotaiEffect.atomEffect(get => {
   return () => abort.abort("Unsubscribed");
 });
 
-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 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 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 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 balancesHydrateDataAtom = jotai.atom(async get => {
-  const [{
-    chainsById,
-    evmNetworksById,
-    tokensById
-  }, tokenRates] = await Promise.all([get(chaindataAtom), get(tokenRatesAtom)]);
+  const [chaindata, tokenRates] = await Promise.all([get(chaindataAtom), get(tokenRatesAtom)]);
+  const networksById = lodashEs.keyBy(chaindata.networks, "id");
+  const tokensById = lodashEs.keyBy(chaindata.tokens, "id");
   return {
-    chains: chainsById,
-    evmNetworks: evmNetworksById,
+    networks: networksById,
     tokens: tokensById,
     tokenRates
   };
 });
-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(miniMetadataHydratedAtom), 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, miniMetadataHydrated, allAddresses, chains, chainsById, evmNetworks, evmNetworksById, tokens, tokensById, _miniMetadatas, enabledChainsConfig, enabledTokensConfig] = await atomDependencies;
-    if (!miniMetadataHydrated) return;
-    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.chain && enabledChainIds?.includes(token.chain.id) : () => 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.chain?.id && (chainsById[token.chain.id]?.rpcs?.length ?? 0) > 0 || token.evmNetwork?.id && (evmNetworksById[token.evmNetwork.id]?.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.evmNetwork?.id || chainsById[token.chain?.id ?? ""]?.account === "secp256k1" : token.chain?.id && chainsById[token.chain?.id ?? ""]?.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 (balance.chainId === undefined && balance.evmNetworkId === undefined) return true;
-      if (balance.chainId !== undefined && !chainIds.has(balance.chainId)) return true;
-      if (balance.evmNetworkId !== undefined && !evmNetworkIds.has(balance.evmNetworkId)) 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 = balance.chainId && chains.find(({
-        id
-      }) => id === balance.chainId) || null;
-      const hasChain = balance.chainId && chainIds.has(balance.chainId);
-      const hasEvmNetwork = balance.evmNetworkId && evmNetworkIds.has(balance.evmNetworkId);
-      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 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 useSetBalancesAddresses = addresses => {
@@ -514,10 +213,8 @@ const useSetBalancesAddresses = addresses => {
  * @returns a Balances object containing the current balances state.
  */
 
-const useBalances = persistBackend => {
-  const [, setPersistBackend] = jotai.useAtom(balancesPersistBackendAtom);
-  if (persistBackend) setPersistBackend(persistBackend);
-  return jotai.useAtomValue(allBalancesAtom);
+const useBalances = () => {
+  return jotai.useAtomValue(balancesAtom);
 };
 
 // TODO: Extract to shared definition between extension and @talismn/balances-react
@@ -548,41 +245,47 @@ const useBalancesStatus = balances => react.useMemo(() => {
     status: "live"
   };
 }, [balances]);
-const getStaleChains = balances => [...new Set(balances.sorted.filter(b => b.status === "stale").map(b => b.chain?.name ?? b.chainId ?? "Unknown"))];
+const getStaleChains = balances => [...new Set(balances.each.filter(b => b.status === "stale").map(b => b.network?.name ?? b.networkId ?? "Unknown"))];
 
 const useChainConnectors = () => jotai.useAtomValue(chainConnectorsAtom);
 
 const useChaindataProvider = () => jotai.useAtomValue(chaindataProviderAtom);
 const useChaindata = () => jotai.useAtomValue(chaindataAtom);
-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 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 useTokenRates = () => jotai.useAtomValue(tokenRatesAtom);
 const useTokenRate = tokenId => useTokenRates()[tokenId ?? ""] ?? undefined;
 
+const cryptoWaitReadyAtom = jotai.atom(async () => await utilCrypto.cryptoWaitReady());
+
 const BalancesProvider = ({
-  balanceModules,
-  onfinalityApiKey,
   coinsApiUrl,
   withTestnets,
   enabledChains,
   enabledTokens,
   children
 }) => {
-  const setBalanceModules = jotai.useSetAtom(balanceModuleCreatorsAtom);
-  react.useEffect(() => {
-    if (balanceModules !== undefined) setBalanceModules(balanceModules);
-  }, [balanceModules, setBalanceModules]);
-  const setOnfinalityApiKey = jotai.useSetAtom(onfinalityApiKeyAtom);
-  react.useEffect(() => {
-    setOnfinalityApiKey(onfinalityApiKey);
-  }, [onfinalityApiKey, setOnfinalityApiKey]);
   const setCoinsApiConfig = jotai.useSetAtom(coinsApiConfigAtom);
   react.useEffect(() => {
     setCoinsApiConfig({
@@ -608,71 +311,54 @@ const BalancesProvider = ({
 
 Object.defineProperty(exports, "evmErc20TokenId", {
   enumerable: true,
-  get: function () { return balances.evmErc20TokenId; }
+  get: function () { return chaindataProvider.evmErc20TokenId; }
 });
 Object.defineProperty(exports, "evmNativeTokenId", {
   enumerable: true,
-  get: function () { return balances.evmNativeTokenId; }
+  get: function () { return chaindataProvider.evmNativeTokenId; }
 });
 Object.defineProperty(exports, "subAssetTokenId", {
   enumerable: true,
-  get: function () { return balances.subAssetTokenId; }
-});
-Object.defineProperty(exports, "subEquilibriumTokenId", {
-  enumerable: true,
-  get: function () { return balances.subEquilibriumTokenId; }
+  get: function () { return chaindataProvider.subAssetTokenId; }
 });
 Object.defineProperty(exports, "subNativeTokenId", {
   enumerable: true,
-  get: function () { return balances.subNativeTokenId; }
+  get: function () { return chaindataProvider.subNativeTokenId; }
 });
 Object.defineProperty(exports, "subPsp22TokenId", {
   enumerable: true,
-  get: function () { return balances.subPsp22TokenId; }
+  get: function () { return chaindataProvider.subPsp22TokenId; }
 });
 Object.defineProperty(exports, "subTokensTokenId", {
   enumerable: true,
-  get: function () { return balances.subTokensTokenId; }
+  get: function () { return chaindataProvider.subTokensTokenId; }
 });
 exports.BalancesProvider = BalancesProvider;
 exports.allAddressesAtom = allAddressesAtom;
-exports.allBalancesAtom = allBalancesAtom;
-exports.balanceModuleCreatorsAtom = balanceModuleCreatorsAtom;
-exports.balanceModulesAtom = balanceModulesAtom;
-exports.balancesPersistBackendAtom = balancesPersistBackendAtom;
+exports.balancesAtom = balancesAtom;
 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.miniMetadataHydratedAtom = miniMetadataHydratedAtom;
-exports.miniMetadatasAtom = miniMetadatasAtom;
-exports.onfinalityApiKeyAtom = onfinalityApiKeyAtom;
+exports.networksAtom = networksAtom;
 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.useChains = useChains;
-exports.useChainsByGenesisHash = useChainsByGenesisHash;
-exports.useEvmNetwork = useEvmNetwork;
-exports.useEvmNetworks = useEvmNetworks;
-exports.useMiniMetadatas = useMiniMetadatas;
+exports.useNetwork = useNetwork;
+exports.useNetworks = useNetworks;
+exports.useNetworksById = useNetworksById;
 exports.useSetBalancesAddresses = useSetBalancesAddresses;
 exports.useToken = useToken;
 exports.useTokenRate = useTokenRate;
 exports.useTokenRates = useTokenRates;
 exports.useTokens = useTokens;
+exports.useTokensById = useTokensById;