@talismn/balances-react 0.0.0-pr2080-20250710073919 → 0.0.0-pr2091-20250715125148

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

@@ -1,24 +1,23 @@
-import { atom, useSetAtom, useAtom, useAtomValue } from 'jotai';
+import { atom, useSetAtom, useAtomValue } from 'jotai';
 import { useMemo, useEffect } from 'react';
-import { defaultBalanceModules, configureStore, decompress, compress, db, Balances, getBalanceId, balances } 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 { ChaindataProvider } from '@talismn/chaindata-provider';
 export { evmErc20TokenId, evmNativeTokenId, subAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId } from '@talismn/chaindata-provider';
-import { firstThenDebounce, isTruthy, isAbortError, isEthereumAddress } from '@talismn/util';
+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 { ChainConnectorSol } from '@talismn/chain-connector-sol';
 import { connectionMetaDb } from '@talismn/connection-meta';
+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 innerCoinsApiConfigAtom = atom(DEFAULT_COINSAPI_CONFIG);
 const coinsApiConfigAtom = atom(get => get(innerCoinsApiConfigAtom), (_get, set, options) => set(innerCoinsApiConfigAtom, {
   apiUrl: options.apiUrl ?? DEFAULT_COINSAPI_CONFIG.apiUrl
@@ -30,55 +29,6 @@ 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 chaindataProviderAtom = atom(() => {
   return new ChaindataProvider({});
 });
@@ -87,25 +37,52 @@ const chainConnectorsAtom = atom(get => {
   const chaindataProvider = get(chaindataProviderAtom);
   const substrate = new ChainConnector(chaindataProvider, connectionMetaDb);
   const evm = new ChainConnectorEvm(chaindataProvider);
+  const solana = new ChainConnectorSol(chaindataProvider);
   return {
     substrate,
-    evm
+    evm,
+    solana
   };
 });
 
-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 balancesProviderAtom = atom(get => {
+  return new BalancesProvider$1(get(chaindataProviderAtom), get(chainConnectorsAtom)) // TODO pass storage
+  ;
 });
 
+const chaindataAtom = atomWithObservable(get => {
+  return combineLatest({
+    networks: get(chaindataProviderAtom).networks$,
+    tokens: get(chaindataProviderAtom).tokens$
+  }).pipe(firstThenDebounce(1_000));
+});
+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 {
+    networks,
+    tokens
+  };
+});
+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.
  */
@@ -119,54 +96,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).getNetworks$("polkadot").pipe(distinctUntilIsEqual, map(filterTestnets), distinctUntilIsEqual);
-  const chainsById = get(chaindataProviderAtom).getNetworksMapById$("polkadot").pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const chainsByGenesisHash = get(chaindataProviderAtom).getNetworksMapByGenesisHash$().pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const evmNetworks = get(chaindataProviderAtom).getNetworks$("ethereum").pipe(distinctUntilIsEqual, map(filterTestnets), distinctUntilIsEqual);
-  const networks = get(chaindataProviderAtom).getNetworks$().pipe(distinctUntilIsEqual, map(filterTestnets), distinctUntilIsEqual);
-  const evmNetworksById = get(chaindataProviderAtom).getNetworksMapById$("ethereum").pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const networksById = get(chaindataProviderAtom).getNetworksMapById$().pipe(distinctUntilIsEqual, map(filterMapTestnets), distinctUntilIsEqual);
-  const tokens = get(chaindataProviderAtom).tokens$.pipe(distinctUntilIsEqual, map(filterEnabledTokens), distinctUntilIsEqual);
-  const tokensById = get(chaindataProviderAtom).getTokensMapById$().pipe(distinctUntilIsEqual, 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({
-    networks,
-    networksById,
-    chains,
-    chainsById,
-    chainsByGenesisHash,
-    evmNetworks,
-    evmNetworksById,
-    tokens,
-    tokensById,
-    miniMetadatas
-  }).pipe(
-  // debounce to prevent hammering UI with updates
-  firstThenDebounce(1_000), distinctUntilIsEqual);
-});
-
-const cryptoWaitReadyAtom = atom(async () => await cryptoWaitReady());
-
 const tokenRatesAtom = atom(async get => {
   // runs a timer to keep tokenRates up to date
   get(tokenRatesFetcherAtomEffect);
@@ -179,7 +108,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
@@ -187,9 +116,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
@@ -203,15 +132,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);
@@ -230,213 +159,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 [{
-    networksById,
-    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 {
     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(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(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.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 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 (!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 => {
@@ -453,10 +211,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
@@ -493,30 +249,41 @@ 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,
   coinsApiUrl,
   withTestnets,
   enabledChains,
   enabledTokens,
   children
 }) => {
-  const setBalanceModules = useSetAtom(balanceModuleCreatorsAtom);
-  useEffect(() => {
-    if (balanceModules !== undefined) setBalanceModules(balanceModules);
-  }, [balanceModules, setBalanceModules]);
   const setCoinsApiConfig = useSetAtom(coinsApiConfigAtom);
   useEffect(() => {
     setCoinsApiConfig({
@@ -540,4 +307,4 @@ const BalancesProvider = ({
   });
 };
 
-export { BalancesProvider, allAddressesAtom, allBalancesAtom, balanceModuleCreatorsAtom, balanceModulesAtom, balancesPersistBackendAtom, chainConnectorsAtom, chaindataAtom, chaindataProviderAtom, chainsAtom, chainsByGenesisHashAtom, chainsByIdAtom, coinsApiConfigAtom, cryptoWaitReadyAtom, enableTestnetsAtom, enabledChainsAtom, enabledTokensAtom, evmNetworksAtom, evmNetworksByIdAtom, getStaleChains, miniMetadatasAtom, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances-react",
-  "version": "0.0.0-pr2080-20250710073919",
+  "version": "0.0.0-pr2091-20250715125148",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -27,29 +27,30 @@
     "dexie-react-hooks": "^1.1.7",
     "jotai": "~2",
     "jotai-effect": "~1",
-    "lodash": "4.17.21",
+    "lodash-es": "4.17.21",
     "react-use": "^17.5.1",
     "rxjs": "^7.8.1",
-    "@talismn/balances": "0.0.0-pr2080-20250710073919",
-    "@talismn/chain-connector": "0.0.0-pr2080-20250710073919",
-    "@talismn/chain-connector-evm": "0.0.0-pr2080-20250710073919",
-    "@talismn/chaindata-provider": "0.0.0-pr2080-20250710073919",
-    "@talismn/scale": "0.1.2",
-    "@talismn/connection-meta": "0.0.0-pr2080-20250710073919",
-    "@talismn/util": "0.0.0-pr2080-20250710073919",
-    "@talismn/token-rates": "0.0.0-pr2080-20250710073919"
+    "@talismn/balances": "0.0.0-pr2091-20250715125148",
+    "@talismn/chain-connector-evm": "0.0.0-pr2091-20250715125148",
+    "@talismn/chaindata-provider": "0.0.0-pr2091-20250715125148",
+    "@talismn/chain-connector-sol": "0.0.0-pr2091-20250715125148",
+    "@talismn/chain-connector": "0.0.0-pr2091-20250715125148",
+    "@talismn/connection-meta": "0.0.0-pr2091-20250715125148",
+    "@talismn/scale": "0.0.0-pr2091-20250715125148",
+    "@talismn/token-rates": "0.0.0-pr2091-20250715125148",
+    "@talismn/util": "0.0.0-pr2091-20250715125148"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/lodash": "^4.17.12",
+    "@types/lodash-es": "^4.17.12",
     "@types/react": "^18.3.12",
     "eslint": "^8.57.1",
     "jest": "^29.7.0",
     "react": "^18.3.1",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/tsconfig": "0.0.2",
-    "@talismn/eslint-config": "0.0.3"
+    "@talismn/eslint-config": "0.0.3",
+    "@talismn/tsconfig": "0.0.2"
   },
   "peerDependencies": {
     "@polkadot/util-crypto": "*",

package/dist/declarations/src/atoms/balanceModules.d.ts

@@ -1,2 +0,0 @@
-import { AnyBalanceModule } from "@talismn/balances";
-export declare const balanceModulesAtom: import("jotai").Atom<AnyBalanceModule[]>;

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

@@ -1,10 +0,0 @@
-import { BalanceJson } from "@talismn/balances";
-type PersistFn = (balances: BalanceJson[]) => Promise<void>;
-type RetrieveFn = () => Promise<BalanceJson[]>;
-export type BalancesPersistBackend = {
-    persist: PersistFn;
-    retrieve: RetrieveFn;
-};
-export declare const indexedDbBalancesPersistBackend: BalancesPersistBackend;
-export declare const localStorageBalancesPersistBackend: BalancesPersistBackend;
-export {};