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

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) {
@@ -1779,12 +1783,16 @@ const getTransferCallData$8 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$7 = 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 +1805,7 @@ const subscribeBalances$8 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$7);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$8,
@@ -1843,6 +1851,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) {
@@ -1993,12 +2005,16 @@ const getTransferCallData$7 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$6 = 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 +2027,7 @@ const subscribeBalances$7 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$7,
@@ -2052,6 +2068,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) {
@@ -2326,12 +2346,16 @@ const getTransferCallData$6 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$5 = 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 +2368,7 @@ const subscribeBalances$6 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
       } catch (error) {
         log.error("Error", {
           module: MODULE_TYPE$6,
@@ -3208,273 +3232,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}.`);
@@ -3510,7 +3399,7 @@ const fetchBalances$6 = async ({
     };
   }
   const queries = buildQueries$6(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);
@@ -3537,80 +3426,6 @@ const fetchBalances$6 = async ({
     errors: []
   });
 };
-const buildQueries$6 = (networkId, balanceDefs, miniMetadata) => {
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: ["Assets", "Account"]
-  });
-  return balanceDefs.map(({
-    token,
-    address
-  }) => {
-    const scaleCoder = networkStorageCoders?.storage;
-    const stateKey = tryEncode$1(scaleCoder, Number(token.assetId), address) ??
-    // Asset Hub
-    tryEncode$1(scaleCoder, BigInt(token.assetId), address); // Astar
-
-    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$1 = (scaleCoder, ...args) => {
-  try {
-    return scaleCoder?.keys?.enc?.(...args);
-  } catch {
-    return null;
-  }
-};
 
 const fetchTokens$5 = async ({
   networkId,
@@ -3847,47 +3662,47 @@ const getTransferAllEncodedArgs$2 = (assetId, to, codec) => {
   })]);
 };
 
-const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const call = builder.buildRuntimeCall(apiName, method);
+  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, scale.toHex(call.args.enc(args))]);
+  return call.value.dec(hex);
+};
+
+const tryGetConstantValue = (metadataRpc, pallet, constant) => {
+  const {
+    unifiedMetadata,
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const encodedValue = unifiedMetadata.pallets.find(({
+    name
+  }) => name === pallet)?.constants.find(({
+    name
+  }) => name === constant)?.value;
+  if (!encodedValue) return null;
+  const codec = builder.buildConstant(pallet, constant);
+  return codec.dec(encodedValue);
+};
+
 const subscribeBalances$5 = ({
   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$6({
-          networkId,
-          tokensWithAddresses: tokensWithAddresses,
-          connector,
-          miniMetadata
-        });
-        if (abortController.signal.aborted) return;
-        subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
-      } catch (error) {
-        log.error("Error", {
-          module: MODULE_TYPE$5,
-          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$6(networkId, balanceDefs, miniMetadata);
+  return getRpcQueryPack$(connector, networkId, queries).pipe(rxjs.map(balances => ({
+    success: balances,
+    errors: []
+  })));
+};
 
 const SubAssetsBalanceModule = {
   type: MODULE_TYPE$5,
@@ -3908,74 +3723,267 @@ const SubAssetsTokenConfigSchema = z__default.default.strictObject({
 const MODULE_TYPE$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.type.value;
 const PLATFORM$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.platform.value;
 
-const fetchBalances$5 = async ({
-  networkId,
-  tokensWithAddresses,
-  connector,
-  miniMetadata
-}) => {
-  const balanceDefs = getBalanceDefs(tokensWithAddresses);
-  if (!miniMetadata?.data) {
-    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$4} balances on ${networkId}.`);
-    return {
-      success: [],
-      errors: balanceDefs.map(def => ({
-        tokenId: def.token.id,
-        address: def.address,
-        error: new Error("Minimetadata is required for fetching balances")
-      }))
-    };
+/**
+ * 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 [];
   }
-  if (miniMetadata.source !== MODULE_TYPE$4) {
-    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$4}.`);
-    return {
-      success: [],
-      errors: balanceDefs.map(def => ({
-        tokenId: def.token.id,
-        address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$4}`)
-      }))
-    };
+}));
+// 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);
   }
-  if (miniMetadata.chainId !== networkId) {
-    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$4}. Expected chainId is ${networkId}`);
-    return {
-      success: [],
-      errors: balanceDefs.map(def => ({
-        tokenId: def.token.id,
-        address: def.address,
-        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
-      }))
-    };
+  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";
   }
-  const queries = buildQueries$5(networkId, balanceDefs, miniMetadata);
-  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
-  return balanceDefs.reduce((acc, def) => {
-    const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
-    if (balance) acc.success.push(balance);
-    //if no entry consider empty balance
-    else acc.success.push({
-      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 {
+    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 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 acc;
-  }, {
-    success: [],
-    errors: []
+    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: ["ForeignAssets", "Account"]
@@ -3997,10 +4005,10 @@ const buildQueries$5 = (networkId, balanceDefs, miniMetadata) => {
       log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${address}`);
       return null;
     }
-    const decodeResult = change => {
+    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, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
+      const decoded = scale.decodeScale(scaleCoder, changes[0], `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
         balance: 0n,
         is_frozen: false,
         status: {
@@ -4042,13 +4050,85 @@ const buildQueries$5 = (networkId, balanceDefs, miniMetadata) => {
       return balance;
     };
     return {
-      chainId: networkId,
-      stateKey,
+      stateKeys: [stateKey],
       decodeResult
     };
   }).filter(util.isNotNil);
 };
 
+const fetchBalances$5 = 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$4} balances on ${networkId}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE$4) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$4}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$4}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$4}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const queries = buildQueries$5(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);
+    //if no entry consider empty balance
+    else acc.success.push({
+      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 fetchTokens$4 = async ({
   networkId,
   tokens,
@@ -4245,46 +4325,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 = {
@@ -4303,48 +4359,30 @@ const SubForeignAssetsTokenConfigSchema = z__default.default.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-// to be used by chaindata too
-const SubHydrationTokenConfigSchema = z__default.default.strictObject({
-  onChainId: chaindataProvider.SubHydrationTokenSchema.shape.onChainId,
-  ...TokenConfigBaseSchema.shape
-});
-
-const MODULE_TYPE$3 = chaindataProvider.SubHydrationTokenSchema.shape.type.value;
-const PLATFORM$3 = chaindataProvider.SubHydrationTokenSchema.shape.platform.value;
-
-const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
-  const {
-    builder
-  } = scale.parseMetadataRpc(metadataRpc);
-  const call = builder.buildRuntimeCall(apiName, method);
-  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, scale.toHex(call.args.enc(args))]);
-  return call.value.dec(hex);
-};
-
-const tryGetConstantValue = (metadataRpc, pallet, constant) => {
-  const {
-    unifiedMetadata,
-    builder
-  } = scale.parseMetadataRpc(metadataRpc);
-  const encodedValue = unifiedMetadata.pallets.find(({
-    name
-  }) => name === pallet)?.constants.find(({
-    name
-  }) => name === constant)?.value;
-  if (!encodedValue) return null;
-  const codec = builder.buildConstant(pallet, constant);
-  return codec.dec(encodedValue);
-};
-
+// to be used by chaindata too
+const SubHydrationTokenConfigSchema = z__default.default.strictObject({
+  onChainId: chaindataProvider.SubHydrationTokenSchema.shape.onChainId,
+  ...TokenConfigBaseSchema.shape
+});
+
+const MODULE_TYPE$3 = chaindataProvider.SubHydrationTokenSchema.shape.type.value;
+const PLATFORM$3 = chaindataProvider.SubHydrationTokenSchema.shape.platform.value;
+
 const fetchBalances$4 = 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$3} balances on ${networkId}.`);
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$3} balances on ${networkId}.`, {
+      tokensWithAddresses
+    });
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -4591,13 +4629,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();
 
@@ -4614,7 +4656,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,
@@ -4646,54 +4688,6 @@ const SubHydrationBalanceModule = {
 const MODULE_TYPE$2 = chaindataProvider.SubNativeTokenSchema.shape.type.value;
 const PLATFORM$2 = chaindataProvider.SubNativeTokenSchema.shape.platform.value;
 
-const fetchRpcQueryPack = async (connector, networkId, queries) => {
-  const allStateKeys = queries.flatMap(({
-    stateKeys
-  }) => stateKeys).filter(util.isNotNil);
-
-  // doing a query without keys would throw an error => return early
-  if (!allStateKeys.length) return queries.map(({
-    stateKeys,
-    decodeResult
-  }) => decodeResult(stateKeys.map(() => null)));
-  const [result] = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
-  return decodeRpcQueryPack(queries, result);
-};
-const getRpcQueryPack$ = (connector, networkId, queries, timeout = false) => {
-  const allStateKeys = queries.flatMap(({
-    stateKeys
-  }) => stateKeys).filter(util.isNotNil);
-
-  // doing a query without keys would throw an error => return early
-  if (!allStateKeys.length) return rxjs.of(queries.map(({
-    stateKeys,
-    decodeResult
-  }) => decodeResult(stateKeys.map(() => null))));
-  return new rxjs.Observable(subscriber => {
-    const promUnsub = connector.subscribe(networkId, "state_subscribeStorage", "state_storage", [allStateKeys], (error, result) => {
-      if (error) subscriber.error(error);else subscriber.next(decodeRpcQueryPack(queries, result));
-    }, timeout);
-    return () => {
-      promUnsub.then(unsub => unsub("state_unsubscribeStorage"));
-    };
-  });
-};
-const decodeRpcQueryPack = (queries, result) => {
-  return queries.reduce((acc, {
-    stateKeys,
-    decodeResult
-  }) => {
-    const changes = stateKeys.map(stateKey => {
-      if (!stateKey) return null;
-      const change = result.changes.find(([key]) => key === stateKey);
-      if (!change) return null;
-      return change[1];
-    });
-    acc.push(decodeResult(changes));
-    return acc;
-  }, []);
-};
-
 const SUBTENSOR_ROOT_NETUID$1 = 0;
 const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1 = 1000000n;
 const TAO_DECIMALS$1 = 9n;
@@ -5411,6 +5405,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}.`);
@@ -5692,6 +5690,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);
@@ -6895,6 +6898,10 @@ const fetchBalances$2 = async ({
   tokensWithAddresses,
   connector
 }) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!balanceDefs.length) return {
     success: [],
@@ -7082,13 +7089,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();
 
@@ -7105,7 +7116,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,
@@ -7143,12 +7154,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}.`);
@@ -7184,7 +7260,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);
@@ -7211,67 +7287,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,
@@ -7472,46 +7487,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 = {
@@ -10371,9 +10362,17 @@ class BalancesProvider {
       miniMetadatas: lodash.values(miniMetadatas).filter(util.isNotNil)
     })));
   }
-  getBalances$(addressesByToken) {
-    const networkIds = lodash.uniq(lodash.keys(addressesByToken).map(tokenId => chaindataProvider.parseTokenId(tokenId).networkId));
-    return rxjs.combineLatest(networkIds.map(networkId => this.getNetworkBalances$(networkId, addressesByToken))).pipe(rxjs.map(results => {
+
+  // this is the only public method
+  getBalances$(addressesByTokenId) {
+    // split by network
+    const addressesByTokenIdByNetworkId = lodash.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
+      const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
+      if (!acc[networkId]) acc[networkId] = {};
+      acc[networkId][tokenId] = addresses;
+      return acc;
+    }, {});
+    return rxjs.combineLatest(lodash.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId]))).pipe(rxjs.map(results => {
       return {
         status: results.some(({
           status
@@ -10382,9 +10381,17 @@ class BalancesProvider {
       };
     }), rxjs.startWith({
       status: "initialising",
-      balances: this.getStoredBalances(addressesByToken)
+      balances: this.getStoredBalances(addressesByTokenId)
     }), rxjs.distinctUntilChanged(lodash.isEqual));
   }
+  fetchBalances(addressesByTokenId) {
+    // TODO: better
+    return rxjs.firstValueFrom(this.getBalances$(addressesByTokenId).pipe(rxjs.filter(({
+      status
+    }) => status === "live"), rxjs.map(({
+      balances
+    }) => balances)));
+  }
   getNetworkBalances$(networkId, addressesByTokenId) {
     const network$ = this.#chaindataProvider.getNetworkById$(networkId);
     const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
@@ -10456,7 +10463,42 @@ class BalancesProvider {
     }));
   }
   getNetworkMiniMetadatas$(networkId) {
-    return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) && this.#chainConnectors.substrate ? rxjs.from(getMiniMetadatas(this.#chainConnectors.substrate, this.#chaindataProvider, networkId)) : rxjs.of([])));
+    return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) && this.#chainConnectors.substrate ? rxjs.from(getSpecVersion(this.#chainConnectors.substrate, networkId)).pipe(rxjs.switchMap(specVersion => this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])));
+  }
+  getMiniMetadatas$(networkId, specVersion) {
+    return rxjs.combineLatest({
+      defaultMiniMetadatas: this.getDefaultMiniMetadatas$(networkId, specVersion),
+      storedMiniMetadatas: this.getStoredMiniMetadatas$(networkId, specVersion)
+    }).pipe(rxjs.switchMap(({
+      storedMiniMetadatas,
+      defaultMiniMetadatas
+    }) => {
+      if (defaultMiniMetadatas.length) return rxjs.of(defaultMiniMetadatas);
+      if (storedMiniMetadatas.length) return rxjs.of(storedMiniMetadatas);
+      if (!this.#chainConnectors.substrate) return rxjs.of([]);
+      return rxjs.from(
+      // fetch them from the chain
+      getMiniMetadatas(this.#chainConnectors.substrate, this.#chaindataProvider, networkId)).pipe(
+      // and persist in storage for later reuse
+      rxjs.tap(newMiniMetadatas => {
+        if (!newMiniMetadatas.length) return;
+        const storage = this.#storage.getValue();
+        const miniMetadatas = lodash.assign(
+        // keep minimetadatas of other networks
+        lodash.keyBy(lodash.values(storage.miniMetadatas).filter(m => m.chainId !== networkId), m => m.id),
+        // add the ones for our network
+        lodash.keyBy(newMiniMetadatas, m => m.id));
+        this.#storage.next(lodash.assign({}, storage, {
+          miniMetadatas
+        }));
+      }));
+    }));
+  }
+  getStoredMiniMetadatas$(networkId, specVersion) {
+    return this.storage$.pipe(rxjs.map(storage => storage.miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodash.isEqual));
+  }
+  getDefaultMiniMetadatas$(networkId, specVersion) {
+    return this.#chaindataProvider.miniMetadatas$.pipe(rxjs.map(miniMetadatas => miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodash.isEqual));
   }
   getStoredBalances(addressesByToken) {
     const balanceDefs = lodash.toPairs(addressesByToken).flatMap(([tokenId, addresses]) => addresses.map(address => [tokenId, address]));
@@ -10467,13 +10509,6 @@ class BalancesProvider {
   }
 }
 
-// const getStoredBalances = (
-//   storedBalances: Record<string, IBalance>,
-//   addressesByToken: Record<TokenId, Address[]>,
-// ): IBalance[] => {
-
-// }
-
 Object.defineProperty(exports, "MINIMETADATA_VERSION", {
   enumerable: true,
   get: function () { return chaindataProvider.MINIMETADATA_VERSION; }