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

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

@@ -1,22 +1,24 @@
-import { atom, useSetAtom, useAtomValue } from 'jotai';
+import { atom, useSetAtom, useAtom, useAtomValue } from 'jotai';
 import { useMemo, useEffect } from 'react';
-import { DEFAULT_COINSAPI_CONFIG, db, fetchTokenRates, ALL_CURRENCY_IDS } from '@talismn/token-rates';
+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 { jsx, Fragment } from 'react/jsx-runtime';
 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 { firstThenDebounce, isTruthy, isAbortError, isEthereumAddress } from '@talismn/util';
 import { atomEffect } from 'jotai-effect';
-import { keyBy, fromPairs } from 'lodash-es';
+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 { ChainConnector } from '@talismn/chain-connector';
 import { ChainConnectorEvm } from '@talismn/chain-connector-evm';
 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 anylogger from 'anylogger';
+import isEqual from 'lodash/isEqual';
 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
@@ -28,6 +30,55 @@ 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({});
 });
@@ -42,44 +93,19 @@ const chainConnectorsAtom = atom(get => {
   };
 });
 
-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;
+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
+  }));
 });
 
-var packageJson = {
-	name: "@talismn/balances-react"};
-
-var log = anylogger(packageJson.name);
-
 /**
  * Converts a dexie Observable into an rxjs Observable.
  */
@@ -93,6 +119,54 @@ 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);
@@ -105,7 +179,7 @@ const tokenRatesDbAtom = atomWithObservable(() => {
   }) => [tokenId, rates]));
 
   // retrieve fetched tokenRates from the db
-  return dexieToRxjs(liveQuery(() => db.tokenRates.toArray())).pipe(map(dbRatesToMap));
+  return dexieToRxjs(liveQuery(() => db$1.tokenRates.toArray())).pipe(map(dbRatesToMap));
 });
 const tokenRatesFetcherAtomEffect = atomEffect(get => {
   // lets us tear down the existing timer when the effect is restarted
@@ -113,9 +187,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 tokensPromise = get(tokensAtom);
+  const tokensByIdPromise = get(tokensByIdAtom);
   (async () => {
-    const tokensById = keyBy(await tokensPromise, "id");
+    const tokensById = await tokensByIdPromise;
     const tokenIds = Object.keys(tokensById);
     const loopMs = 300_000; // 300_000ms = 300s = 5 minutes
     const retryTimeout = 5_000; // 5_000ms = 5 seconds
@@ -129,15 +203,15 @@ const tokenRatesFetcherAtomEffect = atomEffect(get => {
           rates
         }));
         if (abort.signal.aborted) return; // don't insert into db if aborted
-        await db.transaction("rw", db.tokenRates, async () => {
+        await db$1.transaction("rw", db$1.tokenRates, async () => {
           // override all tokenRates
-          await db.tokenRates.bulkPut(putTokenRates);
+          await db$1.tokenRates.bulkPut(putTokenRates);
 
           // delete tokenRates for tokens which no longer exist
           const validTokenIds = new Set(tokenIds);
-          const tokenRatesIds = await db.tokenRates.toCollection().primaryKeys();
+          const tokenRatesIds = await db$1.tokenRates.toCollection().primaryKeys();
           const deleteIds = tokenRatesIds.filter(id => !validTokenIds.has(id));
-          if (deleteIds.length > 0) await db.tokenRates.bulkDelete(deleteIds);
+          if (deleteIds.length > 0) await db$1.tokenRates.bulkDelete(deleteIds);
         });
         if (abort.signal.aborted) return; // don't schedule next loop if aborted
         setTimeout(hydrate, loopMs);
@@ -156,42 +230,213 @@ const tokenRatesFetcherAtomEffect = atomEffect(get => {
   return () => abort.abort("Unsubscribed");
 });
 
-const addressesByTokenIdAtom = atom(async get => {
-  const [tokens, addresses] = await Promise.all([get(tokensAtom), get(allAddressesAtom)]);
-  return fromPairs(tokens.map(token => [token.id, addresses]));
+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 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 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 balancesHydrateDataAtom = atom(async get => {
-  const [chaindata, tokenRates] = await Promise.all([get(chaindataAtom), get(tokenRatesAtom)]);
-  const networksById = keyBy(chaindata.networks, "id");
-  const tokensById = keyBy(chaindata.tokens, "id");
+  const [{
+    networksById,
+    tokensById
+  }, tokenRates] = await Promise.all([get(chaindataAtom), get(tokenRatesAtom)]);
   return {
     networks: networksById,
     tokens: tokensById,
     tokenRates
   };
 });
-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 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 useSetBalancesAddresses = addresses => {
@@ -208,8 +453,10 @@ const useSetBalancesAddresses = addresses => {
  * @returns a Balances object containing the current balances state.
  */
 
-const useBalances = () => {
-  return useAtomValue(balancesAtom);
+const useBalances = persistBackend => {
+  const [, setPersistBackend] = useAtom(balancesPersistBackendAtom);
+  if (persistBackend) setPersistBackend(persistBackend);
+  return useAtomValue(allBalancesAtom);
 };
 
 // TODO: Extract to shared definition between extension and @talismn/balances-react
@@ -246,41 +493,30 @@ const useChainConnectors = () => useAtomValue(chainConnectorsAtom);
 
 const useChaindataProvider = () => useAtomValue(chaindataProviderAtom);
 const useChaindata = () => useAtomValue(chaindataAtom);
-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 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 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({
@@ -304,4 +540,4 @@ const BalancesProvider = ({
   });
 };
 
-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 };
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances-react",
-  "version": "0.0.0-pr2075-20250710142256",
+  "version": "0.0.0-pr2076-20250703120513",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -27,21 +27,21 @@
     "dexie-react-hooks": "^1.1.7",
     "jotai": "~2",
     "jotai-effect": "~1",
-    "lodash-es": "4.17.21",
+    "lodash": "4.17.21",
     "react-use": "^17.5.1",
     "rxjs": "^7.8.1",
-    "@talismn/balances": "0.0.0-pr2075-20250710142256",
-    "@talismn/chaindata-provider": "0.0.0-pr2075-20250710142256",
-    "@talismn/chain-connector": "0.0.0-pr2075-20250710142256",
-    "@talismn/connection-meta": "0.0.0-pr2075-20250710142256",
-    "@talismn/scale": "0.0.0-pr2075-20250710142256",
-    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250710142256",
-    "@talismn/token-rates": "0.0.0-pr2075-20250710142256",
-    "@talismn/util": "0.0.0-pr2075-20250710142256"
+    "@talismn/balances": "0.0.0-pr2076-20250703120513",
+    "@talismn/chain-connector-evm": "0.0.0-pr2076-20250703120513",
+    "@talismn/chain-connector": "0.0.0-pr2076-20250703120513",
+    "@talismn/token-rates": "0.0.0-pr2076-20250703120513",
+    "@talismn/connection-meta": "0.0.0-pr2076-20250703120513",
+    "@talismn/scale": "0.1.2",
+    "@talismn/util": "0.0.0-pr2076-20250703120513",
+    "@talismn/chaindata-provider": "0.0.0-pr2076-20250703120513"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/lodash-es": "^4.17.12",
+    "@types/lodash": "^4.17.12",
     "@types/react": "^18.3.12",
     "eslint": "^8.57.1",
     "jest": "^29.7.0",

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

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