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

package/dist/talismn-balances.esm.js

@@ -11,13 +11,13 @@ 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, map, timer, switchMap, from, firstValueFrom, combineLatest, scan, share, switchAll, mergeMap, toArray, interval, startWith, exhaustMap, BehaviorSubject, debounceTime, takeUntil, withLatestFrom, concatMap, filter, tap } from 'rxjs';
+import { of, Observable, distinctUntilChanged, map, timer, switchMap, from, firstValueFrom, combineLatest, scan, share, switchAll, mergeMap, toArray, interval, startWith, exhaustMap, BehaviorSubject, debounceTime, takeUntil, withLatestFrom, concatMap, filter, tap } from 'rxjs';
 import isEqual$1 from 'lodash/isEqual';
-import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, decodeScale, parseMetadataRpc, getStorageKeyPrefix, compactMetadata, encodeMetadata, toHex, papiParse, papiStringify, getMetadataVersion, encodeStateKey } from '@talismn/scale';
-import { Metadata, TypeRegistry } from '@polkadot/types';
-import groupBy from 'lodash/groupBy';
+import { decodeScale, parseMetadataRpc, getStorageKeyPrefix, compactMetadata, encodeMetadata, toHex, unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, papiParse, papiStringify, getMetadataVersion, encodeStateKey } from '@talismn/scale';
 import { mergeUint8, toHex as toHex$1 } from '@polkadot-api/utils';
 import { Binary, Enum, AccountId } from 'polkadot-api';
+import { Metadata, TypeRegistry } from '@polkadot/types';
+import groupBy from 'lodash/groupBy';
 import upperFirst from 'lodash/upperFirst';
 import { u32, Struct, u128 } from 'scale-ts';
 import { Abi } from '@polkadot/api-contract';
