@talismn/balances-react 0.9.12 → 1.0.0

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

@@ -1,25 +1,22 @@
-import { atom, useSetAtom, useAtom, useAtomValue } from 'jotai';
+import { atom, useSetAtom, useAtomValue } from 'jotai';
 import { useMemo, useEffect } from 'react';
-import { defaultBalanceModules, configureStore, decompress, compress, MiniMetadataUpdater, EvmTokenFetcher, hydrateChaindataAndMiniMetadata, updateCustomMiniMetadata, updateEvmTokens, db, Balances, getBalanceId, balances } from '@talismn/balances';
-export { evmErc20TokenId, evmNativeTokenId, subAssetTokenId, subEquilibriumTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId } from '@talismn/balances';
-import { DEFAULT_COINSAPI_CONFIG, db as db$1, fetchTokenRates, ALL_CURRENCY_IDS } from '@talismn/token-rates';
+import { DEFAULT_COINSAPI_CONFIG, db, fetchTokenRates, ALL_CURRENCY_IDS } from '@talismn/token-rates';
 import { jsx, Fragment } from 'react/jsx-runtime';
-import { firstThenDebounce, isTruthy, isEthereumAddress } from '@talismn/util';
+import { ChaindataProvider } from '@talismn/chaindata-provider';
+export { evmErc20TokenId, evmNativeTokenId, subAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId } from '@talismn/chaindata-provider';
+import { BalancesProvider as BalancesProvider$1, Balances } from '@talismn/balances';
 import { atomEffect } from 'jotai-effect';
-import { atomWithObservable } from 'jotai/utils';
-import { isEqual as isEqual$1 } from 'lodash';
-import { Observable, distinctUntilChanged, map, combineLatest, BehaviorSubject, debounceTime, firstValueFrom } from 'rxjs';
-import anylogger from 'anylogger';
+import { keyBy, fromPairs } from 'lodash-es';
 import { ChainConnector } from '@talismn/chain-connector';
 import { ChainConnectorEvm } from '@talismn/chain-connector-evm';
 import { connectionMetaDb } from '@talismn/connection-meta';
-import { ChaindataProvider } from '@talismn/chaindata-provider';
-import { cryptoWaitReady } from '@polkadot/util-crypto';
+import { firstThenDebounce, isTruthy, isAbortError } from '@talismn/util';
+import { atomWithObservable } from 'jotai/utils';
+import { combineLatest, Observable, map } from 'rxjs';
 import { liveQuery } from 'dexie';
-import isEqual from 'lodash/isEqual';
+import anylogger from 'anylogger';
+import { cryptoWaitReady } from '@polkadot/util-crypto';
 
