@talismn/balances 0.0.0-pr2075-20250707160526 → 0.0.0-pr2075-20250708125508

package/dist/talismn-balances.esm.js

@@ -1,6 +1,6 @@
 import { Dexie } from 'dexie';
 import anylogger from 'anylogger';
-import { evmErc20TokenId, MINIMETADATA_VERSION, EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, networkIdFromTokenId, getGithubTokenLogoUrl, SubAssetsTokenSchema, subAssetTokenId, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, DotNetworkBalancesConfigSchema, parseSubAssetTokenId, parseSubForeignAssetTokenId, parseSubTokensTokenId } from '@talismn/chaindata-provider';
+import { evmErc20TokenId, MINIMETADATA_VERSION, EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, networkIdFromTokenId, getGithubTokenLogoUrl, SubAssetsTokenSchema, subAssetTokenId, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, parseSubAssetTokenId, parseSubForeignAssetTokenId, parseSubTokensTokenId, isNetworkDot } from '@talismn/chaindata-provider';
 export { MINIMETADATA_VERSION } from '@talismn/chaindata-provider';
 import { newTokenRates } from '@talismn/token-rates';
 import { isBigInt, BigMath, planckToTokens, isArrayOf, isTruthy, isEthereumAddress, hasOwnProperty, isNotNil, isAbortError, decodeAnyAddress, blake2Concat, Deferred } from '@talismn/util';
@@ -11,7 +11,7 @@ import pako from 'pako';
 import { parseAbi, erc20Abi, getContract, ContractFunctionExecutionError, hexToString, erc20Abi_bytes32, encodeFunctionData, isHex, hexToBigInt, withRetry } from 'viem';
 import { assign, omit, isEqual, fromPairs, toPairs, keys, keyBy, uniq, values, groupBy as groupBy$1 } from 'lodash';
 import z from 'zod/v4';
-import { Observable, distinctUntilChanged, of, timer, switchMap, from, firstValueFrom, scan, share, map, switchAll, combineLatest, mergeMap, toArray, interval, startWith, exhaustMap, BehaviorSubject, debounceTime, takeUntil, withLatestFrom, concatMap } from 'rxjs';
+import { Observable, distinctUntilChanged, of, timer, switchMap, from, firstValueFrom, combineLatest, map, scan, share, switchAll, mergeMap, toArray, interval, startWith, exhaustMap, BehaviorSubject, debounceTime, takeUntil, withLatestFrom, concatMap, tap } from 'rxjs';
 import isEqual$1 from 'lodash/isEqual';
 import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, decodeScale, parseMetadataRpc, getStorageKeyPrefix, compactMetadata, encodeMetadata, papiParse, papiStringify, toHex, getMetadataVersion, encodeStateKey } from '@talismn/scale';
 import { Metadata, TypeRegistry } from '@polkadot/types';