@@ -1540,6 +1540,10 @@ const fetchBalances$c = async ({
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   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 tokensWithAddresses) {
@@ -1558,7 +1562,6 @@ const fetchWithoutAggregator$1 = async (client, balanceDefs) => {
     success: [],
     errors: []
   };
-  log.debug("fetching %s balances without aggregator", MODULE_TYPE$8, balanceDefs.length);
   const results = await Promise.allSettled(balanceDefs.map(async ({
     token,
     address
@@ -1576,7 +1579,7 @@ const fetchWithoutAggregator$1 = async (client, balanceDefs) => {
         value: result.toString(),
         source: MODULE_TYPE$8,
         networkId: parseEvmErc20TokenId(token.id).networkId,
-        status: "cache"
+        status: "live"
       };
       return balance;
     } catch (err) {
@@ -1603,7 +1606,6 @@ const fetchWithAggregator$1 = async (client, balanceDefs, erc20BalancesAggregato
     success: [],
     errors: []
   };
-  log.debug("fetching %s balances with aggregator", MODULE_TYPE$8, balanceDefs.length);
   try {
     const erc20Balances = await client.readContract({
       abi: erc20BalancesAggregatorAbi,
@@ -1620,7 +1622,7 @@ const fetchWithAggregator$1 = async (client, balanceDefs, erc20BalancesAggregato
       value: erc20Balances[index].toString(),
       source: MODULE_TYPE$8,
       networkId: parseTokenId(balanceDef.token.id).networkId,
-      status: "cache"
+      status: "live"
     }));
     return {
       success,
@@ -1766,12 +1768,16 @@ const getTransferCallData$8 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$6 = 6_000;
+const SUBSCRIPTION_INTERVAL$4 = 6_000;
 const subscribeBalances$8 = ({
   networkId,
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
   return new Observable(subscriber => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -1784,7 +1790,7 @@ const subscribeBalances$8 = ({
         });
         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$8,
@@ -1830,6 +1836,10 @@ const fetchBalances$b = async ({
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   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 tokensWithAddresses) {
@@ -1848,7 +1858,6 @@ const fetchWithoutMulticall = async (client, balanceDefs) => {
     success: [],
     errors: []
   };
-  log.debug("fetching %s balances without multicall3", MODULE_TYPE$7, balanceDefs.length);
   const results = await Promise.allSettled(balanceDefs.map(async ({
     token,
     address
@@ -1890,7 +1899,6 @@ const fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
     success: [],
     errors: []
   };
-  log.debug("fetching %s balances with multicall3", MODULE_TYPE$7, balanceDefs.length);
   try {
     const callResults = await client.multicall({
       contracts: balanceDefs.map(({
@@ -1980,12 +1988,16 @@ const getTransferCallData$7 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$5 = 6_000;
+const SUBSCRIPTION_INTERVAL$3 = 6_000;
 const subscribeBalances$7 = ({
   networkId,
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
   return new Observable(subscriber => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -1998,7 +2010,7 @@ const subscribeBalances$7 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$7,
@@ -2039,6 +2051,10 @@ const fetchBalances$a = async ({
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   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 tokensWithAddresses) {
@@ -2057,7 +2073,6 @@ const fetchWithoutAggregator = async (client, balanceDefs) => {
     success: [],
     errors: []
   };
-  log.debug("fetching %s balances without aggregator", MODULE_TYPE$6, balanceDefs.length);
   const results = await Promise.allSettled(balanceDefs.map(async ({
     token,
     address
@@ -2075,7 +2090,7 @@ const fetchWithoutAggregator = async (client, balanceDefs) => {
         value: result.toString(),
         source: MODULE_TYPE$6,
         networkId: parseTokenId(token.id).networkId,
-        status: "cache"
+        status: "live"
       };
       return balance;
     } catch (err) {
@@ -2102,7 +2117,6 @@ const fetchWithAggregator = async (client, balanceDefs, erc20BalancesAggregatorA
     success: [],
     errors: []
   };
-  log.debug("fetching %s balances with aggregator", MODULE_TYPE$6, balanceDefs.length);
   try {
     const erc20Balances = await client.readContract({
       abi: erc20BalancesAggregatorAbi,
@@ -2119,7 +2133,7 @@ const fetchWithAggregator = async (client, balanceDefs, erc20BalancesAggregatorA
       value: erc20Balances[index].toString(),
       source: MODULE_TYPE$6,
       networkId: parseTokenId(balanceDef.token.id).networkId,
-      status: "cache"
+      status: "live"
     }));
     return {
       success,
@@ -2313,12 +2327,16 @@ const getTransferCallData$6 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const SUBSCRIPTION_INTERVAL$2 = 6_000;
 const subscribeBalances$6 = ({
   networkId,
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
   return new Observable(subscriber => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -2331,7 +2349,7 @@ const subscribeBalances$6 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$6,
@@ -3195,273 +3213,138 @@ async function getPoolBalance(publicClient, contractAddress, accountAddress) {
 const MODULE_TYPE$5 = SubAssetsTokenSchema.shape.type.value;
 const PLATFORM$5 = SubAssetsTokenSchema.shape.platform.value;
 
-/**
- * Wraps a BalanceModule's fetch/subscribe methods with a single `balances` method.
- * This `balances` method will subscribe if a callback parameter is provided, or otherwise fetch.
- */
+const fetchRpcQueryPack = async (connector, networkId, queries) => {
+  const allStateKeys = queries.flatMap(({
+    stateKeys
+  }) => stateKeys).filter(isNotNil);
 
-async function balances(balanceModule, addressesByToken, callback) {
-  // subscription request
-  if (callback !== undefined) return await balanceModule.subscribeBalances({
-    addressesByToken
-  }, callback);
+  // 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(isNotNil);
 
-  // one-off request
-  return await balanceModule.fetchBalances(addressesByToken);
-}
+  // 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 = result.changes.find(([key]) => key === stateKey);
+      if (!change) return null;
+      return change[1];
+    });
+    acc.push(decodeResult(changes));
+    return acc;
+  }, []);
+};
 
-// TODO remove this one in favor of the network specific one below
-const buildStorageCoders = ({
-  chainIds,
-  chains,
-  miniMetadatas,
-  coders
-}) => new Map([...chainIds].flatMap(chainId => {
-  const chain = chains[chainId];
-  if (!chain) return [];
-  const miniMetadata = miniMetadatas.get(chainId); // findMiniMetadata<TBalanceModule>(miniMetadatas, moduleType, chain)
-  if (!miniMetadata) return [];
-  if (!miniMetadata.data) return [];
-  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
-  try {
-    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
-    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
-      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
-        chainId
-      }) : moduleMethodOrFn;
-      try {
-        return [[key, scaleBuilder.buildStorage(module, method)]];
-      } catch (cause) {
-        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
-        return [];
-      }
-    }));
-    return [[chainId, builtCoders]];
-  } catch (cause) {
-    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
-    return [];
-  }
-}));
-// type StorageCoder<TCoders extends NetworkCoders> = ReturnType<ReturnType<typeof getDynamicBuilder>["buildStorage"]>[keyof TCoders]
+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
 
-const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
-  if (!miniMetadata.data) return null;
-  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
+    if (!stateKey) {
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+      return null;
+    }
+    const decodeResult = changes => {
+      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+      const decoded = 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;
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  }).filter(isNotNil);
+};
+const tryEncode$1 = (scaleCoder, ...args) => {
   try {
-    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
-    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
-      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
-        chainId
-      }) : moduleMethodOrFn;
-      try {
-        return [[key, scaleBuilder.buildStorage(module, method)]];
-      } catch (cause) {
-        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
-        return [];
-      }
-    }));
-    return builtCoders;
-  } catch (cause) {
-    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
+    return scaleCoder?.keys?.enc?.(...args);
+  } catch {
+    return null;
   }
-  return null;
 };
 
-/**
- * Decodes & unwraps outputs and errors of a given result, contract, and method.
- * Parsed error message can be found in `decodedOutput` if `isError` is true.
- * SOURCE: https://github.com/paritytech/contracts-ui (GPL-3.0-only)
- */
-function decodeOutput({
-  result
-}, registry, abi, method) {
-  let output;
-  let decodedOutput = "";
-  let isError = true;
-  if (result.isOk) {
-    const flags = result.asOk.flags.toHuman();
-    isError = flags.includes("Revert");
-    const abiMessage = getAbiMessage(abi, method);
-    const returnType = abiMessage.returnType;
-    const returnTypeName = getReturnTypeName(returnType);
-    const r = returnType ? registry.createTypeUnsafe(returnTypeName, [result.asOk.data]).toHuman() : "()";
-    output = isOk(r) ? r.Ok : isErr(r) ? r.Err : r;
-    const errorText = isErr(output) ? typeof output.Err === "object" ? JSON.stringify(output.Err, null, 2) : output.Err?.toString() ?? "Error" : output !== "Ok" ? output?.toString() || "Error" : "Error";
-    const okText = isOk(r) ? typeof output === "object" ? JSON.stringify(output, null, "\t") : output?.toString() ?? "()" : JSON.stringify(output, null, "\t") ?? "()";
-    decodedOutput = isError ? errorText : okText;
-  } else if (result.isErr) {
-    output = result.toHuman();
-    let errorText;
-    if (isErr(output) && typeof output.Err === "object" && Object.keys(output.Err || {}).length && typeof Object.values(output.Err || {})[0] === "string") {
-      const [errorKey, errorValue] = Object.entries(output.Err || {})[0];
-      errorText = `${errorKey}${errorValue}`;
-    }
-    decodedOutput = errorText || "Error";
-  }
-  return {
-    output,
-    decodedOutput,
-    isError
+const fetchBalances$6 = async ({
+  networkId,
+  tokensWithAddresses,
+  connector,
+  miniMetadata
+}) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
   };
-}
-
-/**
- * Helper types & functions
- * SOURCE: https://github.com/paritytech/contracts-ui (GPL-3.0-only)
- */
-
-function isErr(o) {
-  return typeof o === "object" && o !== null && "Err" in o;
-}
-function isOk(o) {
-  return typeof o === "object" && o !== null && "Ok" in o;
-}
-function getReturnTypeName(type) {
-  return type?.lookupName || type?.type || "";
-}
-function getAbiMessage(abi, method) {
-  const abiMessage = abi.messages.find(m => stringCamelCase(m.method) === stringCamelCase(method));
-  if (!abiMessage) {
-    throw new Error(`"${method}" not found in Contract`);
-  }
-  return abiMessage;
-}
-
-/**
- *
- * Detect Balances::transfer -> Balances::transfer_allow_death migration
- * https://github.com/paritytech/substrate/pull/12951
- *
- * `transfer_allow_death` is the preferred method,
- * so if something goes wrong during detection, we should assume the chain has migrated
- * @param metadataRpc string containing the hashed RPC metadata for the chain
- * @returns
- */
-const detectTransferMethod = metadataRpc => {
-  const pjsMetadata = new Metadata(new TypeRegistry(), metadataRpc);
-  pjsMetadata.registry.setMetadata(pjsMetadata);
-  const balancesPallet = pjsMetadata.asLatest.pallets.find(pallet => pallet.name.eq("Balances"));
-  const balancesCallsTypeIndex = balancesPallet?.calls.value.type.toNumber();
-  const balancesCallsType = balancesCallsTypeIndex !== undefined ? pjsMetadata.asLatest.lookup.types[balancesCallsTypeIndex] : undefined;
-  const hasDeprecatedTransferCall = balancesCallsType?.type.def.asVariant?.variants.find(variant => variant.name.eq("transfer")) !== undefined;
-  return hasDeprecatedTransferCall ? "transfer" : "transfer_allow_death";
-};
-
-const getUniqueChainIds = (addressesByToken, tokens) => [...new Set(Object.keys(addressesByToken).map(tokenId => tokens[tokenId]?.networkId).flatMap(chainId => chainId ? [chainId] : []))];
-
-const makeContractCaller = ({
-  chainConnector,
-  chainId,
-  registry
-}) => async (callFrom, contractAddress, inputData) => registry.createType("ContractExecResult", await chainConnector.send(chainId, "state_call", ["ContractsApi_call", u8aToHex(u8aConcatStrict([
-// origin
-registry.createType("AccountId", callFrom).toU8a(),
-// dest
-registry.createType("AccountId", contractAddress).toU8a(),
-// value
-registry.createType("Balance", 0).toU8a(),
-// gasLimit
-registry.createType("Option<WeightV2>").toU8a(),
-// storageDepositLimit
-registry.createType("Option<Balance>").toU8a(),
-// inputData
-inputData instanceof Uint8Array ? inputData : inputData.toU8a()]))]));
-
-/**
- * Pass some these into an `RpcStateQueryHelper` in order to easily batch multiple state queries into the one rpc call.
- */
-
-/**
- * Used by a variety of balance modules to help batch multiple state queries into the one rpc call.
- */
-class RpcStateQueryHelper {
-  #chainConnector;
-  #queries;
-  constructor(chainConnector, queries) {
-    this.#chainConnector = chainConnector;
-    this.#queries = queries;
-  }
-  async subscribe(callback, timeout = false, subscribeMethod = "state_subscribeStorage", responseMethod = "state_storage", unsubscribeMethod = "state_unsubscribeStorage") {
-    const queriesByChain = groupBy(this.#queries, "chainId");
-    const subscriptions = Object.entries(queriesByChain).map(([chainId, queries]) => {
-      const params = [queries.map(({
-        stateKey
-      }) => stateKey)];
-      const unsub = this.#chainConnector.subscribe(chainId, 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") {
-    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.#chainConnector.send(chainId, method, params))[0];
-      return this.#distributeChangesToQueryDecoders.call(this, chainId, result);
-    }));
-    return resultsByChain.flatMap(result => result);
-  }
-  #distributeChangesToQueryDecoders(chainId, result) {
-    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]) => {
-      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 configureStore = (dbTable = db.balancesBlob) => ({
-  persistData: async balances => {
-    const output = compress(balances);
-    await dbTable.clear();
-    await dbTable.put({
-      data: output,
-      id: Date.now().toString()
-    });
-  },
-  retrieveData: async () => {
-    const compressedData = await dbTable.toCollection().first();
-    if (!compressedData) return [];
-    return decompress(compressedData.data);
-  }
-});
-const compress = balances => pako.deflate(JSON.stringify(balances));
-const decompress = data => {
-  const decompressed = pako.inflate(data, {
-    to: "string"
-  });
-  return JSON.parse(decompressed);
-};
-
-const fetchBalances$6 = async ({
-  networkId,
-  tokensWithAddresses,
-  connector,
-  miniMetadata
-}) => {
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
     log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$5} balances on ${networkId}.`);
@@ -3496,8 +3379,8 @@ const fetchBalances$6 = async ({
       }))
     };
   }
-  const queries = buildQueries$7(networkId, balanceDefs, miniMetadata);
-  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
+  const queries = buildQueries$6(networkId, balanceDefs, miniMetadata);
+  const balances = await fetchRpcQueryPack(connector, networkId, queries);
   return balanceDefs.reduce((acc, def) => {
     const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
     if (balance) acc.success.push(balance);
@@ -3524,80 +3407,6 @@ const fetchBalances$6 = async ({
     errors: []
   });
 };
-const buildQueries$7 = (networkId, balanceDefs, miniMetadata) => {
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: ["Assets", "Account"]
-  });
-  return balanceDefs.map(({
-    token,
-    address
-  }) => {
-    const scaleCoder = networkStorageCoders?.storage;
-    const stateKey = tryEncode$2(scaleCoder, Number(token.assetId), address) ??
-    // Asset Hub
-    tryEncode$2(scaleCoder, BigInt(token.assetId), address); // Astar
-
-    if (!stateKey) {
-      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
-      return null;
-    }
-    const decodeResult = change => {
-      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-      const decoded = decodeScale(scaleCoder, change, `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;
-    };
-    return {
-      chainId: networkId,
-      stateKey,
-      decodeResult
-    };
-  }).filter(isNotNil);
-};
-const tryEncode$2 = (scaleCoder, ...args) => {
-  try {
-    return scaleCoder?.keys?.enc?.(...args);
-  } catch {
-    return null;
-  }
-};
 
 const fetchTokens$5 = async ({
   networkId,
@@ -3858,93 +3667,335 @@ const tryGetConstantValue = (metadataRpc, pallet, constant) => {
   return codec.dec(encodedValue);
 };
 
-const fetchRpcQueryPack = async (connector, networkId, queries) => {
-  const allStateKeys = queries.flatMap(({
-    stateKeys
-  }) => stateKeys).filter(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 subscribeBalances$5 = ({
+  networkId,
+  tokensWithAddresses,
+  connector,
+  miniMetadata
+}) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$6(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(map(balances => ({
+    success: balances,
+    errors: []
+  })));
 };
-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 SubAssetsBalanceModule = {
+  type: MODULE_TYPE$5,
+  platform: PLATFORM$5,
+  getMiniMetadata: getMiniMetadata$6,
+  fetchTokens: fetchTokens$5,
+  fetchBalances: fetchBalances$6,
+  subscribeBalances: subscribeBalances$5,
+  getTransferCallData: getTransferCallData$5
 };
-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;
-  }, []);
+
+// to be used by chaindata too
+const SubAssetsTokenConfigSchema = z.strictObject({
+  assetId: SubAssetsTokenSchema.shape.assetId,
+  ...TokenConfigBaseSchema.shape
+});
+
+const MODULE_TYPE$4 = SubForeignAssetsTokenSchema.shape.type.value;
+const PLATFORM$4 = SubForeignAssetsTokenSchema.shape.platform.value;
+
+/**
+ * Wraps a BalanceModule's fetch/subscribe methods with a single `balances` method.
+ * This `balances` method will subscribe if a callback parameter is provided, or otherwise fetch.
+ */
+
+async function balances(balanceModule, addressesByToken, callback) {
+  // subscription request
+  if (callback !== undefined) return await balanceModule.subscribeBalances({
+    addressesByToken
+  }, callback);
+
+  // one-off request
+  return await balanceModule.fetchBalances(addressesByToken);
+}
+
+// TODO remove this one in favor of the network specific one below
+const buildStorageCoders = ({
+  chainIds,
+  chains,
+  miniMetadatas,
+  coders
+}) => new Map([...chainIds].flatMap(chainId => {
+  const chain = chains[chainId];
+  if (!chain) return [];
+  const miniMetadata = miniMetadatas.get(chainId); // findMiniMetadata<TBalanceModule>(miniMetadatas, moduleType, chain)
+  if (!miniMetadata) return [];
+  if (!miniMetadata.data) return [];
+  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
+  try {
+    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
+    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
+      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
+        chainId
+      }) : moduleMethodOrFn;
+      try {
+        return [[key, scaleBuilder.buildStorage(module, method)]];
+      } catch (cause) {
+        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
+        return [];
+      }
+    }));
+    return [[chainId, builtCoders]];
+  } catch (cause) {
+    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
+    return [];
+  }
+}));
+// type StorageCoder<TCoders extends NetworkCoders> = ReturnType<ReturnType<typeof getDynamicBuilder>["buildStorage"]>[keyof TCoders]
+
+const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
+  if (!miniMetadata.data) return null;
+  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
+  try {
+    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
+    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
+      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
+        chainId
+      }) : moduleMethodOrFn;
+      try {
+        return [[key, scaleBuilder.buildStorage(module, method)]];
+      } catch (cause) {
+        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
+        return [];
+      }
+    }));
+    return builtCoders;
+  } catch (cause) {
+    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
+  }
+  return null;
 };
 
-const subscribeBalances$5 = ({
-  networkId,
-  tokensWithAddresses,
-  connector,
-  miniMetadata
-}) => {
-  const balanceDefs = getBalanceDefs(tokensWithAddresses);
-  const queries = buildQueries$6(networkId, balanceDefs, miniMetadata);
-  return getRpcQueryPack$(connector, networkId, queries).pipe(map(balances => ({
-    success: balances,
-    errors: []
-  })));
+/**
+ * Decodes & unwraps outputs and errors of a given result, contract, and method.
+ * Parsed error message can be found in `decodedOutput` if `isError` is true.
+ * SOURCE: https://github.com/paritytech/contracts-ui (GPL-3.0-only)
+ */
+function decodeOutput({
+  result
+}, registry, abi, method) {
+  let output;
+  let decodedOutput = "";
+  let isError = true;
+  if (result.isOk) {
+    const flags = result.asOk.flags.toHuman();
+    isError = flags.includes("Revert");
+    const abiMessage = getAbiMessage(abi, method);
+    const returnType = abiMessage.returnType;
+    const returnTypeName = getReturnTypeName(returnType);
+    const r = returnType ? registry.createTypeUnsafe(returnTypeName, [result.asOk.data]).toHuman() : "()";
+    output = isOk(r) ? r.Ok : isErr(r) ? r.Err : r;
+    const errorText = isErr(output) ? typeof output.Err === "object" ? JSON.stringify(output.Err, null, 2) : output.Err?.toString() ?? "Error" : output !== "Ok" ? output?.toString() || "Error" : "Error";
+    const okText = isOk(r) ? typeof output === "object" ? JSON.stringify(output, null, "\t") : output?.toString() ?? "()" : JSON.stringify(output, null, "\t") ?? "()";
+    decodedOutput = isError ? errorText : okText;
+  } else if (result.isErr) {
+    output = result.toHuman();
+    let errorText;
+    if (isErr(output) && typeof output.Err === "object" && Object.keys(output.Err || {}).length && typeof Object.values(output.Err || {})[0] === "string") {
+      const [errorKey, errorValue] = Object.entries(output.Err || {})[0];
+      errorText = `${errorKey}${errorValue}`;
+    }
+    decodedOutput = errorText || "Error";
+  }
+  return {
+    output,
+    decodedOutput,
+    isError
+  };
+}
+
+/**
+ * Helper types & functions
+ * SOURCE: https://github.com/paritytech/contracts-ui (GPL-3.0-only)
+ */
+
+function isErr(o) {
+  return typeof o === "object" && o !== null && "Err" in o;
+}
+function isOk(o) {
+  return typeof o === "object" && o !== null && "Ok" in o;
+}
+function getReturnTypeName(type) {
+  return type?.lookupName || type?.type || "";
+}
+function getAbiMessage(abi, method) {
+  const abiMessage = abi.messages.find(m => stringCamelCase(m.method) === stringCamelCase(method));
+  if (!abiMessage) {
+    throw new Error(`"${method}" not found in Contract`);
+  }
+  return abiMessage;
+}
+
+/**
+ *
+ * Detect Balances::transfer -> Balances::transfer_allow_death migration
+ * https://github.com/paritytech/substrate/pull/12951
+ *
+ * `transfer_allow_death` is the preferred method,
+ * so if something goes wrong during detection, we should assume the chain has migrated
+ * @param metadataRpc string containing the hashed RPC metadata for the chain
+ * @returns
+ */
+const detectTransferMethod = metadataRpc => {
+  const pjsMetadata = new Metadata(new TypeRegistry(), metadataRpc);
+  pjsMetadata.registry.setMetadata(pjsMetadata);
+  const balancesPallet = pjsMetadata.asLatest.pallets.find(pallet => pallet.name.eq("Balances"));
+  const balancesCallsTypeIndex = balancesPallet?.calls.value.type.toNumber();
+  const balancesCallsType = balancesCallsTypeIndex !== undefined ? pjsMetadata.asLatest.lookup.types[balancesCallsTypeIndex] : undefined;
+  const hasDeprecatedTransferCall = balancesCallsType?.type.def.asVariant?.variants.find(variant => variant.name.eq("transfer")) !== undefined;
+  return hasDeprecatedTransferCall ? "transfer" : "transfer_allow_death";
 };
-const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
+
+const getUniqueChainIds = (addressesByToken, tokens) => [...new Set(Object.keys(addressesByToken).map(tokenId => tokens[tokenId]?.networkId).flatMap(chainId => chainId ? [chainId] : []))];
+
+const makeContractCaller = ({
+  chainConnector,
+  chainId,
+  registry
+}) => async (callFrom, contractAddress, inputData) => registry.createType("ContractExecResult", await chainConnector.send(chainId, "state_call", ["ContractsApi_call", u8aToHex(u8aConcatStrict([
+// origin
+registry.createType("AccountId", callFrom).toU8a(),
+// dest
+registry.createType("AccountId", contractAddress).toU8a(),
+// value
+registry.createType("Balance", 0).toU8a(),
+// gasLimit
+registry.createType("Option<WeightV2>").toU8a(),
+// storageDepositLimit
+registry.createType("Option<Balance>").toU8a(),
+// inputData
+inputData instanceof Uint8Array ? inputData : inputData.toU8a()]))]));
+
+/**
+ * Pass some these into an `RpcStateQueryHelper` in order to easily batch multiple state queries into the one rpc call.
+ */
+
+/**
+ * Used by a variety of balance modules to help batch multiple state queries into the one rpc call.
+ */
+class RpcStateQueryHelper {
+  #chainConnector;
+  #queries;
+  constructor(chainConnector, queries) {
+    this.#chainConnector = chainConnector;
+    this.#queries = queries;
+  }
+  async subscribe(callback, timeout = false, subscribeMethod = "state_subscribeStorage", responseMethod = "state_storage", unsubscribeMethod = "state_unsubscribeStorage") {
+    const queriesByChain = groupBy(this.#queries, "chainId");
+    const subscriptions = Object.entries(queriesByChain).map(([chainId, queries]) => {
+      const params = [queries.map(({
+        stateKey
+      }) => stateKey)];
+      const unsub = this.#chainConnector.subscribe(chainId, 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") {
+    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.#chainConnector.send(chainId, method, params))[0];
+      return this.#distributeChangesToQueryDecoders.call(this, chainId, result);
+    }));
+    return resultsByChain.flatMap(result => result);
+  }
+  #distributeChangesToQueryDecoders(chainId, result) {
+    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]) => {
+      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 configureStore = (dbTable = db.balancesBlob) => ({
+  persistData: async balances => {
+    const output = compress(balances);
+    await dbTable.clear();
+    await dbTable.put({
+      data: output,
+      id: Date.now().toString()
+    });
+  },
+  retrieveData: async () => {
+    const compressedData = await dbTable.toCollection().first();
+    if (!compressedData) return [];
+    return decompress(compressedData.data);
+  }
+});
+const compress = balances => pako.deflate(JSON.stringify(balances));
+const decompress = data => {
+  const decompressed = pako.inflate(data, {
+    to: "string"
+  });
+  return JSON.parse(decompressed);
+};
+
+const buildQueries$5 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: ["Assets", "Account"]
+    storage: ["ForeignAssets", "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
-
+    const getStateKey = onChainId => {
+      try {
+        return scaleCoder?.keys?.enc?.(papiParse(onChainId), address);
+      } catch {
+        return null;
+      }
+    };
+    const stateKey = getStateKey(token.onChainId);
     if (!stateKey) {
-      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${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 = decodeScale(scaleCoder, changes[0], `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
         balance: 0n,
+        is_frozen: false,
         status: {
           type: "Liquid"
         }};
-      const isFrozen = decoded?.status?.type === "Frozen";
+      const isFrozen = decoded.is_frozen ?? decoded?.status?.type === "Frozen";
       const amount = (decoded?.balance ?? 0n).toString();
 
       // due to the following balance calculations, which are made in the `Balance` type:
@@ -3985,32 +4036,6 @@ const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
     };
   }).filter(isNotNil);
 };
-const tryEncode$1 = (scaleCoder, ...args) => {
-  try {
-    return scaleCoder?.keys?.enc?.(...args);
-  } catch {
-    return null;
-  }
-};
-
-const SubAssetsBalanceModule = {
-  type: MODULE_TYPE$5,
-  platform: PLATFORM$5,
-  getMiniMetadata: getMiniMetadata$6,
-  fetchTokens: fetchTokens$5,
-  fetchBalances: fetchBalances$6,
-  subscribeBalances: subscribeBalances$5,
-  getTransferCallData: getTransferCallData$5
-};
-
-// to be used by chaindata too
-const SubAssetsTokenConfigSchema = z.strictObject({
-  assetId: SubAssetsTokenSchema.shape.assetId,
-  ...TokenConfigBaseSchema.shape
-});
-
-const MODULE_TYPE$4 = SubForeignAssetsTokenSchema.shape.type.value;
-const PLATFORM$4 = SubForeignAssetsTokenSchema.shape.platform.value;
 
 const fetchBalances$5 = async ({
   networkId,
@@ -4018,6 +4043,10 @@ const fetchBalances$5 = async ({
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
     log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$4} balances on ${networkId}.`);
@@ -4053,7 +4082,7 @@ const fetchBalances$5 = async ({
     };
   }
   const queries = buildQueries$5(networkId, balanceDefs, miniMetadata);
-  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
+  const balances = await fetchRpcQueryPack(connector, networkId, queries);
   return balanceDefs.reduce((acc, def) => {
     const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
     if (balance) acc.success.push(balance);
@@ -4062,95 +4091,23 @@ const fetchBalances$5 = async ({
       address: def.address,
       networkId,
       tokenId: def.token.id,
-      source: MODULE_TYPE$4,
-      status: "live",
-      values: [{
-        type: "free",
-        label: "free",
-        amount: "0"
-      }, {
-        type: "locked",
-        label: "frozen",
-        amount: "0"
-      }]
-    });
-    return acc;
-  }, {
-    success: [],
-    errors: []
-  });
-};
-const buildQueries$5 = (networkId, balanceDefs, miniMetadata) => {
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: ["ForeignAssets", "Account"]
-  });
-  return balanceDefs.map(({
-    token,
-    address
-  }) => {
-    const scaleCoder = networkStorageCoders?.storage;
-    const getStateKey = onChainId => {
-      try {
-        return scaleCoder?.keys?.enc?.(papiParse(onChainId), address);
-      } catch {
-        return null;
-      }
-    };
-    const stateKey = getStateKey(token.onChainId);
-    if (!stateKey) {
-      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${address}`);
-      return null;
-    }
-    const decodeResult = change => {
-      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-      const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
-        balance: 0n,
-        is_frozen: false,
-        status: {
-          type: "Liquid"
-        }};
-      const isFrozen = decoded.is_frozen ?? 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;
-    };
-    return {
-      chainId: networkId,
-      stateKey,
-      decodeResult
-    };
-  }).filter(isNotNil);
+      source: MODULE_TYPE$4,
+      status: "live",
+      values: [{
+        type: "free",
+        label: "free",
+        amount: "0"
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: "0"
+      }]
+    });
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
 };
 
 const fetchTokens$4 = async ({
@@ -4349,46 +4306,22 @@ const getTransferAllEncodedArgs$1 = (onChainId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$3 = 6_000;
 const subscribeBalances$4 = ({
   networkId,
   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$5({
-          networkId,
-          tokensWithAddresses: tokensWithAddresses,
-          connector,
-          miniMetadata
-        });
-        if (abortController.signal.aborted) return;
-        subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
-      } catch (error) {
-        log.error("Error", {
-          module: MODULE_TYPE$4,
-          networkId,
-          miniMetadata,
-          addressesByToken: tokensWithAddresses,
-          error
-        });
-        subscriber.error(error);
-      }
-    };
-    poll();
-    return () => {
-      abortController.abort();
-    };
-  }).pipe(distinctUntilChanged(isEqual));
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$5(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(map(balances => ({
+    success: balances,
+    errors: []
+  })));
 };
 
 const SubForeignAssetsBalanceModule = {
@@ -4422,9 +4355,15 @@ const fetchBalances$4 = async ({
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$3} balances on ${networkId}.`);
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$3} balances on ${networkId}.`, {
+      tokensWithAddresses
+    });
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -4480,7 +4419,7 @@ const fetchBalances$4 = async ({
           networkId,
           tokenId: token.id,
           source: MODULE_TYPE$3,
-          status: "cache",
+          status: "live",
           values: [{
             type: "free",
             label: "free",
@@ -4671,13 +4610,17 @@ const getTransferCallData$3 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$2 = 6_000;
+const SUBSCRIPTION_INTERVAL$1 = 6_000;
 const subscribeBalances$3 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
   return new Observable(subscriber => {
     const abortController = new AbortController();
 
@@ -4694,7 +4637,7 @@ const subscribeBalances$3 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$1);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$3,
@@ -5443,6 +5386,10 @@ const fetchBalances$3 = async ({
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
     log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$2} balances on ${networkId}.`);
@@ -5724,6 +5671,11 @@ const subscribeBalances$2 = ({
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+
   // could be use as shared observable key if we decide to cache the sub
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const baseQueries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
@@ -6927,6 +6879,10 @@ const fetchBalances$2 = async ({
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!balanceDefs.length) return {
     success: [],
@@ -7114,13 +7070,17 @@ const getTransferCallData$1 = async ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$1 = 6_000;
+const SUBSCRIPTION_INTERVAL = 6_000;
 const subscribeBalances$1 = ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
   return new Observable(subscriber => {
     const abortController = new AbortController();
 
@@ -7137,7 +7097,7 @@ const subscribeBalances$1 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$1);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$1,
@@ -7175,12 +7135,77 @@ const SubPsp22TokenConfigSchema = z.strictObject({
 const MODULE_TYPE = SubTokensTokenSchema.shape.type.value;
 const PLATFORM = SubTokensTokenSchema.shape.platform.value;
 
+const buildQueries$4 = (networkId, balanceDefs, miniMetadata) => {
+  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
+    storage: [miniMetadata.extra.palletId, "Accounts"]
+  });
+  return balanceDefs.map(({
+    token,
+    address
+  }) => {
+    const scaleCoder = networkStorageCoders?.storage;
+    const getStateKey = onChainId => {
+      try {
+        return scaleCoder.keys.enc(address, papiParse(onChainId));
+      } catch {
+        return null;
+      }
+    };
+    const stateKey = getStateKey(token.onChainId);
+    if (!stateKey) {
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${address}`);
+      return null;
+    }
+    const decodeResult = changes => {
+      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+      const decoded = decodeScale(scaleCoder, changes[0], `Failed to decode substrate-tokens balance on chain ${networkId}`) ?? {
+        free: 0n,
+        reserved: 0n,
+        frozen: 0n
+      };
+      const free = (decoded?.free ?? 0n).toString();
+      const reserved = (decoded?.reserved ?? 0n).toString();
+      const frozen = (decoded?.frozen ?? 0n).toString();
+      const balanceValues = [{
+        type: "free",
+        label: "free",
+        amount: free.toString()
+      }, {
+        type: "reserved",
+        label: "reserved",
+        amount: reserved.toString()
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: frozen.toString()
+      }];
+      return {
+        source: "substrate-tokens",
+        status: "live",
+        address,
+        networkId,
+        tokenId: token.id,
+        values: balanceValues
+      };
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  }).filter(isNotNil);
+};
+
 const fetchBalances$1 = async ({
   networkId,
   tokensWithAddresses,
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
     log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE} balances on ${networkId}.`);
@@ -7216,7 +7241,7 @@ const fetchBalances$1 = async ({
     };
   }
   const queries = buildQueries$4(networkId, balanceDefs, miniMetadata);
-  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
+  const balances = await fetchRpcQueryPack(connector, networkId, queries);
   return balanceDefs.reduce((acc, def) => {
     const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
     if (balance) acc.success.push(balance);
@@ -7243,67 +7268,6 @@ const fetchBalances$1 = async ({
     errors: []
   });
 };
-const buildQueries$4 = (networkId, balanceDefs, miniMetadata) => {
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: [miniMetadata.extra.palletId, "Accounts"]
-  });
-  return balanceDefs.map(({
-    token,
-    address
-  }) => {
-    const scaleCoder = networkStorageCoders?.storage;
-    const getStateKey = onChainId => {
-      try {
-        return scaleCoder.keys.enc(address, papiParse(onChainId));
-      } catch {
-        return null;
-      }
-    };
-    const stateKey = getStateKey(token.onChainId);
-    if (!stateKey) {
-      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${address}`);
-      return null;
-    }
-    const decodeResult = change => {
-      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-      const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-tokens balance on chain ${networkId}`) ?? {
-        free: 0n,
-        reserved: 0n,
-        frozen: 0n
-      };
-      const free = (decoded?.free ?? 0n).toString();
-      const reserved = (decoded?.reserved ?? 0n).toString();
-      const frozen = (decoded?.frozen ?? 0n).toString();
-      const balanceValues = [{
-        type: "free",
-        label: "free",
-        amount: free.toString()
-      }, {
-        type: "reserved",
-        label: "reserved",
-        amount: reserved.toString()
-      }, {
-        type: "locked",
-        label: "frozen",
-        amount: frozen.toString()
-      }];
-      return {
-        source: "substrate-tokens",
-        status: "live",
-        address,
-        networkId,
-        tokenId: token.id,
-        values: balanceValues
-      };
-    };
-    return {
-      chainId: networkId,
-      stateKey,
-      decodeResult
-    };
-  }).filter(isNotNil);
-};
 
 const fetchTokens = async ({
   networkId,
@@ -7504,46 +7468,22 @@ const getCallDataOptions = (to, token, value, type, config) => {
   }] : []));
 };
 
-const SUBSCRIPTION_INTERVAL = 6_000;
 const subscribeBalances = ({
   networkId,
   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$1({
-          networkId,
-          tokensWithAddresses: tokensWithAddresses,
-          connector,
-          miniMetadata
-        });
-        if (abortController.signal.aborted) return;
-        subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL);
-      } catch (error) {
-        log.error("Error", {
-          module: MODULE_TYPE,
-          networkId,
-          miniMetadata,
-          addressesByToken: tokensWithAddresses,
-          error
-        });
-        subscriber.error(error);
-      }
-    };
-    poll();
-    return () => {
-      abortController.abort();
-    };
-  }).pipe(distinctUntilChanged(isEqual));
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$4(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(map(balances => ({
+    success: balances,
+    errors: []
+  })));
 };
 
 const SubTokensBalanceModule = {
@@ -10413,14 +10353,18 @@ class BalancesProvider {
       acc[networkId][tokenId] = addresses;
       return acc;
     }, {});
-    return combineLatest(toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId]))).pipe(map(results => {
-      return {
-        status: results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances)
-      };
-    }), startWith({
+    return combineLatest({
+      isStale: timer(30_000).pipe(map(() => true), startWith(false)),
+      results: combineLatest(toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
+    }).pipe(map(({
+      isStale,
+      results
+    }) => ({
+      status: !isStale && results.some(({
+        status
+      }) => status === "initialising") ? "initialising" : "live",
+      balances: results.flatMap(result => result.balances)
+    })), startWith({
       status: "initialising",
       balances: this.getStoredBalances(addressesByTokenId)
     }), distinctUntilChanged(isEqual));