@talismn/balances 0.0.0-pr2075-20250708110002 → 0.0.0-pr2075-20250708143919

package/dist/talismn-balances.cjs.prod.js

@@ -1779,7 +1779,7 @@ const getTransferCallData$8 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$8 = 6_000;
+const SUBSCRIPTION_INTERVAL$6 = 6_000;
 const subscribeBalances$8 = ({
   networkId,
   tokensWithAddresses,
@@ -1797,7 +1797,7 @@ const subscribeBalances$8 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$8);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$8,
@@ -1993,7 +1993,7 @@ const getTransferCallData$7 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$7 = 6_000;
+const SUBSCRIPTION_INTERVAL$5 = 6_000;
 const subscribeBalances$7 = ({
   networkId,
   tokensWithAddresses,
@@ -2011,7 +2011,7 @@ const subscribeBalances$7 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$7);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$7,
@@ -2326,7 +2326,7 @@ const getTransferCallData$6 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$6 = 6_000;
+const SUBSCRIPTION_INTERVAL$4 = 6_000;
 const subscribeBalances$6 = ({
   networkId,
   tokensWithAddresses,
@@ -2344,7 +2344,7 @@ const subscribeBalances$6 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$6,
@@ -3477,7 +3477,7 @@ const fetchBalances$6 = async ({
 }) => {
   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 => ({
@@ -3509,7 +3509,7 @@ const fetchBalances$6 = async ({
       }))
     };
   }
-  const queries = buildQueries$6(networkId, balanceDefs, miniMetadata);
+  const queries = buildQueries$7(networkId, balanceDefs, miniMetadata);
   const balances = await new RpcStateQueryHelper(connector, queries).fetch();
   return balanceDefs.reduce((acc, def) => {
     const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
@@ -3537,7 +3537,7 @@ const fetchBalances$6 = async ({
     errors: []
   });
 };
-const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
+const buildQueries$7 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
     storage: ["Assets", "Account"]
   });
@@ -3546,9 +3546,9 @@ const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
     address
   }) => {
     const scaleCoder = networkStorageCoders?.storage;
-    const stateKey = tryEncode$1(scaleCoder, Number(token.assetId), address) ??
+    const stateKey = tryEncode$2(scaleCoder, Number(token.assetId), address) ??
     // Asset Hub
-    tryEncode$1(scaleCoder, BigInt(token.assetId), address); // Astar
+    tryEncode$2(scaleCoder, BigInt(token.assetId), address); // Astar
 
     if (!stateKey) {
       log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
@@ -3604,7 +3604,7 @@ const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
     };
   }).filter(util.isNotNil);
 };