@@ -275,11 +275,10 @@ class Balances {
 }
 const getBalanceId = balance => {
   const {
-    source,
     address,
     tokenId
   } = balance;
-  return [source, address, tokenId].join("::");
+  return [address, tokenId].join("::");
 };
 
 /**
@@ -1538,16 +1537,16 @@ const getBalanceDefs = addressesByToken => {
 
 const fetchBalances$c = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
-  for (const [token, addresses] of addressesByToken) {
+  for (const [token, addresses] of tokensWithAddresses) {
     if (token.type !== MODULE_TYPE$8 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (client.chain?.contracts?.erc20Aggregator && balanceDefs.length > 1) {
     const erc20Aggregator = client.chain.contracts.erc20Aggregator;
     return fetchWithAggregator$1(client, balanceDefs, erc20Aggregator.address);
@@ -1767,10 +1766,10 @@ const getTransferCallData$8 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$8 = 6_000;
+const SUBSCRIPTION_INTERVAL$7 = 6_000;
 const subscribeBalances$8 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
   return new Observable(subscriber => {
@@ -1780,17 +1779,17 @@ const subscribeBalances$8 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$c({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$8);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$7);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$8,
           networkId,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -1828,16 +1827,16 @@ const PLATFORM$7 = EvmNativeTokenSchema.shape.platform.value;
 
 const fetchBalances$b = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
-  for (const [token, addresses] of addressesByToken) {
+  for (const [token, addresses] of tokensWithAddresses) {
     if (token.type !== MODULE_TYPE$7 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (client.chain?.contracts?.multicall3 && balanceDefs.length > 1) {
     const multicall3 = client.chain.contracts.multicall3;
     return fetchWithMulticall(client, balanceDefs, multicall3.address);
@@ -1981,10 +1980,10 @@ const getTransferCallData$7 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$7 = 6_000;
+const SUBSCRIPTION_INTERVAL$6 = 6_000;
 const subscribeBalances$7 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
   return new Observable(subscriber => {
@@ -1994,17 +1993,17 @@ const subscribeBalances$7 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$b({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$7);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$7,
           networkId,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -2037,16 +2036,16 @@ const PLATFORM$6 = EvmUniswapV2TokenSchema.shape.platform.value;
 
 const fetchBalances$a = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
-  for (const [token, addresses] of addressesByToken) {
+  for (const [token, addresses] of tokensWithAddresses) {
     if (token.type !== MODULE_TYPE$6 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (client.chain?.contracts?.erc20Aggregator && balanceDefs.length > 1) {
     const erc20Aggregator = client.chain.contracts.erc20Aggregator;
     return fetchWithAggregator(client, balanceDefs, erc20Aggregator.address);
@@ -2314,10 +2313,10 @@ const getTransferCallData$6 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$6 = 6_000;
+const SUBSCRIPTION_INTERVAL$5 = 6_000;
 const subscribeBalances$6 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
   return new Observable(subscriber => {
@@ -2327,17 +2326,17 @@ const subscribeBalances$6 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$a({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$6,
           networkId,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -3459,13 +3458,13 @@ const decompress = data => {
 
 const fetchBalances$6 = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn("MiniMetadata is required for fetching balances");
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$5} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -3835,10 +3834,10 @@ const getTransferAllEncodedArgs$2 = (assetId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$5 = 6_000;
+const SUBSCRIPTION_INTERVAL$4 = 6_000;
 const subscribeBalances$5 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
@@ -3852,19 +3851,19 @@ const subscribeBalances$5 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$6({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector,
           miniMetadata
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$5,
           networkId,
           miniMetadata,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -3898,13 +3897,13 @@ const PLATFORM$4 = SubForeignAssetsTokenSchema.shape.platform.value;
 
 const fetchBalances$5 = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn("MiniMetadata is required for fetching balances");
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$4} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -4233,10 +4232,10 @@ const getTransferAllEncodedArgs$1 = (onChainId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const SUBSCRIPTION_INTERVAL$3 = 6_000;
 const subscribeBalances$4 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
@@ -4250,19 +4249,19 @@ const subscribeBalances$4 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$5({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector,
           miniMetadata
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$4,
           networkId,
           miniMetadata,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -4326,13 +4325,13 @@ const tryGetConstantValue = (metadataRpc, pallet, constant) => {
 
 const fetchBalances$4 = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn("MiniMetadata is required for fetching balances");
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$3} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -4377,7 +4376,7 @@ const fetchBalances$4 = async ({
       })).filter(b => b.onChainId !== undefined);
     });
     const balancesByKey = keyBy(fetchedBalances, b => `${b.address}:${b.onChainId}`);
-    const success = addressesByToken.reduce((acc, [token, addresses]) => {
+    const success = tokensWithAddresses.reduce((acc, [token, addresses]) => {
       if (token.type === MODULE_TYPE$3) for (const address of addresses) {
         const rawBalance = balancesByKey[`${address}:${token.onChainId}`];
 
@@ -4579,10 +4578,10 @@ const getTransferCallData$3 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$3 = 6_000;
+const SUBSCRIPTION_INTERVAL$2 = 6_000;
 const subscribeBalances$3 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
@@ -4596,19 +4595,19 @@ const subscribeBalances$3 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$4({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector,
           miniMetadata
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$3,
           networkId,
           miniMetadata,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -4634,140 +4633,54 @@ const SubHydrationBalanceModule = {
 const MODULE_TYPE$2 = SubNativeTokenSchema.shape.type.value;
 const PLATFORM$2 = SubNativeTokenSchema.shape.platform.value;
 
-/**
- * Pass some these into an `RpcStateQueryHelper` in order to easily batch multiple state queries into the one rpc call.
- */
-
-const fetchQueriesPack = async (connector, networkId, queries) => {
+const fetchRpcQueryPack = async (connector, networkId, queries) => {
   const allStateKeys = queries.flatMap(({
     stateKeys
   }) => stateKeys).filter(isNotNil);
 
-  // doing a query with only null keys would throw an error => return early
+  // doing a query without keys would throw an error => return early
   if (!allStateKeys.length) return queries.map(({
     stateKeys,
     decodeResult
   }) => decodeResult(stateKeys.map(() => null)));
-  const response = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
-  const results = queries.reduce((acc, {
+  const [result] = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
+  return decodeRpcQueryPack(queries, result);
+};
+const getRpcQueryPack$ = (connector, networkId, queries, timeout = false) => {
+  const allStateKeys = queries.flatMap(({
+    stateKeys
+  }) => stateKeys).filter(isNotNil);
+
+  // doing a query without keys would throw an error => return early
+  if (!allStateKeys.length) return of(queries.map(({
+    stateKeys,
+    decodeResult
+  }) => decodeResult(stateKeys.map(() => null))));
+  return new Observable(subscriber => {
+    const promUnsub = connector.subscribe(networkId, "state_subscribeStorage", "state_storage", [allStateKeys], (error, result) => {
+      if (error) subscriber.error(error);else subscriber.next(decodeRpcQueryPack(queries, result));
+    }, timeout);
+    return () => {
+      promUnsub.then(unsub => unsub("state_unsubscribeStorage"));
+    };
+  });
+};
+const decodeRpcQueryPack = (queries, result) => {
+  return queries.reduce((acc, {
     stateKeys,
     decodeResult
   }) => {
     const changes = stateKeys.map(stateKey => {
       if (!stateKey) return null;
-      const change = response[0].changes.find(([key]) => key === stateKey);
+      const change = result.changes.find(([key]) => key === stateKey);
       if (!change) return null;
       return change[1];
     });
     acc.push(decodeResult(changes));
     return acc;
   }, []);
-  return results;
 };
 
-/**
- * Used by a variety of balance modules to help batch multiple state queries into the one rpc call.
- */
-// export class RpcStateQueriesHelper<T> {
-//   #connector: ChainConnector
-//   #queries: Array<RpcStateQueries<T>>
-
-//   constructor(connector: ChainConnector, queries: Array<RpcStateQueries<T>>) {
-//     this.#connector = connector
-//     this.#queries = queries
-//   }
-
-//   async subscribe(
-//     networkId: DotNetworkId,
-//     callback: SubscriptionCallback<T[]>,
-//     timeout: number | false = false,
-//     subscribeMethod = "state_subscribeStorage",
-//     responseMethod = "state_storage",
-//     unsubscribeMethod = "state_unsubscribeStorage",
-//   ): Promise<UnsubscribeFn> {
-//     const params = [this.#queries.flatMap(({ stateKeys }) => stateKeys)]
-
-//     const unsub = this.#connector.subscribe(
-//       networkId,
-//       subscribeMethod,
-//       responseMethod,
-//       params,
-//       (error, result) => {
-//         error
-//           ? callback(error)
-//           : callback(null, this.#distributeChangesToQueryDecoders.call(this, chainId, result))
-//       },
-//       timeout,
-//     )
-
-//     const subscriptions = queries.map(([chainId, queries]) => {
-//       const params = [queries.map(({ stateKey }) => stateKey)]
-
-//       const unsub = this.#connector.subscribe(
-//         networkId,
-//         subscribeMethod,
-//         responseMethod,
-//         params,
-//         (error, result) => {
-//           error
-//             ? callback(error)
-//             : callback(null, this.#distributeChangesToQueryDecoders.call(this, chainId, result))
-//         },
-//         timeout,
-//       )
-
-//       return () => unsub.then((unsubscribe) => unsubscribe(unsubscribeMethod))
-//     })
-
-//     return () => subscriptions.forEach((unsubscribe) => unsubscribe())
-//   }
-
-//   async fetch(method = "state_queryStorageAt"): Promise<T[]> {
-//     const queriesByChain = groupBy(this.#queries, "chainId")
-
-//     const resultsByChain = await Promise.all(
-//       Object.entries(queriesByChain).map(async ([chainId, queries]) => {
-//         const params = [queries.map(({ stateKey }) => stateKey)]
-
-//         const result = (await this.#connector.send(chainId, method, params))[0]
-//         return this.#distributeChangesToQueryDecoders.call(this, chainId, result)
-//       }),
-//     )
-
-//     return resultsByChain.flatMap((result) => result)
-//   }
-
-//   #distributeChangesToQueryDecoders(chainId: DotNetworkId, result: unknown): T[] {
-//     if (typeof result !== "object" || result === null) return []
-//     if (!hasOwnProperty(result, "changes") || typeof result.changes !== "object") return []
-//     if (!Array.isArray(result.changes)) return []
-
-//     return result.changes.flatMap(([reference, change]: [unknown, unknown]): [T] | [] => {
-//       if (typeof reference !== "string") {
-//         log.warn(`Received non-string reference in RPC result: ${reference}`)
-//         return []
-//       }
-
-//       if (typeof change !== "string" && change !== null) {
-//         log.warn(`Received non-string and non-null change in RPC result: ${reference} | ${change}`)
-//         return []
-//       }
-
-//       const query = this.#queries.find(
-//         ({ chainId: cId, stateKey }) => cId === chainId && stateKey === reference,
-//       )
-//       if (!query) {
-//         log.warn(
-//           `Failed to find query:\n${reference} in\n${this.#queries.map(({ stateKey }) => stateKey)}`,
-//         )
-//         return []
-//       }
-
-//       return [query.decodeResult(change)]
-//     })
-//   }
-// }
-
 const SUBTENSOR_ROOT_NETUID$1 = 0;
 const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1 = 1000000n;
 const TAO_DECIMALS$1 = 9n;
@@ -5481,13 +5394,13 @@ const getNomPoolStateKeys = (coders, nomPoolMemberInfo, extra) => {
 
 const fetchBalances$3 = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn("MiniMetadata is required for fetching balances");
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$2} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -5519,12 +5432,12 @@ const fetchBalances$3 = async ({
       }))
     };
   }
-  const queries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
-  const partialBalances = await fetchQueriesPack(connector, networkId, queries);
+  const baseQueries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
+  const partialBalances = await fetchRpcQueryPack(connector, networkId, baseQueries);
 
   // now for each balance that includes nomPoolStaking, we need to fetch the metadata for the pool
   const nomPoolQueries = buildNomPoolQueries(networkId, partialBalances, miniMetadata);
-  const balances = await fetchQueriesPack(connector, networkId, nomPoolQueries);
+  const balances = await fetchRpcQueryPack(connector, networkId, nomPoolQueries);
 
   // TODO ⚠️ dedupe locks
 
@@ -5760,46 +5673,32 @@ const getTransferAllEncodedArgs = (to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$2 = 6_000;
 const subscribeBalances$2 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  return new Observable(subscriber => {
-    const abortController = new AbortController();
-
-    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
-    // => poll values for each block
-    const poll = async () => {
-      try {
-        if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$3({
-          networkId,
-          addressesByToken,
-          connector,
-          miniMetadata
-        });
-        if (abortController.signal.aborted) return;
-        subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
-      } catch (error) {
-        log.error("Error", {
-          module: MODULE_TYPE$2,
-          networkId,
-          miniMetadata,
-          addressesByToken,
-          error
-        });
-        subscriber.error(error);
-      }
-    };
-    poll();
-    return () => {
-      abortController.abort();
+  // could be use as shared observable key if we decide to cache the sub
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const baseQueries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
+  const baseBalances$ = getRpcQueryPack$(connector, networkId, baseQueries).pipe(switchMap(partialBalances => {
+    // now for each balance that includes nomPoolStaking, we need to fetch the metadata for the pool
+    const nomPoolQueries = buildNomPoolQueries(networkId, partialBalances, miniMetadata);
+    return getRpcQueryPack$(connector, networkId, nomPoolQueries);
+  }));
+  const subtensorBalancesByAddress$ = getSubtensorStakingBalances$(connector, networkId, balanceDefs, miniMetadata);
+  return combineLatest([baseBalances$, subtensorBalancesByAddress$]).pipe(map(([baseBalances, subtensorBalancesByAddress]) => {
+    // add subtensor balances to base balances
+    for (const [address, subtensorBalances] of toPairs(subtensorBalancesByAddress)) {
+      const balance = baseBalances.find(b => b.address === address);
+      if (balance?.values) balance.values.push(...subtensorBalances);
+    }
+    return {
+      success: baseBalances,
+      errors: []
     };
-  }).pipe(distinctUntilChanged(isEqual));
+  }));
 };
 
 const SubNativeBalanceModule = {
@@ -6980,10 +6879,10 @@ var psp22Abi = {
 
 const fetchBalances$2 = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector
 }) => {
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!balanceDefs.length) return {
     success: [],
     errors: []
@@ -7173,7 +7072,7 @@ const getTransferCallData$1 = async ({
 const SUBSCRIPTION_INTERVAL$1 = 6_000;
 const subscribeBalances$1 = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
@@ -7187,7 +7086,7 @@ const subscribeBalances$1 = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$2({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector,
           miniMetadata
         });
@@ -7199,7 +7098,7 @@ const subscribeBalances$1 = ({
           module: MODULE_TYPE$1,
           networkId,
           miniMetadata,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -7233,13 +7132,13 @@ const PLATFORM = SubTokensTokenSchema.shape.platform.value;
 
 const fetchBalances$1 = async ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  const balanceDefs = getBalanceDefs(addressesByToken);
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn("MiniMetadata is required for fetching balances");
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -7563,7 +7462,7 @@ const getCallDataOptions = (to, token, value, type, config) => {
 const SUBSCRIPTION_INTERVAL = 6_000;
 const subscribeBalances = ({
   networkId,
-  addressesByToken,
+  tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
@@ -7577,7 +7476,7 @@ const subscribeBalances = ({
         if (abortController.signal.aborted) return;
         const balances = await fetchBalances$1({
           networkId,
-          addressesByToken,
+          tokensWithAddresses: tokensWithAddresses,
           connector,
           miniMetadata
         });
@@ -7589,7 +7488,7 @@ const subscribeBalances = ({
           module: MODULE_TYPE,
           networkId,
           miniMetadata,
-          addressesByToken,
+          addressesByToken: tokensWithAddresses,
           error
         });
         subscriber.error(error);
@@ -7693,6 +7592,7 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
   if (CACHE.has(networkId)) return CACHE.get(networkId);
   if (!signal) log.warn("[miniMetadata] getMiniMetadatas called without signal, this may hang the updates", new Error("No signal provided") // this will show the stack trace
   );
+  if (specVersion === undefined) specVersion = await getSpecVersion(chainConnector, networkId);
   const pResult = POOL.add(() => fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion), {
     signal
   });
@@ -7708,42 +7608,21 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
     CACHE.delete(networkId);
   }
 };
-const DotBalanceModuleTypeSchema = z.keyof(DotNetworkBalancesConfigSchema);
 const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
   const start = performance.now();
   log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
   try {
+    const network = await chaindataProvider.getNetworkById(chainId, "polkadot");
+    if (!network) throw new Error(`Network ${chainId} not found in chaindataProvider`);
+    signal?.throwIfAborted();
     const metadataRpc = await getMetadataRpc(chainConnector, chainId);
     signal?.throwIfAborted();
-    const chainConnectors = {
-      substrate: chainConnector,
-      evm: {} // wont be used but workarounds error for module creation
-    };
-    const modules = defaultBalanceModules.map(mod => mod({
-      chainConnectors,
-      chaindataProvider
-    })).filter(mod => DotBalanceModuleTypeSchema.safeParse(mod.type).success);
-    return Promise.all(modules.map(async mod => {
-      const source = mod.type;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
-      const balancesConfig = chain?.balancesConfig?.[mod.type];
-      const chainMeta = await mod.fetchSubstrateChainMeta(chainId, balancesConfig,
-      // TODO better typing
-      metadataRpc);
-      return {
-        id: deriveMiniMetadataId({
-          source,
-          chainId,
-          specVersion
-        }),
-        source,
-        chainId,
-        specVersion,
-        version: MINIMETADATA_VERSION,
-        data: chainMeta?.miniMetadata ?? null,
-        extra: chainMeta?.extra ?? null
-      };
-    }));
+    return Promise.all(BALANCE_MODULES.filter(m => m.platform === "polkadot").map(mod => mod.getMiniMetadata({
+      networkId: chainId,
+      metadataRpc,
+      specVersion,
+      config: network.balancesConfig?.[mod.type]
+    })));
   } finally {
     log.debug("[miniMetadata] updated miniMetadatas for %s in %sms", chainId, (performance.now() - start).toFixed(2));
   }
@@ -10454,4 +10333,132 @@ async function buildQueries(chainConnector, chaindataProvider, addressesByToken,
 const defaultBalanceModules = [EvmErc20Module, EvmNativeModule, EvmUniswapV2Module, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule];
 const BALANCE_MODULES = [SubNativeBalanceModule, SubAssetsBalanceModule, SubHydrationBalanceModule, SubForeignAssetsBalanceModule, SubPsp22BalanceModule, SubTokensBalanceModule, EvmErc20BalanceModule, EvmUniswapV2BalanceModule, EvmNativeBalanceModule];
 
-export { BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN$1 as ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR$1 as SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1 as SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID$1 as SUBTENSOR_ROOT_NETUID, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildNetworkStorageCoders, buildStorageCoders, calculateAlphaPrice$1 as calculateAlphaPrice, calculateTaoAmountFromAlpha$1 as calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo$1 as calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getLockedType$1 as getLockedType, getUniqueChainIds, getValueId, includeInTotalExtraAmount, makeContractCaller, uniswapV2PairAbi };
+const DEFAULT_STORAGE = {
+  balances: [],
+  miniMetadatas: []
+};
+class BalancesProvider {
+  #chaindataProvider;
+  #chainConnectors;
+  #storage;
+  constructor(chaindataProvider, chainConnectors, storage = DEFAULT_STORAGE) {
+    this.#chaindataProvider = chaindataProvider;
+    this.#chainConnectors = chainConnectors;
+    this.#storage = new BehaviorSubject({
+      balances: keyBy(storage.balances.filter(isNotNil), b => getBalanceId(b)),
+      miniMetadatas: keyBy(storage.miniMetadatas.filter(isNotNil), m => m.id)
+    });
+  }
+  get storage$() {
+    return this.#storage.pipe(map(({
+      balances,
+      miniMetadatas
+    }) => ({
+      balances: values(balances).filter(isNotNil),
+      miniMetadatas: values(miniMetadatas).filter(isNotNil)
+    })));
+  }
+  getBalances$(addressesByToken) {
+    const networkIds = uniq(keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId));
+    return combineLatest(networkIds.map(networkId => this.getNetworkBalances$(networkId, addressesByToken))).pipe(map(results => {
+      return {
+        status: results.some(({
+          status
+        }) => status === "initialising") ? "initialising" : "live",
+        balances: results.flatMap(result => result.balances)
+      };
+    }), startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByToken)
+    }), distinctUntilChanged(isEqual));
+  }
+  getNetworkBalances$(networkId, addressesByTokenId) {
+    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+    const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
+    return combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(switchMap(([network, miniMetadatas, tokensMapById]) => {
+      const tokensAndAddresses = toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
+      return combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
+        const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
+        const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+        const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
+
+        // all balance ids expected in result set
+        const balanceIds = toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+          tokenId,
+          address
+        })));
+        const initValue = {
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
+        };
+        const updateStorage = results => {
+          if (results.status !== "live") return;
+          const storage = this.#storage.getValue();
+          const balances = assign({}, storage.balances,
+          // delete all balances expected in the result set. because if they are not present it means they are empty.
+          fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), keyBy(results.balances, b => getBalanceId(b)));
+          this.#storage.next(assign({}, storage, {
+            balances
+          }));
+        };
+        switch (mod.platform) {
+          case "ethereum":
+            {
+              if (!this.#chainConnectors.evm) return of(initValue);
+              return mod.subscribeBalances({
+                networkId,
+                tokensWithAddresses,
+                connector: this.#chainConnectors.evm
+              }).pipe(map(results => ({
+                status: "live",
+                // exclude zero balances
+                balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+              })), tap(updateStorage), startWith(initValue));
+            }
+          case "polkadot":
+            if (!this.#chainConnectors.substrate || !miniMetadata) {
+              log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
+              return of(initValue);
+            }
+            return mod.subscribeBalances({
+              networkId,
+              tokensWithAddresses,
+              connector: this.#chainConnectors.substrate,
+              miniMetadata: miniMetadata
+            }).pipe(map(results => ({
+              status: "live",
+              // exclude zero balances
+              balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+            })), tap(updateStorage), startWith(initValue));
+        }
+      }));
+    }), map(results => {
+      return {
+        status: results.some(({
+          status
+        }) => status === "initialising") ? "initialising" : "live",
+        balances: results.flatMap(result => result.balances)
+      };
+    }));
+  }
+  getNetworkMiniMetadatas$(networkId) {
+    return this.#chaindataProvider.getNetworkById$(networkId).pipe(switchMap(network => isNetworkDot(network) && this.#chainConnectors.substrate ? from(getMiniMetadatas(this.#chainConnectors.substrate, this.#chaindataProvider, networkId)) : of([])));
+  }
+  getStoredBalances(addressesByToken) {
+    const balanceDefs = toPairs(addressesByToken).flatMap(([tokenId, addresses]) => addresses.map(address => [tokenId, address]));
+    return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({
+      address,
+      tokenId
+    })]).filter(isNotNil);
+  }
+}
+
+// const getStoredBalances = (
+//   storedBalances: Record<string, IBalance>,
+//   addressesByToken: Record<TokenId, Address[]>,
+// ): IBalance[] => {
+
+// }
+
+export { BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, BalancesProvider, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN$1 as ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR$1 as SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1 as SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID$1 as SUBTENSOR_ROOT_NETUID, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildNetworkStorageCoders, buildStorageCoders, calculateAlphaPrice$1 as calculateAlphaPrice, calculateTaoAmountFromAlpha$1 as calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo$1 as calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getLockedType$1 as getLockedType, getUniqueChainIds, getValueId, includeInTotalExtraAmount, makeContractCaller, uniswapV2PairAbi };