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

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

@@ -1,6 +1,2 @@
 import { Balances } from "@talismn/balances";
-import { BalancesPersistBackend } from "../util/balancesPersist";
 export declare const allBalancesAtom: import("jotai").Atom<Promise<Balances>>;
-export declare const balancesPersistBackendAtom: import("jotai").PrimitiveAtom<BalancesPersistBackend> & {
-    init: BalancesPersistBackend;
-};

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

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

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

@@ -530,7 +530,15 @@ export declare const tokensByIdAtom: import("jotai").Atom<Promise<{
         mirrorOf?: string | undefined;
     };
 }>>;
-export declare const miniMetadatasAtom: import("jotai").Atom<Promise<import("@talismn/balances").MiniMetadata[]>>;
+export declare const miniMetadatasAtom: import("jotai").Atom<Promise<{
+    id: string;
+    source: string;
+    chainId: string;
+    specVersion: number;
+    version: string;
+    data: `0x${string}` | null;
+    extra: any;
+}[]>>;
 export declare const chaindataAtom: import("jotai").Atom<{
     networks: ({
         id: string;
@@ -1246,7 +1254,15 @@ export declare const chaindataAtom: import("jotai").Atom<{
             mirrorOf?: string | undefined;
         };
     };
-    miniMetadatas: import("@talismn/balances").MiniMetadata[];
+    miniMetadatas: {
+        id: string;
+        source: string;
+        chainId: string;
+        specVersion: number;
+        version: string;
+        data: `0x${string}` | null;
+        extra: any;
+    }[];
 } | Promise<{
     networks: ({
         id: string;
@@ -1962,5 +1978,13 @@ export declare const chaindataAtom: import("jotai").Atom<{
             mirrorOf?: string | undefined;
         };
     };
-    miniMetadatas: import("@talismn/balances").MiniMetadata[];
+    miniMetadatas: {
+        id: string;
+        source: string;
+        chainId: string;
+        specVersion: number;
+        version: string;
+        data: `0x${string}` | null;
+        extra: any;
+    }[];
 }>>;

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

@@ -1,8 +1,4 @@
-import { AnyBalanceModule, Hydrate } from "@talismn/balances";
 import { CoinsApiConfig } from "@talismn/token-rates";
-export declare const balanceModuleCreatorsAtom: import("jotai").PrimitiveAtom<((hydrate: Hydrate) => AnyBalanceModule)[]> & {
-    init: ((hydrate: Hydrate) => AnyBalanceModule)[];
-};
 export declare const coinsApiConfigAtom: import("jotai").WritableAtom<CoinsApiConfig, [Partial<CoinsApiConfig>], void>;
 export declare const enableTestnetsAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;

package/dist/declarations/src/hooks/useBalances.d.ts

@@ -1,5 +1,4 @@
 import { Balances } from "@talismn/balances";
-import { BalancesPersistBackend } from "../util/balancesPersist";
 export declare const useSetBalancesAddresses: (addresses: string[]) => void;
 /**
  * @name useBalances
@@ -7,7 +6,7 @@ export declare const useSetBalancesAddresses: (addresses: string[]) => void;
  * @param persistBackend an optional BalancesPersistBackend backend to use for persisting the balances state. By default, indexedDB is used.
  * @returns a Balances object containing the current balances state.
  */
-export declare const useBalances: (persistBackend?: BalancesPersistBackend) => Balances;
+export declare const useBalances: () => Balances;
 export type BalancesStatus = {
     status: "live";
 } | {

package/dist/declarations/src/hooks/useChaindata.d.ts

@@ -715,7 +715,15 @@ export declare const useChaindata: () => {
             mirrorOf?: string | undefined;
         };
     };
-    miniMetadatas: import("@talismn/balances").MiniMetadata[];
+    miniMetadatas: {
+        id: string;
+        source: string;
+        chainId: string;
+        specVersion: number;
+        version: string;
+        data: `0x${string}` | null;
+        extra: any;
+    }[];
 };
 export declare const useChains: () => Record<string, {
     id: string;
@@ -1012,7 +1020,15 @@ export declare const useTokens: () => {
         mirrorOf?: string | undefined;
     };
 };
-export declare const useMiniMetadatas: () => import("@talismn/balances").MiniMetadata[];
+export declare const useMiniMetadatas: () => {
+    id: string;
+    source: string;
+    chainId: string;
+    specVersion: number;
+    version: string;
+    data: `0x${string}` | null;
+    extra: any;
+}[];
 export declare const useChain: (chainId?: DotNetworkId) => {
     id: string;
     name: string;

package/dist/declarations/src/index.d.ts

@@ -1,12 +1,10 @@
-import { AnyBalanceModule, Hydrate } from "@talismn/balances";
 import { ReactNode } from "react";
-export { evmErc20TokenId, evmNativeTokenId, subNativeTokenId, subAssetTokenId, subPsp22TokenId, subTokensTokenId, } from "@talismn/chaindata-provider";
+export { evmErc20TokenId, evmNativeTokenId, subAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId, } from "@talismn/chaindata-provider";
 export * from "./hooks/useBalances";
 export * from "./hooks/useChainConnectors";
 export * from "./hooks/useChaindata";
 export * from "./hooks/useTokenRates";
 export * from "./atoms/allAddresses";
-export * from "./atoms/balanceModules";
 export * from "./atoms/balances";
 export * from "./atoms/chainConnectors";
 export * from "./atoms/chaindata";
@@ -15,10 +13,6 @@ export * from "./atoms/config";
 export * from "./atoms/cryptoWaitReady";
 export * from "./atoms/tokenRates";
 export type BalancesConfig = {
-    /**
-     * Optionally provide your own array of BalanceModules, when you don't want to use the defaults.
-     */
-    balanceModules?: Array<(hydrate: Hydrate) => AnyBalanceModule>;
     coinsApiUrl?: string;
     /** Enables balances fetching for tokens on testnet chains. */
     withTestnets?: boolean;
@@ -71,4 +65,4 @@ export type BalancesConfig = {
     enabledTokens?: string[];
     children?: ReactNode;
 };
-export declare const BalancesProvider: ({ balanceModules, coinsApiUrl, withTestnets, enabledChains, enabledTokens, children, }: BalancesConfig) => import("react/jsx-runtime").JSX.Element;
+export declare const BalancesProvider: ({ coinsApiUrl, withTestnets, enabledChains, enabledTokens, children, }: BalancesConfig) => import("react/jsx-runtime").JSX.Element;

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

@@ -2,29 +2,28 @@
 
 var jotai = require('jotai');
 var react = require('react');
-var balances = require('@talismn/balances');
 var tokenRates = require('@talismn/token-rates');
 var jsxRuntime = require('react/jsx-runtime');
 var chaindataProvider = require('@talismn/chaindata-provider');
+var balances = require('@talismn/balances');
 var util = require('@talismn/util');
 var jotaiEffect = require('jotai-effect');
 var utils = require('jotai/utils');
 var lodash = require('lodash');
 var rxjs = require('rxjs');
-var anylogger = require('anylogger');
 var chainConnector = require('@talismn/chain-connector');
 var chainConnectorEvm = require('@talismn/chain-connector-evm');
 var connectionMeta = require('@talismn/connection-meta');
 var dexie = require('dexie');
 var isEqual = require('lodash/isEqual');
 var utilCrypto = require('@polkadot/util-crypto');
+var anylogger = require('anylogger');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
 var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
+var anylogger__default = /*#__PURE__*/_interopDefault(anylogger);
 
-const balanceModuleCreatorsAtom = jotai.atom(balances.defaultBalanceModules);
 const innerCoinsApiConfigAtom = jotai.atom(tokenRates.DEFAULT_COINSAPI_CONFIG);
 const coinsApiConfigAtom = jotai.atom(get => get(innerCoinsApiConfigAtom), (_get, set, options) => set(innerCoinsApiConfigAtom, {
   apiUrl: options.apiUrl ?? tokenRates.DEFAULT_COINSAPI_CONFIG.apiUrl
@@ -36,55 +35,6 @@ const enabledTokensAtom = jotai.atom(undefined);
 /** Sets the list of addresses for which token balances will be fetched by the balances subscription */
 const allAddressesAtom = jotai.atom([]);
 
-var packageJson = {
-	name: "@talismn/balances-react"};
-
-var log = anylogger__default.default(packageJson.name);
-
-/** 
-// Persistence backend for indexedDB
-// Add a new backend by implementing the BalancesPersistBackend interface
-// configureStore can be called with a different indexedDB table
-*/
-const {
-  persistData,
-  retrieveData
-} = balances.configureStore();
-
-/** 
-// Persistence backend for localStorage
-*/
-const localStoragePersist = async balances$1 => {
-  const storedBalances = balances$1.map(b => {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const {
-      status,
-      ...rest
-    } = b;
-    return rest;
-  });
-  const deflated = balances.compress(storedBalances);
-  localStorage.setItem("talismanBalances", deflated.toString());
-};
-const localStorageRetrieve = async () => {
-  const deflated = localStorage.getItem("talismanBalances");
-  if (deflated) {
-    // deflated will be a long string of numbers separated by commas
-    const deflatedArray = deflated.split(",").map(n => parseInt(n, 10));
-    const deflatedBytes = new Uint8Array(deflatedArray.length);
-    deflatedArray.forEach((n, i) => deflatedBytes[i] = n);
-    return balances.decompress(deflatedBytes).map(b => ({
-      ...b,
-      status: "cache"
-    }));
-  }
-  return [];
-};
-const localStorageBalancesPersistBackend = {
-  persist: localStoragePersist,
-  retrieve: localStorageRetrieve
-};
-
 const chaindataProviderAtom = jotai.atom(() => {
   return new chaindataProvider.ChaindataProvider({});
 });
@@ -99,17 +49,9 @@ const chainConnectorsAtom = jotai.atom(get => {
   };
 });
 
-const balanceModulesAtom = jotai.atom(get => {
-  const balanceModuleCreators = get(balanceModuleCreatorsAtom);
-  const chainConnectors = get(chainConnectorsAtom);
-  const chaindataProvider = get(chaindataProviderAtom);
-  if (!chainConnectors.substrate) return [];
-  if (!chainConnectors.evm) return [];
-  if (!chaindataProvider) return [];
-  return balanceModuleCreators.map(mod => mod({
-    chainConnectors,
-    chaindataProvider
-  }));
+const balancesProviderAtom = jotai.atom(get => {
+  return new balances.BalancesProvider(get(chaindataProviderAtom), get(chainConnectorsAtom)) // TODO pass storage
+  ;
 });
 
 /**
@@ -173,6 +115,11 @@ const chaindataAtom = utils.atomWithObservable(get => {
 
 const cryptoWaitReadyAtom = jotai.atom(async () => await utilCrypto.cryptoWaitReady());
 
+var packageJson = {
+	name: "@talismn/balances-react"};
+
+var log = anylogger__default.default(packageJson.name);
+
 const tokenRatesAtom = jotai.atom(async get => {
   // runs a timer to keep tokenRates up to date
   get(tokenRatesFetcherAtomEffect);
@@ -246,14 +193,20 @@ const allBalancesAtom = jotai.atom(async get => {
 });
 const balancesObservable = new rxjs.BehaviorSubject({});
 const balancesObservableAtom = utils.atomWithObservable(() => balancesObservable);
-const balancesPersistBackendAtom = jotai.atom(localStorageBalancesPersistBackend);
-const hydrateBalancesObservableAtom = jotai.atom(async get => {
-  const persistBackend = get(balancesPersistBackendAtom);
-  const balances$1 = await persistBackend.retrieve();
-  balancesObservable.next(Object.fromEntries(balances$1.map(b => [balances.getBalanceId(b), {
-    ...b,
-    status: "cache"
-  }])));
+
+// export const balancesPersistBackendAtom = atom<BalancesPersistBackend>(
+//   localStorageBalancesPersistBackend,
+// )
+
+const hydrateBalancesObservableAtom = jotai.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 = jotai.atom(async get => {
   const [{
@@ -272,16 +225,21 @@ const balancesSubscriptionAtomEffect = jotaiEffect.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(rxjs.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.Balances(balancesUpdates);
@@ -335,6 +293,7 @@ const balancesSubscriptionAtomEffect = jotaiEffect.atomEffect(get => {
         return util.isEthereumAddress(address) ? token.networkId || chainsById[token.networkId ?? ""]?.account === "secp256k1" : token.networkId && chainsById[token.networkId ?? ""]?.account !== "secp256k1";
       });
     });
+    const addressesByTokenId = lodash.fromPairs(enabledTokenIds.map(tokenId => [tokenId, allAddresses]));
 
     // Delete invalid cached balances
     const chainIds = new Set(chains.map(chain => chain.id));
@@ -350,7 +309,7 @@ const balancesSubscriptionAtomEffect = jotaiEffect.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)
@@ -387,62 +346,96 @@ const balancesSubscriptionAtomEffect = jotaiEffect.atomEffect(get => {
         if (v.length) updateBalances(v);
       });
     }, 30_000);
-    return balanceModules.map(balanceModule => {
-      const unsub = balances.balances(balanceModule, addressesByTokenByModule[balanceModule.type] ?? {}, (error, balances) => {
-        // log errors
-        if (error) {
-          if (error?.type === "STALE_RPC_ERROR" || error?.type === "WEBSOCKET_ALLOCATION_EXHAUSTED_ERROR") {
-            const addressesByModuleToken = addressesByTokenByModule[balanceModule.type] ?? {};
-            const staleObservable = balancesObservable.pipe(rxjs.map(val => Object.values(val).filter(balance => {
-              const {
-                tokenId,
-                address,
-                source
-              } = balance;
-              const chainComparison = error.chainId ? "chainId" in balance && error.chainId === balance.chainId : error.evmNetworkId ? "evmNetworkId" in balance && error.evmNetworkId === balance.evmNetworkId : true;
-              return chainComparison && addressesByModuleToken[tokenId]?.includes(address) && source === balanceModule.type;
-            }).map(balance => ({
-              ...balance,
-              status: "stale"
-            }))));
-            rxjs.firstValueFrom(staleObservable).then(v => {
-              if (v.length) updateBalances(v);
-            });
-          }
-          return log.error(`Failed to fetch ${balanceModule.type} balances`, error);
-        }
-
-        // ignore empty balance responses
-        if (!balances) return;
-        // ignore balances from old subscriptions which are still in the process of unsubscribing
-        if (abort.signal.aborted) return;
-
-        // good balances
-        if (balances) {
-          if ("status" in balances) {
-            // For modules using the new SubscriptionResultWithStatus pattern
-            //TODO fix initialisin
-            // if (result.status === "initialising") this.#initialising.add(balanceModule.type)
-            // else this.#initialising.delete(balanceModule.type)
-            updateBalances(balances.data);
-          } else {
-            // add good ones to initialisedBalances
-            updateBalances(Object.values(balances.toJSON()));
-          }
-        }
-      });
-      return () => unsub.then(unsubscribe => unsubscribe());
+    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 => {
@@ -459,9 +452,7 @@ const useSetBalancesAddresses = addresses => {
  * @returns a Balances object containing the current balances state.
  */
 
-const useBalances = persistBackend => {
-  const [, setPersistBackend] = jotai.useAtom(balancesPersistBackendAtom);
-  if (persistBackend) setPersistBackend(persistBackend);
+const useBalances = () => {
   return jotai.useAtomValue(allBalancesAtom);
 };
 
@@ -512,17 +503,12 @@ const useTokenRates = () => jotai.useAtomValue(tokenRatesAtom);
 const useTokenRate = tokenId => useTokenRates()[tokenId ?? ""] ?? undefined;
 
 const BalancesProvider = ({
-  balanceModules,
   coinsApiUrl,
   withTestnets,
   enabledChains,
   enabledTokens,
   children
 }) => {
-  const setBalanceModules = jotai.useSetAtom(balanceModuleCreatorsAtom);
-  react.useEffect(() => {
-    if (balanceModules !== undefined) setBalanceModules(balanceModules);
-  }, [balanceModules, setBalanceModules]);
   const setCoinsApiConfig = jotai.useSetAtom(coinsApiConfigAtom);
   react.useEffect(() => {
     setCoinsApiConfig({
@@ -573,9 +559,6 @@ Object.defineProperty(exports, "subTokensTokenId", {
 exports.BalancesProvider = BalancesProvider;
 exports.allAddressesAtom = allAddressesAtom;
 exports.allBalancesAtom = allBalancesAtom;
-exports.balanceModuleCreatorsAtom = balanceModuleCreatorsAtom;
-exports.balanceModulesAtom = balanceModulesAtom;
-exports.balancesPersistBackendAtom = balancesPersistBackendAtom;
 exports.chainConnectorsAtom = chainConnectorsAtom;
 exports.chaindataAtom = chaindataAtom;
 exports.chaindataProviderAtom = chaindataProviderAtom;