-const tryEncode$1 = (scaleCoder, ...args) => {
+const tryEncode$2 = (scaleCoder, ...args) => {
   try {
     return scaleCoder?.keys?.enc?.(...args);
   } catch {
@@ -3847,46 +3847,163 @@ const getTransferAllEncodedArgs$2 = (assetId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$5 = 6_000;
+const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const call = builder.buildRuntimeCall(apiName, method);
+  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, scale.toHex(call.args.enc(args))]);
+  return call.value.dec(hex);
+};
+
+const tryGetConstantValue = (metadataRpc, pallet, constant) => {
+  const {
+    unifiedMetadata,
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const encodedValue = unifiedMetadata.pallets.find(({
+    name
+  }) => name === pallet)?.constants.find(({
+    name
+  }) => name === constant)?.value;
+  if (!encodedValue) return null;
+  const codec = builder.buildConstant(pallet, constant);
+  return codec.dec(encodedValue);
+};
+
+const fetchRpcQueryPack = async (connector, networkId, queries) => {
+  const allStateKeys = queries.flatMap(({
+    stateKeys
+  }) => stateKeys).filter(util.isNotNil);
+
+  // doing a query without keys would throw an error => return early
+  if (!allStateKeys.length) return queries.map(({
+    stateKeys,
+    decodeResult
+  }) => decodeResult(stateKeys.map(() => null)));
+  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(util.isNotNil);
+
+  // doing a query without keys would throw an error => return early
+  if (!allStateKeys.length) return rxjs.of(queries.map(({
+    stateKeys,
+    decodeResult
+  }) => decodeResult(stateKeys.map(() => null))));
+  return new rxjs.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 = result.changes.find(([key]) => key === stateKey);
+      if (!change) return null;
+      return change[1];
+    });
+    acc.push(decodeResult(changes));
+    return acc;
+  }, []);
+};
+
 const subscribeBalances$5 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  return new rxjs.Observable(subscriber => {
-    const abortController = new AbortController();
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$6(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(rxjs.map(balances => ({
+    success: balances,
+    errors: []
+  })));
+};
+const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
+  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
+    storage: ["Assets", "Account"]
+  });
+  return balanceDefs.map(({
+    token,
+    address
+  }) => {
+    const scaleCoder = networkStorageCoders?.storage;
+    const stateKey = tryEncode$1(scaleCoder, Number(token.assetId), address) ??
+    // Asset Hub
+    tryEncode$1(scaleCoder, BigInt(token.assetId), address); // Astar
 
-    // 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$6({
-          networkId,
-          tokensWithAddresses: tokensWithAddresses,
-          connector,
-          miniMetadata
-        });
-        if (abortController.signal.aborted) return;
-        subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
-      } catch (error) {
-        log.error("Error", {
-          module: MODULE_TYPE$5,
-          networkId,
-          miniMetadata,
-          addressesByToken: tokensWithAddresses,
-          error
-        });
-        subscriber.error(error);
-      }
+    if (!stateKey) {
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+      return null;
+    } else log.log(`VALID assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+    const decodeResult = changes => {
+      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+      const decoded = scale.decodeScale(scaleCoder, changes[0], `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
+        balance: 0n,
+        status: {
+          type: "Liquid"
+        }};
+      const isFrozen = decoded?.status?.type === "Frozen";
+      const amount = (decoded?.balance ?? 0n).toString();
+
+      // due to the following balance calculations, which are made in the `Balance` type:
+      //
+      // total balance        = (free balance) + (reserved balance)
+      // transferable balance = (free balance) - (frozen balance)
+      //
+      // when `isFrozen` is true we need to set **both** the `free` and `frozen` amounts
+      // of this balance to the value we received from the RPC.
+      //
+      // if we only set the `frozen` amount, then the `total` calculation will be incorrect!
+      const free = amount;
+      const frozen = token.isFrozen || isFrozen ? amount : "0";
+
+      // include balance values even if zero, so that newly-zero values overwrite old values
+      const balanceValues = [{
+        type: "free",
+        label: "free",
+        amount: free.toString()
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: frozen.toString()
+      }];
+      const balance = {
+        source: "substrate-assets",
+        status: "live",
+        address,
+        networkId,
+        tokenId: token.id,
+        values: balanceValues
+      };
+      return balance;
     };