-const balanceModuleCreatorsAtom = atom(defaultBalanceModules);
-const onfinalityApiKeyAtom = atom(undefined);
 const innerCoinsApiConfigAtom = atom(DEFAULT_COINSAPI_CONFIG);
 const coinsApiConfigAtom = atom(get => get(innerCoinsApiConfigAtom), (_get, set, options) => set(innerCoinsApiConfigAtom, {
   apiUrl: options.apiUrl ?? DEFAULT_COINSAPI_CONFIG.apiUrl
@@ -31,137 +28,58 @@ const enabledTokensAtom = atom(undefined);
 /** Sets the list of addresses for which token balances will be fetched by the balances subscription */
 const allAddressesAtom = atom([]);
 
-var packageJson = {
-	name: "@talismn/balances-react"};
-
-var log = anylogger(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
-} = configureStore();
-
-/** 
-// Persistence backend for localStorage
-*/
-const localStoragePersist = async balances => {
-  const storedBalances = balances.map(b => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {
-      status,
-      ...rest
-    } = b;
-    return rest;
-  });
-  const deflated = 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 decompress(deflatedBytes).map(b => ({
-      ...b,
-      status: "cache"
-    }));
-  }
-  return [];
-};
-const localStorageBalancesPersistBackend = {
-  persist: localStoragePersist,
-  retrieve: localStorageRetrieve
-};
-
-const cryptoWaitReadyAtom = atom(async () => await cryptoWaitReady());
-
-const chaindataProviderAtom = atom(get => {
-  // runs a timer to keep chaindata hydrated
-  get(chaindataHydrateAtomEffect);
-  return new ChaindataProvider({
-    onfinalityApiKey: get(onfinalityApiKeyAtom)
-  });
+const chaindataProviderAtom = atom(() => {
+  return new ChaindataProvider({});
 });
-const miniMetadataHydratedAtom = atom(false);
 
-/** This atomEffect keeps chaindata hydrated (i.e. up to date with the GitHub repo) */
-const chaindataHydrateAtomEffect = atomEffect((get, set) => {
+const chainConnectorsAtom = 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 hydrateChaindataAndMiniMetadata(chaindataProvider, miniMetadataUpdater);
-      await updateCustomMiniMetadata(chaindataProvider, miniMetadataUpdater);
-      await 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(chaindataProvider, connectionMetaDb);
+  const evm = new 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 = atom(get => {
-  const chainConnectors = get(chainConnectorsAtom);
-  const chaindataProvider = get(chaindataProviderAtom);
-  const balanceModules = get(balanceModulesAtom);
-  return new MiniMetadataUpdater(chainConnectors, chaindataProvider, balanceModules);
+const balancesProviderAtom = atom(get => {
+  return new BalancesProvider$1(get(chaindataProviderAtom), get(chainConnectorsAtom)) // TODO pass storage
+  ;
 });
 
-/** EvmTokenFetcher is a class used for hydrating chaindata */
-const evmTokenFetcherAtom = atom(get => {
-  const chaindataProvider = get(chaindataProviderAtom);
-  const balanceModules = get(balanceModulesAtom);
-  return new EvmTokenFetcher(chaindataProvider, balanceModules);
+const chaindataAtom = atomWithObservable(get => {
+  return combineLatest({
+    networks: get(chaindataProviderAtom).networks$,
+    tokens: get(chaindataProviderAtom).tokens$
+  }).pipe(firstThenDebounce(1_000));
 });
-
-const chainConnectorsAtom = atom(get => {
-  const onfinalityApiKey = get(onfinalityApiKeyAtom);
-  const chaindataProvider = get(chaindataProviderAtom);
-  const substrate = new ChainConnector(chaindataProvider, connectionMetaDb);
-  const evm = new ChainConnectorEvm(chaindataProvider, {
-    onfinalityApiKey
-  });
+const filteredChaindataAtom = 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 = 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 = 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 = atom(async get => {
+  const chaindata = await get(filteredChaindataAtom);
+  return chaindata.tokens;
+});
+const networksAtom = atom(async get => {
+  const chaindata = await get(filteredChaindataAtom);
+  return chaindata.networks;
 });
 
+var packageJson = {
+	name: "@talismn/balances-react"};
+
+var log = anylogger(packageJson.name);
+
 /**
  * Converts a dexie Observable into an rxjs Observable.
  */
@@ -175,48 +93,6 @@ function dexieToRxjs(o) {
   });
 }
 
-const chainsAtom = atom(async get => (await get(chaindataAtom)).chains);
-const chainsByIdAtom = atom(async get => (await get(chaindataAtom)).chainsById);
-const chainsByGenesisHashAtom = atom(async get => (await get(chaindataAtom)).chainsByGenesisHash);
-const evmNetworksAtom = atom(async get => (await get(chaindataAtom)).evmNetworks);
-const evmNetworksByIdAtom = atom(async get => (await get(chaindataAtom)).evmNetworksById);
-const tokensAtom = atom(async get => (await get(chaindataAtom)).tokens);
-const tokensByIdAtom = atom(async get => (await get(chaindataAtom)).tokensById);
-const miniMetadatasAtom = atom(async get => (await get(chaindataAtom)).miniMetadatas);
-const chaindataAtom = 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 = distinctUntilChanged((a, b) => isEqual(a, b));
-  const chains = get(chaindataProviderAtom).chainsObservable.pipe(distinctUntilIsEqual, map(filterTestnets), distinctUntilIsEqual);
-  const chainsById = get(chaindataProviderAtom).chainsByIdObservable.pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const chainsByGenesisHash = get(chaindataProviderAtom).chainsByGenesisHashObservable.pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const evmNetworks = get(chaindataProviderAtom).evmNetworksObservable.pipe(distinctUntilIsEqual, map(filterTestnets), distinctUntilIsEqual);
-  const evmNetworksById = get(chaindataProviderAtom).evmNetworksByIdObservable.pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const tokens = get(chaindataProviderAtom).tokensObservable.pipe(distinctUntilIsEqual, map(filterTestnets), map(filterEnabledTokens), distinctUntilIsEqual);
-  const tokensById = get(chaindataProviderAtom).tokensByIdObservable.pipe(distinctUntilIsEqual, map(filterMapTestnets), map(filterMapEnabledTokens), distinctUntilIsEqual);
-  const miniMetadatasObservable = dexieToRxjs(liveQuery(() => db.miniMetadatas.toArray()));
-  const miniMetadatas = combineLatest([miniMetadatasObservable.pipe(distinctUntilIsEqual), chainsById]).pipe(map(([miniMetadatas, chainsById]) => miniMetadatas.filter(m => chainsById[m.chainId])), distinctUntilIsEqual);
-  return combineLatest({
-    chains,
-    chainsById,
-    chainsByGenesisHash,
-    evmNetworks,
-    evmNetworksById,
-    tokens,
-    tokensById,
-    miniMetadatas
-  }).pipe(
-  // debounce to prevent hammering UI with updates
-  firstThenDebounce(1_000), distinctUntilIsEqual);
-});
-
 const tokenRatesAtom = atom(async get => {
   // runs a timer to keep tokenRates up to date
   get(tokenRatesFetcherAtomEffect);
@@ -229,7 +105,7 @@ const tokenRatesDbAtom = atomWithObservable(() => {
   }) => [tokenId, rates]));
 
   // retrieve fetched tokenRates from the db
-  return dexieToRxjs(liveQuery(() => db$1.tokenRates.toArray())).pipe(map(dbRatesToMap));
+  return dexieToRxjs(liveQuery(() => db.tokenRates.toArray())).pipe(map(dbRatesToMap));
 });
 const tokenRatesFetcherAtomEffect = atomEffect(get => {
   // lets us tear down the existing timer when the effect is restarted
@@ -237,9 +113,9 @@ const tokenRatesFetcherAtomEffect = 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 = 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
@@ -253,15 +129,15 @@ const tokenRatesFetcherAtomEffect = atomEffect(get => {
           rates
         }));
         if (abort.signal.aborted) return; // don't insert into db if aborted
-        await db$1.transaction("rw", db$1.tokenRates, async () => {
+        await db.transaction("rw", db.tokenRates, async () => {
           // override all tokenRates
-          await db$1.tokenRates.bulkPut(putTokenRates);
+          await db.tokenRates.bulkPut(putTokenRates);
 
           // delete tokenRates for tokens which no longer exist
           const validTokenIds = new Set(tokenIds);
-          const tokenRatesIds = await db$1.tokenRates.toCollection().primaryKeys();
+          const tokenRatesIds = await db.tokenRates.toCollection().primaryKeys();
           const deleteIds = tokenRatesIds.filter(id => !validTokenIds.has(id));
-          if (deleteIds.length > 0) await db$1.tokenRates.bulkDelete(deleteIds);
+          if (deleteIds.length > 0) await db.tokenRates.bulkDelete(deleteIds);
         });
         if (abort.signal.aborted) return; // don't schedule next loop if aborted
         setTimeout(hydrate, loopMs);
@@ -269,7 +145,7 @@ const tokenRatesFetcherAtomEffect = 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(isTruthy);
         log.error(messageParts.join(", "), error);
-        if (abort.signal.aborted) return; // don't schedule retry if aborted
+        if (isAbortError(error)) return; // don't schedule retry if aborted
         setTimeout(hydrate, retryTimeout);
       }
     };
@@ -280,218 +156,42 @@ const tokenRatesFetcherAtomEffect = atomEffect(get => {
   return () => abort.abort("Unsubscribed");
 });
 
-const allBalancesAtom = atom(async get => {
-  // set up our subscription to fetch balances from the various blockchains
-  get(balancesSubscriptionAtomEffect);
-  const [balances, hydrateData] = await Promise.all([get(balancesObservableAtom), get(balancesHydrateDataAtom)]);
-  return new Balances(Object.values(balances).filter(balance => !!hydrateData?.tokens?.[balance.tokenId]),
-  // hydrate balance chains, evmNetworks, tokens and tokenRates
-  hydrateData);
+const addressesByTokenIdAtom = atom(async get => {
+  const [tokens, addresses] = await Promise.all([get(tokensAtom), get(allAddressesAtom)]);
+  return fromPairs(tokens.map(token => [token.id, addresses]));
 });
-const balancesObservable = new BehaviorSubject({});
-const balancesObservableAtom = atomWithObservable(() => balancesObservable);
-const balancesPersistBackendAtom = atom(localStorageBalancesPersistBackend);
-const hydrateBalancesObservableAtom = atom(async get => {
-  const persistBackend = get(balancesPersistBackendAtom);
-  const balances = await persistBackend.retrieve();
-  balancesObservable.next(Object.fromEntries(balances.map(b => [getBalanceId(b), {
-    ...b,
-    status: "cache"
-  }])));
+const rawBalancesAtom = atom([]);
+const subscribeBalancesAtom = 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 = 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 = keyBy(chaindata.networks, "id");
+  const tokensById = keyBy(chaindata.tokens, "id");
   return {
-    chains: chainsById,
-    evmNetworks: evmNetworksById,
+    networks: networksById,
     tokens: tokensById,
     tokenRates
   };
 });
-const balancesSubscriptionAtomEffect = 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(debounceTime(10000)).subscribe(balancesUpdate => {
-      persistBackend.persist(Object.values(balancesUpdate));
-    });
-    const updateBalances = async balancesUpdates => {
-      if (abort.signal.aborted) return;
-      const updatesWithIds = new 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 = !isEqual$1(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(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 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 (!isEthereumAddress(balance.address)) {
-        if (!hasChain) return true;
-        if (chainUsesSecp256k1Accounts) return true;
-      }
-      if (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(map(val => Object.values(val).filter(({
-        status
-      }) => status === "cache").map(balance => ({
-        ...balance,
-        status: "stale"
-      }))));
-      firstValueFrom(staleObservable).then(v => {
-        if (v.length) updateBalances(v);
-      });
-    }, 30_000);
-    return balanceModules.map(balanceModule => {
-      const unsub = 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(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"
-            }))));
-            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 = 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(rawBalances, hydrate);
 });
 
 const useSetBalancesAddresses = addresses => {
@@ -508,10 +208,8 @@ const useSetBalancesAddresses = addresses => {
  * @returns a Balances object containing the current balances state.
  */
 
-const useBalances = persistBackend => {
-  const [, setPersistBackend] = useAtom(balancesPersistBackendAtom);
-  if (persistBackend) setPersistBackend(persistBackend);
-  return useAtomValue(allBalancesAtom);
+const useBalances = () => {
+  return useAtomValue(balancesAtom);
 };
 
 // TODO: Extract to shared definition between extension and @talismn/balances-react
@@ -542,41 +240,47 @@ const useBalancesStatus = balances => 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 = () => useAtomValue(chainConnectorsAtom);
 
 const useChaindataProvider = () => useAtomValue(chaindataProviderAtom);
 const useChaindata = () => useAtomValue(chaindataAtom);
-const useChains = () => useAtomValue(chainsByIdAtom);
-const useChainsByGenesisHash = () => useAtomValue(chainsByGenesisHashAtom);
-const useEvmNetworks = () => useAtomValue(evmNetworksByIdAtom);
-const useTokens = () => useAtomValue(tokensByIdAtom);
-const useMiniMetadatas = () => 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 useMemo(() => 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 useMemo(() => keyBy(tokens, t => t.id), [tokens]);
+};
+const useToken = tokenId => {
+  const tokensById = useTokensById();
+  return tokensById[tokenId ?? ""] ?? null;
+};
 
 const useTokenRates = () => useAtomValue(tokenRatesAtom);
 const useTokenRate = tokenId => useTokenRates()[tokenId ?? ""] ?? undefined;
 
+const cryptoWaitReadyAtom = atom(async () => await cryptoWaitReady());
+
 const BalancesProvider = ({
-  balanceModules,
-  onfinalityApiKey,
   coinsApiUrl,
   withTestnets,
   enabledChains,
   enabledTokens,
   children
 }) => {
-  const setBalanceModules = useSetAtom(balanceModuleCreatorsAtom);
-  useEffect(() => {
-    if (balanceModules !== undefined) setBalanceModules(balanceModules);
-  }, [balanceModules, setBalanceModules]);
-  const setOnfinalityApiKey = useSetAtom(onfinalityApiKeyAtom);
-  useEffect(() => {
-    setOnfinalityApiKey(onfinalityApiKey);
-  }, [onfinalityApiKey, setOnfinalityApiKey]);
   const setCoinsApiConfig = useSetAtom(coinsApiConfigAtom);
   useEffect(() => {
     setCoinsApiConfig({
@@ -600,4 +304,4 @@ const BalancesProvider = ({
   });
 };
 
-export { BalancesProvider, allAddressesAtom, allBalancesAtom, balanceModuleCreatorsAtom, balanceModulesAtom, balancesPersistBackendAtom, chainConnectorsAtom, chaindataAtom, chaindataProviderAtom, chainsAtom, chainsByGenesisHashAtom, chainsByIdAtom, coinsApiConfigAtom, cryptoWaitReadyAtom, enableTestnetsAtom, enabledChainsAtom, enabledTokensAtom, evmNetworksAtom, evmNetworksByIdAtom, getStaleChains, miniMetadataHydratedAtom, miniMetadatasAtom, onfinalityApiKeyAtom, tokenRatesAtom, tokensAtom, tokensByIdAtom, useBalances, useBalancesStatus, useChain, useChainConnectors, useChaindata, useChaindataProvider, useChains, useChainsByGenesisHash, useEvmNetwork, useEvmNetworks, useMiniMetadatas, useSetBalancesAddresses, useToken, useTokenRate, useTokenRates, useTokens };
+export { BalancesProvider, allAddressesAtom, balancesAtom, chainConnectorsAtom, chaindataAtom, chaindataProviderAtom, coinsApiConfigAtom, cryptoWaitReadyAtom, enableTestnetsAtom, enabledChainsAtom, enabledTokensAtom, getStaleChains, networksAtom, tokenRatesAtom, tokensAtom, useBalances, useBalancesStatus, useChainConnectors, useChaindata, useChaindataProvider, useNetwork, useNetworks, useNetworksById, useSetBalancesAddresses, useToken, useTokenRate, useTokenRates, useTokens, useTokensById };