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

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

@@ -15,10 +15,10 @@ var z = require('zod/v4');
 var rxjs = require('rxjs');
 var isEqual = require('lodash/isEqual');
 var scale = require('@talismn/scale');
-var types = require('@polkadot/types');
-var groupBy = require('lodash/groupBy');
 var utils = require('@polkadot-api/utils');
 var polkadotApi = require('polkadot-api');
+var types = require('@polkadot/types');
+var groupBy = require('lodash/groupBy');
 var upperFirst = require('lodash/upperFirst');
 var scaleTs = require('scale-ts');
 var apiContract = require('@polkadot/api-contract');
@@ -1553,6 +1553,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) {
@@ -1571,7 +1575,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
@@ -1589,7 +1592,7 @@ const fetchWithoutAggregator$1 = async (client, balanceDefs) => {
         value: result.toString(),
         source: MODULE_TYPE$8,
         networkId: chaindataProvider.parseEvmErc20TokenId(token.id).networkId,
-        status: "cache"
+        status: "live"
       };
       return balance;
     } catch (err) {
@@ -1616,7 +1619,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,
@@ -1633,7 +1635,7 @@ const fetchWithAggregator$1 = async (client, balanceDefs, erc20BalancesAggregato
       value: erc20Balances[index].toString(),
       source: MODULE_TYPE$8,
       networkId: chaindataProvider.parseTokenId(balanceDef.token.id).networkId,
-      status: "cache"
+      status: "live"
     }));
     return {
       success,
@@ -1779,12 +1781,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 rxjs.of({
+    success: [],
+    errors: []
+  });
   return new rxjs.Observable(subscriber => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -1797,7 +1803,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,
@@ -1843,6 +1849,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) {
@@ -1861,7 +1871,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
@@ -1903,7 +1912,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(({
@@ -1993,12 +2001,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 rxjs.of({
+    success: [],
+    errors: []
+  });
   return new rxjs.Observable(subscriber => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -2011,7 +2023,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,
@@ -2052,6 +2064,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) {
@@ -2070,7 +2086,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
@@ -2088,7 +2103,7 @@ const fetchWithoutAggregator = async (client, balanceDefs) => {
         value: result.toString(),
         source: MODULE_TYPE$6,
         networkId: chaindataProvider.parseTokenId(token.id).networkId,
-        status: "cache"
+        status: "live"
       };
       return balance;
     } catch (err) {
@@ -2115,7 +2130,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,
@@ -2132,7 +2146,7 @@ const fetchWithAggregator = async (client, balanceDefs, erc20BalancesAggregatorA
       value: erc20Balances[index].toString(),
       source: MODULE_TYPE$6,
       networkId: chaindataProvider.parseTokenId(balanceDef.token.id).networkId,
-      status: "cache"
+      status: "live"
     }));
     return {
       success,
@@ -2326,12 +2340,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 rxjs.of({
+    success: [],
+    errors: []
+  });
   return new rxjs.Observable(subscriber => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -2344,7 +2362,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,
@@ -3208,273 +3226,138 @@ async function getPoolBalance(publicClient, contractAddress, accountAddress) {
 const MODULE_TYPE$5 = chaindataProvider.SubAssetsTokenSchema.shape.type.value;
 const PLATFORM$5 = chaindataProvider.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(util.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(util.isNotNil);
 
-  // one-off request
-  return await balanceModule.fetchBalances(addressesByToken);
-}
+  // 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;
+  }, []);
+};
 
-// 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 = scale.unifyMetadata(scale.decAnyMetadata(miniMetadata.data));
-  try {
-    const scaleBuilder = scale.getDynamicBuilder(scale.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 = scale.unifyMetadata(scale.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 = 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;
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  }).filter(util.isNotNil);
+};
+const tryEncode$1 = (scaleCoder, ...args) => {
   try {
-    const scaleBuilder = scale.getDynamicBuilder(scale.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 => util$1.stringCamelCase(m.method) === util$1.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 types.Metadata(new types.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", util$1.u8aToHex(util$1.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__default.default(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__default.default(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 (!util.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__default.default.deflate(JSON.stringify(balances));
-const decompress = data => {
-  const decompressed = pako__default.default.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}.`);
@@ -3509,8 +3392,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);
@@ -3537,80 +3420,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 = scale.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(util.isNotNil);
-};
-const tryEncode$2 = (scaleCoder, ...args) => {
-  try {
-    return scaleCoder?.keys?.enc?.(...args);
-  } catch {
-    return null;
-  }
-};
 
 const fetchTokens$5 = async ({
   networkId,
@@ -3871,93 +3680,335 @@ const tryGetConstantValue = (metadataRpc, 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 subscribeBalances$5 = ({
+  networkId,
+  tokensWithAddresses,
+  connector,
+  miniMetadata
+}) => {
+  if (!tokensWithAddresses.length) return rxjs.of({
+    success: [],
+    errors: []
+  });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$6(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(rxjs.map(balances => ({
+    success: balances,
+    errors: []
+  })));
 };
-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 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__default.default.strictObject({
+  assetId: chaindataProvider.SubAssetsTokenSchema.shape.assetId,
+  ...TokenConfigBaseSchema.shape
+});
+
+const MODULE_TYPE$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.type.value;
+const PLATFORM$4 = chaindataProvider.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 = scale.unifyMetadata(scale.decAnyMetadata(miniMetadata.data));
+  try {
+    const scaleBuilder = scale.getDynamicBuilder(scale.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 = scale.unifyMetadata(scale.decAnyMetadata(miniMetadata.data));
+  try {
+    const scaleBuilder = scale.getDynamicBuilder(scale.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(rxjs.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 => util$1.stringCamelCase(m.method) === util$1.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 types.Metadata(new types.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", util$1.u8aToHex(util$1.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__default.default(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__default.default(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 (!util.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__default.default.deflate(JSON.stringify(balances));
+const decompress = data => {
+  const decompressed = pako__default.default.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?.(scale.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 = scale.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:
@@ -3998,32 +4049,6 @@ const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
     };
   }).filter(util.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__default.default.strictObject({
-  assetId: chaindataProvider.SubAssetsTokenSchema.shape.assetId,
-  ...TokenConfigBaseSchema.shape
-});
-
-const MODULE_TYPE$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.type.value;
-const PLATFORM$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.platform.value;
 
 const fetchBalances$5 = async ({
   networkId,
@@ -4031,6 +4056,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}.`);
@@ -4066,7 +4095,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);
@@ -4075,95 +4104,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?.(scale.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 = scale.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(util.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 ({
@@ -4362,46 +4319,22 @@ const getTransferAllEncodedArgs$1 = (onChainId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$3 = 6_000;
 const subscribeBalances$4 = ({
   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$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(rxjs.distinctUntilChanged(lodash.isEqual));
+  if (!tokensWithAddresses.length) return rxjs.of({
+    success: [],
+    errors: []
+  });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$5(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(rxjs.map(balances => ({
+    success: balances,
+    errors: []
+  })));
 };
 
 const SubForeignAssetsBalanceModule = {
@@ -4435,9 +4368,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 => ({
@@ -4493,7 +4432,7 @@ const fetchBalances$4 = async ({
           networkId,
           tokenId: token.id,
           source: MODULE_TYPE$3,
-          status: "cache",
+          status: "live",
           values: [{
             type: "free",
             label: "free",
@@ -4684,13 +4623,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 rxjs.of({
+    success: [],
+    errors: []
+  });
   return new rxjs.Observable(subscriber => {
     const abortController = new AbortController();
 
@@ -4707,7 +4650,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,
@@ -5456,6 +5399,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}.`);
@@ -5737,6 +5684,11 @@ const subscribeBalances$2 = ({
   connector,
   miniMetadata
 }) => {
+  if (!tokensWithAddresses.length) return rxjs.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);
@@ -6940,6 +6892,10 @@ const fetchBalances$2 = async ({
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!balanceDefs.length) return {
     success: [],
@@ -7127,13 +7083,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 rxjs.of({
+    success: [],
+    errors: []
+  });
   return new rxjs.Observable(subscriber => {
     const abortController = new AbortController();
 
@@ -7150,7 +7110,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,
@@ -7188,12 +7148,77 @@ const SubPsp22TokenConfigSchema = z__default.default.strictObject({
 const MODULE_TYPE = chaindataProvider.SubTokensTokenSchema.shape.type.value;
 const PLATFORM = chaindataProvider.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, scale.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 = scale.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(util.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}.`);
@@ -7229,7 +7254,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);
@@ -7256,67 +7281,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, scale.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 = scale.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(util.isNotNil);
-};
 
 const fetchTokens = async ({
   networkId,
@@ -7517,46 +7481,22 @@ const getCallDataOptions = (to, token, value, type, config) => {
   }] : []));
 };
 
-const SUBSCRIPTION_INTERVAL = 6_000;
 const subscribeBalances = ({
   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$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(rxjs.distinctUntilChanged(lodash.isEqual));
+  if (!tokensWithAddresses.length) return rxjs.of({
+    success: [],
+    errors: []
+  });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  const queries = buildQueries$4(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(rxjs.map(balances => ({
+    success: balances,
+    errors: []
+  })));
 };
 
 const SubTokensBalanceModule = {
@@ -10426,14 +10366,18 @@ class BalancesProvider {
       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
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances)
-      };
-    }), rxjs.startWith({
+    return rxjs.combineLatest({
+      isStale: rxjs.timer(30_000).pipe(rxjs.map(() => true), rxjs.startWith(false)),
+      results: rxjs.combineLatest(lodash.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
+    }).pipe(rxjs.map(({
+      isStale,
+      results
+    }) => ({
+      status: !isStale && results.some(({
+        status
+      }) => status === "initialising") ? "initialising" : "live",
+      balances: results.flatMap(result => result.balances)
+    })), rxjs.startWith({
       status: "initialising",
       balances: this.getStoredBalances(addressesByTokenId)
     }), rxjs.distinctUntilChanged(lodash.isEqual));