-    poll();
-    return () => {
-      abortController.abort();
+    return {
+      stateKeys: [stateKey],
+      decodeResult
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }).filter(util.isNotNil);
+};
+const tryEncode$1 = (scaleCoder, ...args) => {
+  try {
+    return scaleCoder?.keys?.enc?.(...args);
+  } catch {
+    return null;
+  }
 };
 
 const SubAssetsBalanceModule = {
@@ -3916,7 +4033,7 @@ const fetchBalances$5 = async ({
 }) => {
   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 => ({
@@ -4245,7 +4362,7 @@ const getTransferAllEncodedArgs$1 = (onChainId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const SUBSCRIPTION_INTERVAL$3 = 6_000;
 const subscribeBalances$4 = ({
   networkId,
   tokensWithAddresses,
@@ -4268,7 +4385,7 @@ const subscribeBalances$4 = ({
         });
         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,
@@ -4312,30 +4429,6 @@ const SubHydrationTokenConfigSchema = z__default.default.strictObject({
 const MODULE_TYPE$3 = chaindataProvider.SubHydrationTokenSchema.shape.type.value;
 const PLATFORM$3 = chaindataProvider.SubHydrationTokenSchema.shape.platform.value;
 
-const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
-  const {
-    builder
-  } = scale.parseMetadataRpc(metadataRpc);
-  const call = builder.buildRuntimeCall(apiName, method);
-  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, scale.toHex(call.args.enc(args))]);
-  return call.value.dec(hex);
-};
-
-const tryGetConstantValue = (metadataRpc, pallet, constant) => {
-  const {
-    unifiedMetadata,
-    builder
-  } = scale.parseMetadataRpc(metadataRpc);
-  const encodedValue = unifiedMetadata.pallets.find(({
-    name
-  }) => name === pallet)?.constants.find(({
-    name
-  }) => name === constant)?.value;
-  if (!encodedValue) return null;
-  const codec = builder.buildConstant(pallet, constant);
-  return codec.dec(encodedValue);
-};
-
 const fetchBalances$4 = async ({
   networkId,
   tokensWithAddresses,
@@ -4344,7 +4437,7 @@ const fetchBalances$4 = async ({
 }) => {
   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 => ({
@@ -4591,7 +4684,7 @@ const getTransferCallData$3 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$3 = 6_000;
+const SUBSCRIPTION_INTERVAL$2 = 6_000;
 const subscribeBalances$3 = ({
   networkId,
   tokensWithAddresses,
@@ -4614,7 +4707,7 @@ const subscribeBalances$3 = ({
         });
         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,
@@ -4646,140 +4739,6 @@ const SubHydrationBalanceModule = {
 const MODULE_TYPE$2 = chaindataProvider.SubNativeTokenSchema.shape.type.value;
 const PLATFORM$2 = chaindataProvider.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 allStateKeys = queries.flatMap(({
-    stateKeys
-  }) => stateKeys).filter(util.isNotNil);
-
-  // doing a query with only null 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, {
-    stateKeys,
-    decodeResult
-  }) => {
-    const changes = stateKeys.map(stateKey => {
-      if (!stateKey) return null;
-      const change = response[0].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;
@@ -5499,7 +5458,7 @@ const fetchBalances$3 = async ({
 }) => {
   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 => ({
@@ -5531,12 +5490,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
 
@@ -5772,46 +5731,32 @@ const getTransferAllEncodedArgs = (to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$2 = 6_000;
 const subscribeBalances$2 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
-  return new rxjs.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,
-          tokensWithAddresses: tokensWithAddresses,
-          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: tokensWithAddresses,
-          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(rxjs.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 rxjs.combineLatest([baseBalances$, subtensorBalancesByAddress$]).pipe(rxjs.map(([baseBalances, subtensorBalancesByAddress]) => {
+    // add subtensor balances to base balances
+    for (const [address, subtensorBalances] of lodash.toPairs(subtensorBalancesByAddress)) {
+      const balance = baseBalances.find(b => b.address === address);
+      if (balance?.values) balance.values.push(...subtensorBalances);
+    }
+    return {
+      success: baseBalances,
+      errors: []
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }));
 };
 
 const SubNativeBalanceModule = {
@@ -7251,7 +7196,7 @@ const fetchBalances$1 = async ({
 }) => {
   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 => ({
@@ -10471,9 +10416,17 @@ class BalancesProvider {
       miniMetadatas: lodash.values(miniMetadatas).filter(util.isNotNil)
     })));
   }
-  getBalances$(addressesByToken) {
-    const networkIds = lodash.uniq(lodash.keys(addressesByToken).map(tokenId => chaindataProvider.parseTokenId(tokenId).networkId));
-    return rxjs.combineLatest(networkIds.map(networkId => this.getNetworkBalances$(networkId, addressesByToken))).pipe(rxjs.map(results => {
+
+  // this is the only public method
+  getBalances$(addressesByTokenId) {
+    // split by network
+    const addressesByTokenIdByNetworkId = lodash.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
+      const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
+      if (!acc[networkId]) acc[networkId] = {};
+      acc[networkId][tokenId] = addresses;
+      return acc;
+    }, {});
+    return rxjs.combineLatest(lodash.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId]))).pipe(rxjs.map(results => {
       return {
         status: results.some(({
           status
@@ -10482,9 +10435,17 @@ class BalancesProvider {
       };
     }), rxjs.startWith({
       status: "initialising",
-      balances: this.getStoredBalances(addressesByToken)
+      balances: this.getStoredBalances(addressesByTokenId)
     }), rxjs.distinctUntilChanged(lodash.isEqual));
   }
+  fetchBalances(addressesByTokenId) {
+    // TODO: better
+    return rxjs.firstValueFrom(this.getBalances$(addressesByTokenId).pipe(rxjs.filter(({
+      status
+    }) => status === "live"), rxjs.map(({
+      balances
+    }) => balances)));
+  }
   getNetworkBalances$(networkId, addressesByTokenId) {
     const network$ = this.#chaindataProvider.getNetworkById$(networkId);
     const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
@@ -10556,7 +10517,42 @@ class BalancesProvider {
     }));
   }
   getNetworkMiniMetadatas$(networkId) {
-    return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) && this.#chainConnectors.substrate ? rxjs.from(getMiniMetadatas(this.#chainConnectors.substrate, this.#chaindataProvider, networkId)) : rxjs.of([])));
+    return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) && this.#chainConnectors.substrate ? rxjs.from(getSpecVersion(this.#chainConnectors.substrate, networkId)).pipe(rxjs.switchMap(specVersion => this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])));
+  }
+  getMiniMetadatas$(networkId, specVersion) {
+    return rxjs.combineLatest({
+      defaultMiniMetadatas: this.getDefaultMiniMetadatas$(networkId, specVersion),
+      storedMiniMetadatas: this.getStoredMiniMetadatas$(networkId, specVersion)
+    }).pipe(rxjs.switchMap(({
+      storedMiniMetadatas,
+      defaultMiniMetadatas
+    }) => {
+      if (defaultMiniMetadatas.length) return rxjs.of(defaultMiniMetadatas);
+      if (storedMiniMetadatas.length) return rxjs.of(storedMiniMetadatas);
+      if (!this.#chainConnectors.substrate) return rxjs.of([]);
+      return rxjs.from(
+      // fetch them from the chain
+      getMiniMetadatas(this.#chainConnectors.substrate, this.#chaindataProvider, networkId)).pipe(
+      // and persist in storage for later reuse
+      rxjs.tap(newMiniMetadatas => {
+        if (!newMiniMetadatas.length) return;
+        const storage = this.#storage.getValue();
+        const miniMetadatas = lodash.assign(
+        // keep minimetadatas of other networks
+        lodash.keyBy(lodash.values(storage.miniMetadatas).filter(m => m.chainId !== networkId), m => m.id),
+        // add the ones for our network
+        lodash.keyBy(newMiniMetadatas, m => m.id));
+        this.#storage.next(lodash.assign({}, storage, {
+          miniMetadatas
+        }));
+      }));
+    }));
+  }
+  getStoredMiniMetadatas$(networkId, specVersion) {
+    return this.storage$.pipe(rxjs.map(storage => storage.miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodash.isEqual));
+  }
+  getDefaultMiniMetadatas$(networkId, specVersion) {
+    return this.#chaindataProvider.miniMetadatas$.pipe(rxjs.map(miniMetadatas => miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodash.isEqual));
   }
   getStoredBalances(addressesByToken) {
     const balanceDefs = lodash.toPairs(addressesByToken).flatMap(([tokenId, addresses]) => addresses.map(address => [tokenId, address]));
@@ -10567,13 +10563,6 @@ class BalancesProvider {
   }
 }
 
-// const getStoredBalances = (
-//   storedBalances: Record<string, IBalance>,
-//   addressesByToken: Record<TokenId, Address[]>,
-// ): IBalance[] => {
-
-// }
-
 Object.defineProperty(exports, "MINIMETADATA_VERSION", {
   enumerable: true,
   get: function () { return chaindataProvider.MINIMETADATA_VERSION; }