@talismn/balances-react 0.0.0-pr2075-20250708160640 → 0.0.0-pr2075-20250709134044

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 { 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, db, Balances } from '@talismn/balances';
 import { firstThenDebounce, isTruthy, isAbortError, isEthereumAddress } from '@talismn/util';
 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 { fromPairs, isEqual as isEqual$1 } from 'lodash';
+import { Observable, distinctUntilChanged, map, combineLatest, BehaviorSubject, firstValueFrom } from 'rxjs';
 import { ChainConnector } from '@talismn/chain-connector';
 import { ChainConnectorEvm } from '@talismn/chain-connector-evm';
 import { connectionMetaDb } from '@talismn/connection-meta';
 import { liveQuery } from 'dexie';
 import isEqual from 'lodash/isEqual';
 import { cryptoWaitReady } from '@polkadot/util-crypto';
+import anylogger from 'anylogger';
 
-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({});
 });
@@ -93,17 +43,9 @@ const chainConnectorsAtom = atom(get => {
   };
 });
 
-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
+  ;
 });
 
 /**
@@ -167,6 +109,11 @@ const chaindataAtom = atomWithObservable(get => {
 
 const cryptoWaitReadyAtom = atom(async () => await cryptoWaitReady());
 
+var packageJson = {
+	name: "@talismn/balances-react"};
+
+var log = anylogger(packageJson.name);
+
 const tokenRatesAtom = atom(async get => {
   // runs a timer to keep tokenRates up to date
   get(tokenRatesFetcherAtomEffect);
@@ -240,14 +187,20 @@ const allBalancesAtom = atom(async get => {
 });
 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"
-  }])));
+
+// export const balancesPersistBackendAtom = atom<BalancesPersistBackend>(
+//   localStorageBalancesPersistBackend,
+// )
+
+const hydrateBalancesObservableAtom = atom(async () => {
+  // const persistBackend = get(balancesPersistBackendAtom)
+  // const balances = await persistBackend.retrieve()
+
+  balancesObservable.next({}
+  // Object.fromEntries(
+  //   balances.map((b) => [getBalanceId(b), { ...b, status: "cache" } as BalanceJson]),
+  // ),
+  );
 });
 const balancesHydrateDataAtom = atom(async get => {
   const [{
@@ -266,16 +219,21 @@ const balancesSubscriptionAtomEffect = atomEffect(get => {
 
   // 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 atomDependencies = Promise.all([get(cryptoWaitReadyAtom),
+  // get(balanceModulesAtom), // TODO yeet
+  get(balancesProviderAtom), 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;
+    const [_cryptoReady, balancesProvider, 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));
-    });
+    // 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);
@@ -329,6 +287,7 @@ const balancesSubscriptionAtomEffect = atomEffect(get => {
         return isEthereumAddress(address) ? token.networkId || chainsById[token.networkId ?? ""]?.account === "secp256k1" : token.networkId && chainsById[token.networkId ?? ""]?.account !== "secp256k1";
       });
     });
+    const addressesByTokenId = fromPairs(enabledTokenIds.map(tokenId => [tokenId, allAddresses]));
 
     // Delete invalid cached balances
     const chainIds = new Set(chains.map(chain => chain.id));
@@ -344,7 +303,7 @@ const balancesSubscriptionAtomEffect = atomEffect(get => {
       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;
+      // 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)
@@ -381,62 +340,96 @@ const balancesSubscriptionAtomEffect = atomEffect(get => {
         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());
+    const sub = balancesProvider.getBalances$(addressesByTokenId).subscribe(balances => {
+      updateBalances(balances.balances);
     });
+    return () => {
+      sub.unsubscribe();
+    };
+
+    // return balanceModules.map((balanceModule) => {
+    //   const unsub = balancesFn(
+    //     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" }) as BalanceJson),
+    //             ),
+    //           )
+
+    //           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 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")
+
+  return () => {
+    unsubsPromise.then(unsub => {
+      unsub?.();
+      //console.log("unsubscribed")
+    });
+  };
 });
 
 const useSetBalancesAddresses = addresses => {
@@ -453,9 +446,7 @@ const useSetBalancesAddresses = addresses => {
  * @returns a Balances object containing the current balances state.
  */
 
-const useBalances = persistBackend => {
-  const [, setPersistBackend] = useAtom(balancesPersistBackendAtom);
-  if (persistBackend) setPersistBackend(persistBackend);
+const useBalances = () => {
   return useAtomValue(allBalancesAtom);
 };
 
@@ -506,17 +497,12 @@ const useTokenRates = () => useAtomValue(tokenRatesAtom);
 const useTokenRate = tokenId => useTokenRates()[tokenId ?? ""] ?? undefined;
 
 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 +526,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, allBalancesAtom, 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-20250708160640",
+  "version": "0.0.0-pr2075-20250709134044",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -30,14 +30,14 @@
     "lodash": "4.17.21",
     "react-use": "^17.5.1",
     "rxjs": "^7.8.1",
-    "@talismn/balances": "0.0.0-pr2075-20250708160640",
-    "@talismn/chain-connector": "0.0.0-pr2075-20250708160640",
-    "@talismn/chaindata-provider": "0.0.0-pr2075-20250708160640",
-    "@talismn/scale": "0.0.0-pr2075-20250708160640",
-    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250708160640",
-    "@talismn/connection-meta": "0.0.0-pr2075-20250708160640",
-    "@talismn/util": "0.0.0-pr2075-20250708160640",
-    "@talismn/token-rates": "0.0.0-pr2075-20250708160640"
+    "@talismn/chain-connector": "0.0.0-pr2075-20250709134044",
+    "@talismn/balances": "0.0.0-pr2075-20250709134044",
+    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250709134044",
+    "@talismn/chaindata-provider": "0.0.0-pr2075-20250709134044",
+    "@talismn/scale": "0.0.0-pr2075-20250709134044",
+    "@talismn/connection-meta": "0.0.0-pr2075-20250709134044",
+    "@talismn/token-rates": "0.0.0-pr2075-20250709134044",
+    "@talismn/util": "0.0.0-pr2075-20250709134044"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
@@ -48,8 +48,8 @@
     "react": "^18.3.1",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/eslint-config": "0.0.3",
-    "@talismn/tsconfig": "0.0.2"
+    "@talismn/tsconfig": "0.0.2",
+    "@talismn/eslint-config": "0.0.3"
   },
   "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 {};