@talismn/balances 0.0.0-pr2043-20250703063959 → 0.0.0-pr2059-20250626001054

package/dist/talismn-balances.esm.js

@@ -1,30 +1,29 @@
-import { Dexie } from 'dexie';
+import PromisePool$1, { PromisePool } from '@supercharge/promise-pool';
+import { fetchMiniMetadatas, fetchInitMiniMetadatas, availableTokenLogoFilenames, githubTokenLogoUrl } from '@talismn/chaindata-provider';
+import { fetchBestMetadata, getScaleApi } from '@talismn/sapi';
+import { Dexie, liveQuery } from 'dexie';
+import isEqual from 'lodash/isEqual';
+import { from, Observable, scan, share, map, switchAll, combineLatest, mergeMap, toArray, interval, startWith, exhaustMap, pipe, filter, shareReplay, combineLatestWith, distinctUntilChanged, firstValueFrom, BehaviorSubject, debounceTime, takeUntil, switchMap, withLatestFrom, concatMap } from 'rxjs';
 import anylogger from 'anylogger';
-import { evmErc20TokenId, TokenBaseSchema, EvmErc20TokenSchema, networkIdFromTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, getGithubTokenLogoUrl, DotNetworkBalancesConfigSchema, SubAssetsTokenSchema, parseSubAssetTokenId, subAssetTokenId, SubForeignAssetsTokenSchema, parseSubForeignAssetTokenId, subForeignAssetTokenId, parseTokenId, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, parseSubTokensTokenId, subTokensTokenId } from '@talismn/chaindata-provider';
 import { newTokenRates } from '@talismn/token-rates';
-import { isBigInt, BigMath, planckToTokens, isArrayOf, isTruthy, isEthereumAddress, hasOwnProperty, isAbortError, isNotNil, decodeAnyAddress, blake2Concat, Deferred } from '@talismn/util';
+import { isBigInt, BigMath, planckToTokens, isTruthy, isArrayOf, isEthereumAddress, hasOwnProperty, decodeAnyAddress, isNotNil, blake2Concat, firstThenDebounce, Deferred } from '@talismn/util';
 import BigNumber from 'bignumber.js';
-import { u8aToHex, assert, stringCamelCase, u8aConcatStrict, arrayChunk, u8aToString, hexToNumber, hexToU8a } from '@polkadot/util';
-import { xxhashAsU8a } from '@polkadot/util-crypto';
+import { u8aToHex, assert, stringCamelCase, u8aConcatStrict, u8aConcat, arrayChunk, u8aToString, hexToNumber, hexToU8a } from '@polkadot/util';
+import { xxhashAsU8a, blake2AsU8a } from '@polkadot/util-crypto';
 import pako from 'pako';
-import z from 'zod/v4';
 import { parseAbi, isHex, hexToBigInt } from 'viem';
-import { fromPairs, toPairs, keys, groupBy as groupBy$1 } from 'lodash';
-import isEqual from 'lodash/isEqual';
 import { defineMethod } from '@substrate/txwrapper-core';
-import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, compactMetadata, encodeMetadata, decodeScale, papiParse, getMetadataVersion, encodeStateKey } from '@talismn/scale';
+import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, getMetadataVersion, compactMetadata, encodeMetadata, decodeScale, encodeStateKey, papiParse } from '@talismn/scale';
 import camelCase from 'lodash/camelCase';
-import PQueue from 'p-queue';
-import { fetchBestMetadata, getScaleApi } from '@talismn/sapi';
 import { Metadata, TypeRegistry } from '@polkadot/types';
 import groupBy from 'lodash/groupBy';
 import { mergeUint8, toHex } from '@polkadot-api/utils';
 import { Binary, AccountId } from 'polkadot-api';
 import { ChainConnectionError } from '@talismn/chain-connector';
-import { Observable, scan, share, map, switchAll, combineLatest, from, mergeMap, toArray, interval, startWith, exhaustMap, BehaviorSubject, debounceTime, takeUntil, distinctUntilChanged, switchMap, withLatestFrom, concatMap } from 'rxjs';
-import { u32, Struct, u128 } from 'scale-ts';
+import { u32, u128, Struct } from 'scale-ts';
 import upperFirst from 'lodash/upperFirst';
 import { Abi } from '@polkadot/api-contract';
+import { compressToEncodedURIComponent } from 'lz-string';
 
 // TODO: Document default balances module purpose/usage
 const DefaultBalanceModule = type => ({
@@ -59,11 +58,48 @@ const DefaultBalanceModule = type => ({
 // internal
 //
 
-var pkg = {
-	name: "@talismn/balances",
-	version: "0.0.0-pr2043-20250703063959"};
+/**
+ * Fetches tokens for EVM networks.
+ */
+class EvmTokenFetcher {
+  #chaindataProvider;
+  #balanceModules;
+  constructor(chaindataProvider, balanceModules) {
+    this.#chaindataProvider = chaindataProvider;
+    this.#balanceModules = balanceModules;
+  }
+  async update(evmNetworkIds) {
+    await this.updateEvmNetworks(evmNetworkIds);
+  }
+  async updateEvmNetworks(evmNetworkIds) {
+    const evmNetworks = new Map((await this.#chaindataProvider.evmNetworks()).map(evmNetwork => [evmNetwork.id, evmNetwork]));
+    const allEvmTokens = {};
+    const evmNetworkConcurrency = 10;
+    await PromisePool.withConcurrency(evmNetworkConcurrency).for(evmNetworkIds).process(async evmNetworkId => {
+      const evmNetwork = evmNetworks.get(evmNetworkId);
+      if (!evmNetwork) return;
+      for (const mod of this.#balanceModules.filter(m => m.type.startsWith("evm-"))) {
+        const balancesConfig = (evmNetwork.balancesConfig ?? []).find(({
+          moduleType
+        }) => moduleType === mod.type);
+        const moduleConfig = balancesConfig?.moduleConfig ?? {};
+
+        // chainMeta arg only needs the isTestnet property, let's save a db roundtrip for now
+        const isTestnet = evmNetwork.isTestnet ?? false;
+        const tokens = await mod.fetchEvmChainTokens(evmNetworkId, {
+          isTestnet
+        }, moduleConfig);
+        for (const [tokenId, token] of Object.entries(tokens)) allEvmTokens[tokenId] = token;
+      }
+    });
+    await this.#chaindataProvider.updateEvmNetworkTokens(Object.values(allEvmTokens));
+  }
+}
+
+var packageJson = {
+	name: "@talismn/balances"};
 
-var log = anylogger(pkg.name);
+var log = anylogger(packageJson.name);
 
 function excludeFromTransferableAmount(locks) {
   if (typeof locks === "string") return BigInt(locks);
@@ -273,13 +309,15 @@ class Balances {
     return new SumBalancesFormatter(this);
   }
 }
+const isBalanceEvm = balance => "evmNetworkId" in balance;
 const getBalanceId = balance => {
   const {
     source,
     address,
     tokenId
   } = balance;
-  return [source, address, tokenId].join("::");
+  const locationId = isBalanceEvm(balance) ? balance.evmNetworkId : balance.chainId;
+  return [source, address, locationId, tokenId].filter(isTruthy).join("::");
 };
 
 /**
@@ -341,17 +379,23 @@ class Balance {
   get address() {
     return this.#storage.address;
   }
-  get networkId() {
-    return this.#storage.networkId;
+  get chainId() {
+    return isBalanceEvm(this.#storage) ? undefined : this.#storage.chainId;
+  }
+  get chain() {
+    return this.#db?.chains && this.chainId && this.#db?.chains[this.chainId] || null;
   }
-  get network() {
-    return this.#db?.networks?.[this.networkId] || null;
+  get evmNetworkId() {
+    return isBalanceEvm(this.#storage) ? this.#storage.evmNetworkId : undefined;
+  }
+  get evmNetwork() {
+    return this.#db?.evmNetworks && this.evmNetworkId && this.#db?.evmNetworks[this.evmNetworkId] || null;
   }
   get tokenId() {
     return this.#storage.tokenId;
   }
   get token() {
-    return this.#db?.tokens?.[this.tokenId] || null;
+    return this.#db?.tokens && this.#db?.tokens[this.tokenId] || null;
   }
   get decimals() {
     return this.token?.decimals || null;
@@ -364,9 +408,9 @@ class Balance {
     //
     // This means that those rates are always available for calculating the uniswapv2 rates,
     // regardless of whether or not the underlying erc20s are actually in chaindata and enabled.
-    if (this.isSource("evm-uniswapv2") && this.token?.type === "evm-uniswapv2") {
-      const tokenId0 = evmErc20TokenId(this.networkId, this.token.tokenAddress0);
-      const tokenId1 = evmErc20TokenId(this.networkId, this.token.tokenAddress1);
+    if (this.isSource("evm-uniswapv2") && this.token?.type === "evm-uniswapv2" && this.evmNetworkId) {
+      const tokenId0 = evmErc20TokenId$1(this.evmNetworkId, this.token.tokenAddress0);
+      const tokenId1 = evmErc20TokenId$1(this.evmNetworkId, this.token.tokenAddress1);
       const decimals = this.token.decimals;
       const decimals0 = this.token.decimals0;
       const decimals1 = this.token.decimals1;
@@ -445,7 +489,9 @@ class Balance {
     const nomPoolStakedPlancks = this.locks.some(lock => lock.source === "substrate-native-holds" && lock.label === "DelegatedStaking") ? 0n : this.nompools.map(({
       amount
     }) => amount.planck).reduce((a, b) => a + b, 0n);
-    return this.#format(this.free.planck + this.reserved.planck + nomPoolStakedPlancks + this.subtensor.map(({
+    return this.#format(this.free.planck + this.reserved.planck + nomPoolStakedPlancks + this.crowdloans.map(({
+      amount
+    }) => amount.planck).reduce((a, b) => a + b, 0n) + this.subtensor.map(({
       amount
     }) => amount.planck).reduce((a, b) => a + b, 0n) + includeInTotalExtraAmount(extra));
   }
@@ -481,6 +527,9 @@ class Balance {
   get locks() {
     return this.getValue("locked");
   }
+  get crowdloans() {
+    return this.getValue("crowdloan");
+  }
   get nompools() {
     return this.getValue("nompool");
   }
@@ -559,7 +608,7 @@ class Balance {
     const nomPoolStakedPlancks = this.locks.some(lock => lock.source === "substrate-native-holds" && lock.label === "DelegatedStaking") ? 0n : this.nompools.map(({
       amount
     }) => amount.planck).reduce((a, b) => a + b, 0n);
-    const otherUnavailable = nomPoolStakedPlancks + this.subtensor.reduce((total, each) => total + each.amount.planck, 0n);
+    const otherUnavailable = nomPoolStakedPlancks + this.crowdloans.reduce((total, each) => total + each.amount.planck, 0n) + this.subtensor.reduce((total, each) => total + each.amount.planck, 0n);
     return this.#format(baseUnavailable + otherUnavailable);
   }
 
@@ -794,6 +843,10 @@ const filterMirrorTokens = (balance, i, balances) => {
   return !mirrorOf || !balances.find(b => b.tokenId === mirrorOf);
 };
 
+// TODO: Move this into a common module which can then be imported both here and into EvmErc20Module
+// We can't import this directly from EvmErc20Module because then we'd have a circular dependency
+const evmErc20TokenId$1 = (chainId, tokenContractAddress) => `${chainId}-evm-erc20-${tokenContractAddress}`.toLowerCase();
+
 /**
  * `BalanceTypes` is an automatically determined sub-selection of `PluginBalanceTypes`.
  *
@@ -824,6 +877,7 @@ const getValueId = amount => {
   const getMetaId = () => {
     const meta = amount.meta;
     if (!meta) return "";
+    if (amount.type === "crowdloan") return meta.paraId?.toString() ?? "";
     if (amount.type === "nompool") return meta.poolId?.toString() ?? "";
     if (amount.type === "subtensor") {
       const {
@@ -847,9 +901,10 @@ const getValueId = amount => {
 const deriveMiniMetadataId = ({
   source,
   chainId,
+  specName,
   specVersion,
-  libVersion
-}) => u8aToHex(xxhashAsU8a(new TextEncoder().encode(`${source}${chainId}${specVersion}${libVersion}`), 64), undefined, false);
+  balancesConfig
+}) => u8aToHex(xxhashAsU8a(new TextEncoder().encode(`${source}${chainId}${specName}${specVersion}${balancesConfig}`), 64), undefined, false);
 
 // for DB version 3, Wallet version 1.21.0
 const upgradeRemoveSymbolFromNativeTokenId = async tx => {
@@ -944,9 +999,230 @@ class TalismanBalancesDatabase extends Dexie {
 }
 const db = new TalismanBalancesDatabase();
 
-const TokenConfigBaseSchema = TokenBaseSchema.partial().omit({
-  id: true
-});
+const minimumHydrationInterval = 300_000; // 300_000ms = 300s = 5 minutes
+
+/**
+ * A substrate dapp needs access to a set of types when it wants to communicate with a blockchain node.
+ *
+ * These types are used to encode requests & decode responses via the SCALE codec.
+ * Each chain generally has its own set of types.
+ *
+ * Substrate provides a construct to retrieve these types from a blockchain node.
+ * The chain metadata.
+ *
+ * The metadata includes the types required for any communication with the chain,
+ * including lots of methods which are not relevant to balance fetching.
+ *
+ * As such, the metadata can clock in at around 1-2MB per chain, which is a lot of storage
+ * for browser-based dapps which want to connect to lots of chains.
+ *
+ * By utilizing the wonderful [scale-ts](https://github.com/unstoppablejs/unstoppablejs/tree/main/packages/scale-ts#readme) library,
+ * we can trim the chain metadata down so that it only includes the types we need for balance fetching.
+ *
+ * Each balance module has a function to do just that, `BalanceModule::fetchSubstrateChainMeta`.
+ *
+ * But, we only want to run this operation when necessary.
+ *
+ * The purpose of this class, `MiniMetadataUpdater`, is to maintain a local cache of
+ * trimmed-down metadatas, which we'll refer to as `MiniMetadatas`.
+ */
+class MiniMetadataUpdater {
+  #lastHydratedMiniMetadatasAt = 0;
+  #lastHydratedCustomChainsAt = 0;
+  #chainConnectors;
+  #chaindataProvider;
+  #balanceModules;
+  constructor(chainConnectors, chaindataProvider, balanceModules) {
+    this.#chainConnectors = chainConnectors;
+    this.#chaindataProvider = chaindataProvider;
+    this.#balanceModules = balanceModules;
+  }
+
+  /** Subscribe to the metadata for a chain */
+  subscribe(chainId) {
+    return from(liveQuery(() => db.miniMetadatas.filter(m => m.chainId === chainId).toArray().then(array => array[0])));
+  }
+  async update(chainIds) {
+    await this.updateSubstrateChains(chainIds);
+  }
+  async statuses(chains) {
+    const ids = await db.miniMetadatas.orderBy("id").primaryKeys();
+    const wantedIdsByChain = new Map(chains.flatMap(({
+      id: chainId,
+      specName,
+      specVersion,
+      balancesConfig
+    }) => {
+      if (specName === null) return [];
+      if (specVersion === null) return [];
+      return [[chainId, this.#balanceModules.filter(m => m.type.startsWith("substrate-")).map(({
+        type: source
+      }) => deriveMiniMetadataId({
+        source,
+        chainId: chainId,
+        specName: specName,
+        specVersion: specVersion,
+        balancesConfig: JSON.stringify((balancesConfig ?? []).find(({
+          moduleType
+        }) => moduleType === source)?.moduleConfig ?? {})
+      }))]];
+    }));
+    const statusesByChain = new Map(Array.from(wantedIdsByChain.entries()).map(([chainId, wantedIds]) => [chainId, wantedIds.every(wantedId => ids.includes(wantedId)) ? "good" : "none"]));
+    return {
+      wantedIdsByChain,
+      statusesByChain
+    };
+  }
+  async hydrateFromChaindata() {
+    const now = Date.now();
+    if (now - this.#lastHydratedMiniMetadatasAt < minimumHydrationInterval) return false;
+    const dbHasMiniMetadatas = (await db.miniMetadatas.count()) > 0;
+    try {
+      try {
+        // TODO: Move `fetchMiniMetadatas` into this package,
+        // so that we don't have a circular import between `@talismn/balances` and `@talismn/chaindata-provider`.
+        var miniMetadatas = await fetchMiniMetadatas(); // eslint-disable-line no-var
+        if (miniMetadatas.length <= 0) throw new Error("Ignoring empty chaindata miniMetadatas response");
+      } catch (error) {
+        if (dbHasMiniMetadatas) throw error;
+        // On first start-up (db is empty), if we fail to fetch miniMetadatas then we should
+        // initialize the DB with the list of miniMetadatas inside our init/mini-metadatas.json file.
+        // This data will represent a relatively recent copy of what's in chaindata,
+        // which will be better for our users than to have nothing at all.
+        var miniMetadatas = await fetchInitMiniMetadatas(); // eslint-disable-line no-var
+      }
+      await db.miniMetadatas.bulkPut(miniMetadatas);
+      this.#lastHydratedMiniMetadatasAt = now;
+      return true;
+    } catch (error) {
+      log.warn(`Failed to hydrate miniMetadatas from chaindata`, error);
+      return false;
+    }
+  }
+  async hydrateCustomChains() {
+    const now = Date.now();
+    if (now - this.#lastHydratedCustomChainsAt < minimumHydrationInterval) return false;
+    const chains = await this.#chaindataProvider.chains();
+    const customChains = chains.filter(chain => "isCustom" in chain && chain.isCustom);
+    const updatedCustomChains = [];
+    const concurrency = 4;
+    (await PromisePool.withConcurrency(concurrency).for(customChains).process(async customChain => {
+      const send = (method, params) => this.#chainConnectors.substrate?.send(customChain.id, method, params);
+      const [genesisHash, runtimeVersion, chainName, chainType] = await Promise.all([send("chain_getBlockHash", [0]), send("state_getRuntimeVersion", []), send("system_chain", []), send("system_chainType", [])]);
+
+      // deconstruct rpc data
+      const {
+        specName,
+        implName
+      } = runtimeVersion;
+      const specVersion = String(runtimeVersion.specVersion);
+      const changed = customChain.genesisHash !== genesisHash || customChain.chainName !== chainName || !isEqual(customChain.chainType, chainType) || customChain.implName !== implName || customChain.specName !== specName || customChain.specVersion !== specVersion;
+      if (!changed) return;
+      customChain.genesisHash = genesisHash;
+      customChain.chainName = chainName;
+      customChain.chainType = chainType;
+      customChain.implName = implName;
+      customChain.specName = specName;
+      customChain.specVersion = specVersion;
+      updatedCustomChains.push(customChain);
+    })).errors.forEach(error => log.error("Error hydrating custom chains", error));
+    if (updatedCustomChains.length > 0) {
+      await this.#chaindataProvider.transaction("rw", ["chains"], async () => {
+        for (const updatedCustomChain of updatedCustomChains) {
+          await this.#chaindataProvider.removeCustomChain(updatedCustomChain.id);
+          await this.#chaindataProvider.addCustomChain(updatedCustomChain);
+        }
+      });
+    }
+    if (updatedCustomChains.length > 0) this.#lastHydratedCustomChainsAt = now;
+    return true;
+  }
+  async updateSubstrateChains(chainIds) {
+    const chains = new Map((await this.#chaindataProvider.chains()).map(chain => [chain.id, chain]));
+    const filteredChains = chainIds.flatMap(chainId => chains.get(chainId) ?? []);
+    const ids = await db.miniMetadatas.orderBy("id").primaryKeys();
+    const {
+      wantedIdsByChain,
+      statusesByChain
+    } = await this.statuses(filteredChains);
+
+    // clean up store
+    const wantedIds = Array.from(wantedIdsByChain.values()).flatMap(ids => ids);
+    const unwantedIds = ids.filter(id => !wantedIds.includes(id));
+    if (unwantedIds.length > 0) {
+      const chainIds = Array.from(new Set((await db.miniMetadatas.bulkGet(unwantedIds)).map(m => m?.chainId)));
+      log.info(`Pruning ${unwantedIds.length} miniMetadatas on chains ${chainIds.join(", ")}`);
+      await db.miniMetadatas.bulkDelete(unwantedIds);
+    }
+    const needUpdates = Array.from(statusesByChain.entries()).filter(([, status]) => status !== "good").map(([chainId]) => chainId);
+    if (needUpdates.length > 0) log.info(`${needUpdates.length} miniMetadatas need updates (${needUpdates.join(", ")})`);
+    const availableTokenLogos = await availableTokenLogoFilenames().catch(error => {
+      log.error("Failed to fetch available token logos", error);
+      return [];
+    });
+    const concurrency = 12;
+    (await PromisePool.withConcurrency(concurrency).for(needUpdates).process(async chainId => {
+      log.info(`Updating metadata for chain ${chainId}`);
+      const chain = chains.get(chainId);
+      if (!chain) return;
+      const {
+        specName,
+        specVersion
+      } = chain;
+      if (specName === null) return;
+      if (specVersion === null) return;
+      const fetchMetadata = async () => {
+        try {
+          return await fetchBestMetadata((method, params, isCacheable) => {
+            if (!this.#chainConnectors.substrate) throw new Error("Substrate connector is not available");
+            return this.#chainConnectors.substrate.send(chainId, method, params, isCacheable);
+          }, true // allow v14 fallback
+          );
+        } catch (err) {
+          log.warn(`Failed to fetch metadata for chain ${chainId}`);
+          return undefined;
+        }
+      };
+      const [metadataRpc, systemProperties] = await Promise.all([fetchMetadata(), this.#chainConnectors.substrate?.send(chainId, "system_properties", [])]);
+      for (const mod of this.#balanceModules.filter(m => m.type.startsWith("substrate-"))) {
+        const balancesConfig = (chain.balancesConfig ?? []).find(({
+          moduleType
+        }) => moduleType === mod.type);
+        const moduleConfig = balancesConfig?.moduleConfig ?? {};
+        const chainMeta = await mod.fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc, systemProperties);
+        const tokens = await mod.fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig);
+
+        // update tokens in chaindata
+        await this.#chaindataProvider.updateChainTokens(chainId, mod.type, Object.values(tokens), availableTokenLogos);
+
+        // update miniMetadatas
+        const {
+          miniMetadata: data,
+          metadataVersion: version,
+          ...extra
+        } = chainMeta ?? {};
+        await db.miniMetadatas.put({
+          id: deriveMiniMetadataId({
+            source: mod.type,
+            chainId,
+            specName,
+            specVersion,
+            balancesConfig: JSON.stringify(moduleConfig)
+          }),
+          source: mod.type,
+          chainId,
+          specName,
+          specVersion,
+          balancesConfig: JSON.stringify(moduleConfig),
+          // TODO: Standardise return value from `fetchSubstrateChainMeta`
+          version,
+          data,
+          extra: JSON.stringify(extra)
+        });
+      }
+    })).errors.forEach(error => log.error("Error updating chain metadata", error));
+  }
+}
 
 const erc20Abi = [{
   constant: true,
@@ -1178,11 +1454,8 @@ const erc20Abi = [{
 
 const erc20BalancesAggregatorAbi = parseAbi(["struct AccountToken {address account; address token;}", "function balances(AccountToken[] memory accountTokens) public view returns (uint256[] memory)"]);
 
-const moduleType$7 = "evm-erc20";
-const EvmErc20TokenConfigSchema = z.strictObject({
-  contractAddress: EvmErc20TokenSchema.shape.contractAddress,
-  ...TokenConfigBaseSchema.shape
-});
+const moduleType$8 = "evm-erc20";
+const evmErc20TokenId = (chainId, tokenContractAddress) => `${chainId}-evm-erc20-${tokenContractAddress}`.toLowerCase();
 const EvmErc20Module = hydrate => {
   const {
     chainConnectors,
@@ -1206,36 +1479,38 @@ const EvmErc20Module = hydrate => {
     }, {});
   };
   const getModuleTokens = async () => {
-    return await chaindataProvider.getTokensMapById(moduleType$7);
+    return await chaindataProvider.tokensByIdForType(moduleType$8);
   };
   const getErc20Aggregators = async () => {
-    const evmNetworks = await chaindataProvider.getNetworks("ethereum");
-    return Object.fromEntries(evmNetworks.filter(n => n.contracts?.Erc20Aggregator).map(n => [n.id, n.contracts.Erc20Aggregator]));
+    const evmNetworks = await chaindataProvider.evmNetworks();
+    return Object.fromEntries(evmNetworks.filter(n => n.erc20aggregator).map(n => [n.id, n.erc20aggregator]));
   };
   return {
-    ...DefaultBalanceModule(moduleType$7),
+    ...DefaultBalanceModule(moduleType$8),
     /**
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L280-L284).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the chainmeta for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainMeta(_chainId) {
+    async fetchEvmChainMeta(chainId) {
+      const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false;
       return {
-        miniMetadata: null,
-        extra: null
+        isTestnet
       };
     },
     /**
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L338-L343).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the list of tokens for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig, tokens) {
+    async fetchEvmChainTokens(chainId, chainMeta, moduleConfig) {
+      const {
+        isTestnet
+      } = chainMeta;
       const chainTokens = {};
-      for (const tokenConfig of tokens ?? []) {
+      for (const tokenConfig of moduleConfig?.tokens ?? []) {
         const {
           contractAddress,
           symbol: contractSymbol,
-          decimals: contractDecimals,
-          name: contractName
+          decimals: contractDecimals
         } = tokenConfig;
         // TODO : in chaindata's build, filter out all tokens that don't have any of these
         if (!contractAddress || !contractSymbol || contractDecimals === undefined) {
@@ -1249,25 +1524,22 @@ const EvmErc20Module = hydrate => {
         const token = {
           id,
           type: "evm-erc20",
-          platform: "ethereum",
+          isTestnet,
           isDefault: tokenConfig.isDefault ?? true,
           symbol,
           decimals,
-          name: contractName ?? symbol,
-          logo: tokenConfig?.logo,
+          logo: tokenConfig?.logo || githubTokenLogoUrl(id),
           contractAddress,
-          networkId: chainId
+          evmNetwork: {
+            id: chainId
+          }
         };
         if (tokenConfig?.symbol) token.symbol = tokenConfig?.symbol;
         if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+        if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
         if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
         if (tokenConfig?.noDiscovery) token.noDiscovery = tokenConfig?.noDiscovery;
-        const validation = EvmErc20TokenSchema.safeParse(token);
-        if (validation.success) {
-          chainTokens[token.id] = token;
-        } else {
-          log.warn("Ignoring invalid token", token.id, validation.error.message, validation.error.issues);
-        }
+        chainTokens[token.id] = token;
       }
       return chainTokens;
     },
@@ -1279,18 +1551,18 @@ const EvmErc20Module = hydrate => {
       const subscriptionInterval = 6_000; // 6_000ms == 6 seconds
       const initDelay = 1_500; // 1_500ms == 1.5 seconds
       const initialisingBalances = new Set();
-      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.networkId));
+      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.evmNetworkId));
       const tokens = await getModuleTokens();
 
       // for chains with a zero balance we only call fetchBalances once every 5 subscriptionIntervals
       // if subscriptionInterval is 6 seconds, this means we only poll chains with a zero balance every 30 seconds
       let zeroBalanceSubscriptionIntervalCounter = 0;
-      const evmNetworks = await chaindataProvider.getNetworksMapById("ethereum");
+      const evmNetworks = await chaindataProvider.evmNetworksById();
       const ethAddressesByToken = Object.fromEntries(Object.entries(addressesByToken).map(([tokenId, addresses]) => {
         const ethAddresses = addresses.filter(isEthereumAddress);
         if (ethAddresses.length === 0) return null;
         const token = tokens[tokenId];
-        const evmNetworkId = token.networkId;
+        const evmNetworkId = token.evmNetwork?.id;
         if (!evmNetworkId) return null;
         return [tokenId, ethAddresses];
       }).filter(x => Boolean(x)));
@@ -1416,17 +1688,20 @@ const fetchBalances$3 = async (evmChainConnector, tokenAddressesByNetwork, erc20
     results: [],
     errors: []
   };
-  await Promise.all(Object.entries(tokenAddressesByNetwork).map(async ([networkId, networkParams]) => {
-    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(networkId);
-    if (!publicClient) throw new EvmErc20NetworkError(`Could not get rpc provider for evm network ${networkId}`, networkId);
-    const balances = await getEvmTokenBalances(publicClient, networkParams, result.errors, erc20Aggregators[networkId]);
+  await Promise.all(Object.entries(tokenAddressesByNetwork).map(async ([evmNetworkId, networkParams]) => {
+    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(evmNetworkId);
+    if (!publicClient) throw new EvmErc20NetworkError(`Could not get rpc provider for evm network ${evmNetworkId}`, evmNetworkId);
+    const balances = await getEvmTokenBalances(publicClient, networkParams, result.errors, erc20Aggregators[evmNetworkId]);
 
     // consider only non null balances in the results
     result.results.push(...balances.filter(isTruthy).map((free, i) => ({
       source: "evm-erc20",
       status: "live",
       address: networkParams[i].address,
-      networkId,
+      multiChainId: {
+        evmChainId: evmNetworkId
+      },
+      evmNetworkId,
       tokenId: networkParams[i].token.id,
       value: free
     })));
@@ -1497,7 +1772,7 @@ function groupAddressesByTokenByEvmNetwork$1(addressesByToken, tokens) {
       log.error(`Token ${tokenId} not found`);
       return byChain;
     }
-    const chainId = token.networkId;
+    const chainId = token.evmNetwork?.id;
     if (!chainId) {
       log.error(`Token ${tokenId} has no evm network`);
       return byChain;
@@ -1510,38 +1785,67 @@ function groupAddressesByTokenByEvmNetwork$1(addressesByToken, tokens) {
 
 const abiMulticall = parseAbi(["struct Call { address target; bytes callData; }", "struct Call3 { address target; bool allowFailure; bytes callData; }", "struct Call3Value { address target; bool allowFailure; uint256 value; bytes callData; }", "struct Result { bool success; bytes returnData; }", "function aggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes[] memory returnData)", "function aggregate3(Call3[] calldata calls) public payable returns (Result[] memory returnData)", "function aggregate3Value(Call3Value[] calldata calls) public payable returns (Result[] memory returnData)", "function blockAndAggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)", "function getBasefee() view returns (uint256 basefee)", "function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)", "function getBlockNumber() view returns (uint256 blockNumber)", "function getChainId() view returns (uint256 chainid)", "function getCurrentBlockCoinbase() view returns (address coinbase)", "function getCurrentBlockDifficulty() view returns (uint256 difficulty)", "function getCurrentBlockGasLimit() view returns (uint256 gaslimit)", "function getCurrentBlockTimestamp() view returns (uint256 timestamp)", "function getEthBalance(address addr) view returns (uint256 balance)", "function getLastBlockHash() view returns (bytes32 blockHash)", "function tryAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (Result[] memory returnData)", "function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)"]);
 
-const moduleType$6 = "evm-native";
-const EvmNativeTokenConfigSchema = TokenConfigBaseSchema;
+const moduleType$7 = "evm-native";
+const evmNativeTokenId = chainId => `${chainId}-evm-native`.toLowerCase().replace(/ /g, "-");
+const getEvmNetworkIdFromTokenId = tokenId => {
+  const evmNetworkId = tokenId.split("-")[0];
+  if (!evmNetworkId) throw new Error(`Can't detect chainId for token ${tokenId}`);
+  return evmNetworkId;
+};
 const EvmNativeModule = hydrate => {
   const {
     chainConnectors,
     chaindataProvider
   } = hydrate;
   const getModuleTokens = async () => {
-    return await chaindataProvider.getTokensMapById(moduleType$6);
+    return await chaindataProvider.tokensByIdForType(moduleType$7);
   };
   return {
-    ...DefaultBalanceModule(moduleType$6),
+    ...DefaultBalanceModule(moduleType$7),
     get tokens() {
-      return chaindataProvider.getTokensMapById(moduleType$6);
+      return chaindataProvider.tokensByIdForType(moduleType$7);
     },
     /**
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L280-L284).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the chainmeta for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainMeta(_chainId) {
+    async fetchEvmChainMeta(chainId) {
+      const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false;
       return {
-        miniMetadata: null,
-        extra: null
+        isTestnet
       };
     },
     /**
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L338-L343).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the list of tokens for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainTokens() {
-      // token is currently generated in chaindata from the EthNetworkConfig["nativeCurrency"] field
-      return {};
+    async fetchEvmChainTokens(chainId, chainMeta, moduleConfig) {
+      const {
+        isTestnet
+      } = chainMeta;
+      const symbol = moduleConfig?.symbol ?? "ETH";
+      const decimals = typeof moduleConfig?.decimals === "number" ? moduleConfig.decimals : 18;
+      const id = evmNativeTokenId(chainId);
+      const nativeToken = {
+        id,
+        type: "evm-native",
+        isTestnet,
+        isDefault: true,
+        symbol,
+        decimals,
+        logo: moduleConfig?.logo || githubTokenLogoUrl(id),
+        evmNetwork: {
+          id: chainId
+        }
+      };
+      if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol;
+      if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId;
+      if (moduleConfig?.dcentName) nativeToken.dcentName = moduleConfig?.dcentName;
+      if (moduleConfig?.mirrorOf) nativeToken.mirrorOf = moduleConfig?.mirrorOf;
+      if (moduleConfig?.noDiscovery) nativeToken.noDiscovery = moduleConfig?.noDiscovery;
+      return {
+        [nativeToken.id]: nativeToken
+      };
     },
     async subscribeBalances({
       addressesByToken,
@@ -1552,11 +1856,11 @@ const EvmNativeModule = hydrate => {
       const initDelay = 500; // 500ms == 0.5 seconds
 
       const tokens = await getModuleTokens();
-      const ethAddressesByToken = fromPairs(toPairs(addressesByToken).map(([tokenId, addresses]) => {
+      const ethAddressesByToken = Object.fromEntries(Object.entries(addressesByToken).map(([tokenId, addresses]) => {
         const ethAddresses = addresses.filter(isEthereumAddress);
         if (ethAddresses.length === 0) return null;
         const token = tokens[tokenId];
-        const evmNetworkId = token.networkId;
+        const evmNetworkId = token.evmNetwork?.id;
         if (!evmNetworkId) return null;
         return [tokenId, ethAddresses];
       }).filter(x => Boolean(x)));
@@ -1566,16 +1870,16 @@ const EvmNativeModule = hydrate => {
       let zeroBalanceSubscriptionIntervalCounter = 0;
 
       // setup initialising balances for all active evm networks
-      const activeEvmNetworkIds = keys(ethAddressesByToken).map(networkIdFromTokenId);
+      const activeEvmNetworkIds = Object.keys(ethAddressesByToken).map(getEvmNetworkIdFromTokenId);
       const initialisingBalances = new Set(activeEvmNetworkIds);
-      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.networkId));
+      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.evmNetworkId));
       const poll = async () => {
         if (!subscriptionActive) return;
         zeroBalanceSubscriptionIntervalCounter = (zeroBalanceSubscriptionIntervalCounter + 1) % 5;
         try {
           // fetch balance for each network sequentially to prevent creating a big queue of http requests (browser can only handle 2 at a time)
           for (const [tokenId, addresses] of Object.entries(ethAddressesByToken)) {
-            const evmNetworkId = networkIdFromTokenId(tokenId);
+            const evmNetworkId = getEvmNetworkIdFromTokenId(tokenId);
 
             // a zero balance network is one that has initialised and does not have a positive balance
             const isZeroBalanceNetwork = !initialisingBalances.has(evmNetworkId) && !positiveBalanceNetworks.has(evmNetworkId);
@@ -1595,10 +1899,10 @@ const EvmNativeModule = hydrate => {
                   log.error(balance.message, balance.networkId);
                   initialisingBalances.delete(balance.networkId);
                 } else {
-                  if (balance.networkId) {
-                    initialisingBalances.delete(balance.networkId);
+                  if (balance.evmNetworkId) {
+                    initialisingBalances.delete(balance.evmNetworkId);
                     if (BigInt(balance.value) > 0n) {
-                      positiveBalanceNetworks.add(balance.networkId);
+                      positiveBalanceNetworks.add(balance.evmNetworkId);
                     }
                     resultBalances.push(balance);
                   }
@@ -1648,20 +1952,23 @@ const fetchBalances$2 = async (evmChainConnector, addressesByToken, tokens) => {
   if (!evmChainConnector) throw new Error(`This module requires an evm chain connector`);
   return Promise.all(Object.entries(addressesByToken).map(async ([tokenId, addresses]) => {
     const token = tokens[tokenId];
-    const networkId = token.networkId;
-    if (!networkId) throw new Error(`Token ${token.id} has no evm network`);
-    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(networkId);
-    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
+    const evmNetworkId = token.evmNetwork?.id;
+    if (!evmNetworkId) throw new Error(`Token ${token.id} has no evm network`);
+    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(evmNetworkId);
+    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${evmNetworkId}`);
 
     // fetch all balances
     const freeBalances = await getFreeBalances(publicClient, addresses);
     const balanceResults = addresses.map((address, i) => {
-      if (freeBalances[i] === "error") return new EvmNativeBalanceError("Could not fetch balance ", networkId);
+      if (freeBalances[i] === "error") return new EvmNativeBalanceError("Could not fetch balance ", evmNetworkId);
       return {
         source: "evm-native",
         status: "live",
         address: address,
-        networkId,
+        multiChainId: {
+          evmChainId: evmNetworkId
+        },
+        evmNetworkId,
         tokenId,
         value: freeBalances[i].toString()
       };
@@ -1714,7 +2021,7 @@ async function getFreeBalances(publicClient, addresses) {
       });
     } catch (err) {
       const errorMessage = hasOwnProperty(err, "shortMessage") ? err.shortMessage : hasOwnProperty(err, "message") ? err.message : err;
-      log.warn(`Failed to get balance from chain ${publicClient.chain.id} for ${ethAddresses.length} addresses: ${errorMessage}`);
+      log.warn(`Failed to get balance from chain ${publicClient.chain?.id} for ${ethAddresses.length} addresses: ${errorMessage}`);
       return ethAddresses.map(() => "error");
     }
   }
@@ -2282,20 +2589,8 @@ const uniswapV2PairAbi = [{
   type: "function"
 }];
 
-const moduleType$5 = "evm-uniswapv2";
-const EvmUniswapV2TokenConfigSchema = z.strictObject({
-  contractAddress: EvmUniswapV2TokenSchema.shape.contractAddress,
-  ...TokenConfigBaseSchema.shape,
-  // on chaindata side these are fetched by a dedicated task
-  symbol0: EvmUniswapV2TokenSchema.shape.symbol0.optional(),
-  symbol1: EvmUniswapV2TokenSchema.shape.symbol1.optional(),
-  decimals0: EvmUniswapV2TokenSchema.shape.decimals0.optional(),
-  decimals1: EvmUniswapV2TokenSchema.shape.decimals1.optional(),
-  tokenAddress0: EvmUniswapV2TokenSchema.shape.tokenAddress0.optional(),
-  tokenAddress1: EvmUniswapV2TokenSchema.shape.tokenAddress1.optional(),
-  coingeckoId0: EvmUniswapV2TokenSchema.shape.coingeckoId0.optional(),
-  coingeckoId1: EvmUniswapV2TokenSchema.shape.coingeckoId1.optional()
-});
+const moduleType$6 = "evm-uniswapv2";
+const evmUniswapV2TokenId = (chainId, contractAddress) => `${chainId}-evm-uniswapv2-${contractAddress}`.toLowerCase();
 const EvmUniswapV2Module = hydrate => {
   const {
     chainConnectors,
@@ -2304,16 +2599,19 @@ const EvmUniswapV2Module = hydrate => {
   const chainConnector = chainConnectors.evm;
   assert(chainConnector, "This module requires an evm chain connector");
   return {
-    ...DefaultBalanceModule(moduleType$5),
-    async fetchEvmChainMeta(_chainId) {
+    ...DefaultBalanceModule(moduleType$6),
+    async fetchEvmChainMeta(chainId) {
+      const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false;
       return {
-        miniMetadata: null,
-        extra: null
+        isTestnet
       };
     },
-    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig, pools) {
+    async fetchEvmChainTokens(chainId, chainMeta, moduleConfig) {
+      const {
+        isTestnet
+      } = chainMeta;
       const tokens = {};
-      for (const tokenConfig of pools ?? []) {
+      for (const tokenConfig of moduleConfig?.pools ?? []) {
         const {
           contractAddress,
           decimals,
@@ -2324,8 +2622,7 @@ const EvmUniswapV2Module = hydrate => {
           tokenAddress0,
           tokenAddress1,
           coingeckoId0,
-          coingeckoId1,
-          name
+          coingeckoId1
         } = tokenConfig;
         if (!contractAddress || decimals === undefined || symbol0 === undefined || decimals0 === undefined || symbol1 === undefined || decimals1 === undefined || tokenAddress0 === undefined || tokenAddress1 === undefined) {
           log.warn("ignoring token on chain %s", chainId, tokenConfig);
@@ -2335,12 +2632,11 @@ const EvmUniswapV2Module = hydrate => {
         const token = {
           id,
           type: "evm-uniswapv2",
-          platform: "ethereum",
+          isTestnet,
           isDefault: tokenConfig.isDefault ?? false,
           symbol: `${symbol0 ?? "UNKNOWN"}/${symbol1 ?? "UNKNOWN"}`,
-          name: name ?? `${symbol0 ?? "UNKNOWN"}/${symbol1 ?? "UNKNOWN"}`,
           decimals,
-          logo: tokenConfig?.logo || getGithubTokenLogoUrl("uniswap"),
+          logo: tokenConfig?.logo || githubTokenLogoUrl("uniswap"),
           symbol0,
           decimals0,
           symbol1,
@@ -2350,10 +2646,13 @@ const EvmUniswapV2Module = hydrate => {
           tokenAddress1,
           coingeckoId0,
           coingeckoId1,
-          networkId: chainId
+          evmNetwork: {
+            id: chainId
+          }
         };
         if (tokenConfig?.symbol) token.symbol = tokenConfig?.symbol;
         if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+        if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
         if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
         if (tokenConfig?.noDiscovery) token.noDiscovery = tokenConfig?.noDiscovery;
         tokens[token.id] = token;
@@ -2369,9 +2668,9 @@ const EvmUniswapV2Module = hydrate => {
       const initDelay = 1_500; // 1_500ms == 1.5 seconds
 
       const initialBalancesByNetwork = initialBalances?.reduce((result, b) => {
-        if (!b.networkId) return result;
-        if (!result[b.networkId]) result[b.networkId] = {};
-        result[b.networkId][getBalanceId(b)] = b;
+        if (!b.evmNetworkId) return result;
+        if (!result[b.evmNetworkId]) result[b.evmNetworkId] = {};
+        result[b.evmNetworkId][getBalanceId(b)] = b;
         return result;
       }, {});
       const cache = new Map(Object.entries(initialBalancesByNetwork ?? {}));
@@ -2379,8 +2678,8 @@ const EvmUniswapV2Module = hydrate => {
       // for chains with a zero balance we only call fetchBalances once every 5 subscriptionIntervals
       // if subscriptionInterval is 6 seconds, this means we only poll chains with a zero balance every 30 seconds
       let zeroBalanceSubscriptionIntervalCounter = 0;
-      const evmNetworks = await chaindataProvider.getNetworksMapById("ethereum");
-      const tokens = await chaindataProvider.getTokensMapById();
+      const evmNetworks = await chaindataProvider.evmNetworksById();
+      const tokens = await chaindataProvider.tokensById();
       const poll = async () => {
         if (!subscriptionActive) return;
         zeroBalanceSubscriptionIntervalCounter = (zeroBalanceSubscriptionIntervalCounter + 1) % 5;
@@ -2423,20 +2722,20 @@ const EvmUniswapV2Module = hydrate => {
     },
     async fetchBalances(addressesByToken) {
       if (!chainConnectors.evm) throw new Error(`This module requires an evm chain connector`);
-      const evmNetworks = await chaindataProvider.getNetworksMapById("ethereum");
-      const tokens = await chaindataProvider.getTokensMapById();
+      const evmNetworks = await chaindataProvider.evmNetworksById();
+      const tokens = await chaindataProvider.tokensById();
       return fetchBalances$1(chainConnectors.evm, evmNetworks, tokens, addressesByToken);
     }
   };
 };
 const fetchBalances$1 = async (evmChainConnector, evmNetworks, tokens, addressesByToken) => {
   const addressesByTokenGroupedByEvmNetwork = groupAddressesByTokenByEvmNetwork(addressesByToken, tokens);
-  const balances = (await Promise.allSettled(Object.entries(addressesByTokenGroupedByEvmNetwork).map(async ([networkId, addressesByToken]) => {
+  const balances = (await Promise.allSettled(Object.entries(addressesByTokenGroupedByEvmNetwork).map(async ([evmNetworkId, addressesByToken]) => {
     if (!evmChainConnector) throw new Error(`This module requires an evm chain connector`);
-    const evmNetwork = evmNetworks[networkId];
-    if (!evmNetwork) throw new Error(`Evm network ${networkId} not found`);
-    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(networkId);
-    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
+    const evmNetwork = evmNetworks[evmNetworkId];
+    if (!evmNetwork) throw new Error(`Evm network ${evmNetworkId} not found`);
+    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(evmNetworkId);
+    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${evmNetworkId}`);
     const tokensAndAddresses = Object.entries(addressesByToken).reduce((tokensAndAddresses, [tokenId, addresses]) => {
       const token = tokens[tokenId];
       if (!token) {
@@ -2458,7 +2757,10 @@ const fetchBalances$1 = async (evmChainConnector, evmNetworks, tokens, addresses
         source: "evm-uniswapv2",
         status: "live",
         address: address,
-        networkId,
+        multiChainId: {
+          evmChainId: evmNetwork.id
+        },
+        evmNetworkId,
         tokenId: token.id,
         values: await getPoolBalance(publicClient, token.contractAddress, address)
       }));
@@ -2494,7 +2796,7 @@ function groupAddressesByTokenByEvmNetwork(addressesByToken, tokens) {
       log.error(`Token ${tokenId} not found`);
       return byChain;
     }
-    const chainId = token.networkId;
+    const chainId = token.evmNetwork?.id;
     if (!chainId) {
       log.error(`Token ${tokenId} has no evm network`);
       return byChain;
@@ -2569,170 +2871,6 @@ async function getPoolBalance(publicClient, contractAddress, accountAddress) {
   }
 }
 
-const libVersion = pkg.version;
-
-// cache the promise so it can be shared across multiple calls
-const CACHE_GET_SPEC_VERSION = new Map();
-const fetchSpecVersion = async (chainConnector, networkId) => {
-  const {
-    specVersion
-  } = await chainConnector.send(networkId, "state_getRuntimeVersion", [], true);
-  return specVersion;
-};
-
-/**
- * fetches the spec version of a network. current request is cached in case of multiple calls (all balance modules will kick in at once)
- */
-const getSpecVersion = async (chainConnector, networkId) => {
-  if (CACHE_GET_SPEC_VERSION.has(networkId)) return CACHE_GET_SPEC_VERSION.get(networkId);
-  const pResult = fetchSpecVersion(chainConnector, networkId);
-  CACHE_GET_SPEC_VERSION.set(networkId, pResult);
-  try {
-    return await pResult;
-  } catch (cause) {
-    throw new Error(`Failed to fetch specVersion for network ${networkId}`, {
-      cause
-    });
-  } finally {
-    CACHE_GET_SPEC_VERSION.delete(networkId);
-  }
-};
-
-// share requests as all modules will call this at once
-const CACHE$1 = new Map();
-const getMetadataRpc = async (chainConnector, networkId) => {
-  if (CACHE$1.has(networkId)) return CACHE$1.get(networkId);
-  const pResult = fetchBestMetadata((method, params, isCacheable) => chainConnector.send(networkId, method, params, isCacheable, {
-    expectErrors: true
-  }), true // allow fallback to 14 as modules dont use any v15 or v16 specifics yet
-  );
-  CACHE$1.set(networkId, pResult);
-  try {
-    return await pResult;
-  } catch (cause) {
-    if (isAbortError(cause)) throw cause;
-    throw new Error(`Failed to fetch metadataRpc for network ${networkId}`, {
-      cause
-    });
-  } finally {
-    CACHE$1.delete(networkId);
-  }
-};
-
-// share requests as all modules will call this at once
-const CACHE = new Map();
-
-// ensures we dont fetch miniMetadatas on more than 4 chains at once
-const POOL = new PQueue({
-  concurrency: 4
-});
-const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion, signal) => {
-  if (CACHE.has(networkId)) return CACHE.get(networkId);
-  if (!signal) log.warn("[miniMetadata] getMiniMetadatas called without signal, this may hang the updates", new Error("No signal provided") // this will show the stack trace
-  );
-  const pResult = POOL.add(() => fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion), {
-    signal
-  });
-  CACHE.set(networkId, pResult);
-  try {
-    return await pResult;
-  } catch (cause) {
-    if (isAbortError(cause)) throw cause;
-    throw new Error(`Failed to fetch metadataRpc for network ${networkId}`, {
-      cause
-    });
-  } finally {
-    CACHE.delete(networkId);
-  }
-};
-const DotBalanceModuleTypeSchema = z.keyof(DotNetworkBalancesConfigSchema);
-const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
-  const start = performance.now();
-  log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
-  try {
-    const metadataRpc = await getMetadataRpc(chainConnector, chainId);
-    signal?.throwIfAborted();
-    const chainConnectors = {
-      substrate: chainConnector,
-      evm: {} // wont be used but workarounds error for module creation
-    };
-    const modules = defaultBalanceModules.map(mod => mod({
-      chainConnectors,
-      chaindataProvider
-    })).filter(mod => DotBalanceModuleTypeSchema.safeParse(mod.type).success);
-    return Promise.all(modules.map(async mod => {
-      const source = mod.type;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
-      const balancesConfig = chain?.balancesConfig?.[mod.type];
-      const chainMeta = await mod.fetchSubstrateChainMeta(chainId, balancesConfig,
-      // TODO better typing
-      metadataRpc);
-      return {
-        id: deriveMiniMetadataId({
-          source,
-          chainId,
-          specVersion,
-          libVersion
-        }),
-        source,
-        chainId,
-        specVersion,
-        libVersion,
-        data: chainMeta?.miniMetadata ?? null,
-        extra: chainMeta?.extra ?? null
-      };
-    }));
-  } finally {
-    log.debug("[miniMetadata] updated miniMetadatas for %s in %sms", chainId, (performance.now() - start).toFixed(2));
-  }
-};
-
-const getUpdatedMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
-  const miniMetadatas = await getMiniMetadatas(chainConnector, chaindataProvider, chainId, specVersion, signal);
-  signal?.throwIfAborted();
-  await db.transaction("readwrite", "miniMetadatas", async tx => {
-    await tx.miniMetadatas.where({
-      chainId
-    }).delete();
-    await tx.miniMetadatas.bulkPut(miniMetadatas);
-  });
-  return miniMetadatas;
-};
-
-const getMiniMetadata = async (chaindataProvider, chainConnector, chainId, source, signal) => {
-  const specVersion = await getSpecVersion(chainConnector, chainId);
-  signal?.throwIfAborted();
-  const miniMetadataId = deriveMiniMetadataId({
-    source,
-    chainId,
-    specVersion,
-    libVersion
-  });
-
-  // lookup local ones
-  const [dbMiniMetadata, ghMiniMetadata] = await Promise.all([db.miniMetadatas.get(miniMetadataId), chaindataProvider.miniMetadataById(miniMetadataId)]);
-  signal?.throwIfAborted();
-  const miniMetadata = dbMiniMetadata ?? ghMiniMetadata;
-  if (miniMetadata) return miniMetadata;
-
-  // update from live chain metadata and persist locally
-  const miniMetadatas = await getUpdatedMiniMetadatas(chainConnector, chaindataProvider, chainId, specVersion, signal);
-  signal?.throwIfAborted();
-  const found = miniMetadatas.find(m => m.id === miniMetadataId);
-  if (!found) {
-    log.warn("MiniMetadata not found in updated miniMetadatas", {
-      source,
-      chainId,
-      specVersion,
-      libVersion,
-      miniMetadataId,
-      miniMetadatas
-    });
-    throw new Error(`MiniMetadata not found for ${source} on ${chainId}`);
-  }
-  return found;
-};
-
 /**
  * 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.
@@ -2748,16 +2886,44 @@ async function balances(balanceModule, addressesByToken, callback) {
   return await balanceModule.fetchBalances(addressesByToken);
 }
 
-// TODO remove this one in favor of the network specific one below
+/**
+ * Given a `moduleType` and a `chain` from a chaindataProvider, this function will find the chainMeta
+ * associated with the given balanceModule for the given chain.
+ */
+const findChainMeta = (miniMetadatas, moduleType, chain) => {
+  if (!chain) return [undefined, undefined];
+  if (!chain.specName) return [undefined, undefined];
+  if (!chain.specVersion) return [undefined, undefined];
+
+  // TODO: This is spaghetti to import this here, it should be injected into each balance module or something.
+  const metadataId = deriveMiniMetadataId({
+    source: moduleType,
+    chainId: chain.id,
+    specName: chain.specName,
+    specVersion: chain.specVersion,
+    balancesConfig: JSON.stringify(chain.balancesConfig?.find(config => config.moduleType === moduleType)?.moduleConfig ?? {})
+  });
+
+  // TODO: Fix this (needs to fetch miniMetadata without being async)
+  const miniMetadata = miniMetadatas.get(metadataId);
+  const chainMeta = miniMetadata ? {
+    miniMetadata: miniMetadata.data,
+    metadataVersion: miniMetadata.version,
+    ...JSON.parse(miniMetadata.extra)
+  } : undefined;
+  return [chainMeta, miniMetadata];
+};
+
 const buildStorageCoders = ({
   chainIds,
   chains,
   miniMetadatas,
+  moduleType,
   coders
 }) => new Map([...chainIds].flatMap(chainId => {
   const chain = chains[chainId];
   if (!chain) return [];
-  const miniMetadata = miniMetadatas.get(chainId); // findMiniMetadata<TBalanceModule>(miniMetadatas, moduleType, chain)
+  const [, miniMetadata] = findChainMeta(miniMetadatas, moduleType, chain);
   if (!miniMetadata) return [];
   if (!miniMetadata.data) return [];
   const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
@@ -2780,28 +2946,6 @@ const buildStorageCoders = ({
     return [];
   }
 }));
-const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
-  if (!miniMetadata.data) return null;
-  const metadata = unifyMetadata(decAnyMetadata(miniMetadata.data));
-  try {
-    const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
-    const builtCoders = Object.fromEntries(Object.entries(coders).flatMap(([key, moduleMethodOrFn]) => {
-      const [module, method] = typeof moduleMethodOrFn === "function" ? moduleMethodOrFn({
-        chainId
-      }) : moduleMethodOrFn;
-      try {
-        return [[key, scaleBuilder.buildStorage(module, method)]];
-      } catch (cause) {
-        log.trace(`Failed to build SCALE coder for chain ${chainId} (${module}::${method})`, cause);
-        return [];
-      }
-    }));
-    return builtCoders;
-  } catch (cause) {
-    log.error(`Failed to build SCALE coders for chain ${chainId} (${JSON.stringify(coders)})`, cause);
-  }
-  return null;
-};
 
 /**
  * Decodes & unwraps outputs and errors of a given result, contract, and method.
@@ -2883,7 +3027,7 @@ const detectTransferMethod = metadataRpc => {
   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 getUniqueChainIds = (addressesByToken, tokens) => [...new Set(Object.keys(addressesByToken).map(tokenId => tokens[tokenId]?.chain?.id).flatMap(chainId => chainId ? [chainId] : []))];
 
 const makeContractCaller = ({
   chainConnector,
@@ -2992,15 +3136,8 @@ const decompress = data => {
   return JSON.parse(decompressed);
 };
 
-const moduleType$4 = "substrate-assets";
-const SubAssetsTokenConfigSchema = z.strictObject({
-  assetId: SubAssetsTokenSchema.shape.assetId,
-  ...TokenConfigBaseSchema.shape
-});
-const UNSUPPORTED_CHAIN_META$2 = {
-  miniMetadata: null,
-  extra: null
-};
+const moduleType$5 = "substrate-assets";
+const subAssetTokenId = (chainId, assetId, tokenSymbol) => `${chainId}-substrate-assets-${assetId}-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
 const SubAssetsModule = hydrate => {
   const {
     chainConnectors,
@@ -3009,10 +3146,16 @@ const SubAssetsModule = hydrate => {
   const chainConnector = chainConnectors.substrate;
   assert(chainConnector, "This module requires a substrate chain connector");
   return {
-    ...DefaultBalanceModule(moduleType$4),
-    // TODO make synchronous at the module definition level ?
+    ...DefaultBalanceModule(moduleType$5),
     async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
-      if (!metadataRpc) return UNSUPPORTED_CHAIN_META$2;
+      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
+      if (metadataRpc === undefined) return {
+        isTestnet
+      };
+      if ((moduleConfig?.tokens ?? []).length < 1) return {
+        isTestnet
+      };
+      const metadataVersion = getMetadataVersion(metadataRpc);
       const metadata = decAnyMetadata(metadataRpc);
       compactMetadata(metadata, [{
         pallet: "Assets",
@@ -3020,98 +3163,82 @@ const SubAssetsModule = hydrate => {
       }]);
       const miniMetadata = encodeMetadata(metadata);
       return {
+        isTestnet,
         miniMetadata,
-        extra: null
+        metadataVersion
       };
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig, tokens) {
-      if (!tokens?.length) return {};
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
+      if ((moduleConfig?.tokens ?? []).length < 1) return {};
       const {
-        miniMetadata
+        isTestnet,
+        miniMetadata,
+        metadataVersion
       } = chainMeta;
-      if (!miniMetadata) return {};
+      if (miniMetadata === undefined || metadataVersion === undefined) return {};
+      if (metadataVersion < 14) return {};
       const metadata = unifyMetadata(decAnyMetadata(miniMetadata));
       const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
       const assetCoder = scaleBuilder.buildStorage("Assets", "Asset");
       const metadataCoder = scaleBuilder.buildStorage("Assets", "Metadata");
-      const tokenList = {};
-      for (const tokenConfig of tokens ?? []) {
+      const tokens = {};
+      for (const tokenConfig of moduleConfig?.tokens ?? []) {
         try {
-          const assetId = String(tokenConfig.assetId);
+          const assetId = typeof tokenConfig.assetId === "number" ? tokenConfig.assetId.toString() : tokenConfig.assetId;
           const assetStateKey = tryEncode(assetCoder, BigInt(assetId)) ?? tryEncode(assetCoder, assetId);
           const metadataStateKey = tryEncode(metadataCoder, BigInt(assetId)) ?? tryEncode(metadataCoder, assetId);
           if (assetStateKey === null || metadataStateKey === null) throw new Error(`Failed to encode stateKey for asset ${assetId} on chain ${chainId}`);
           const [assetsAsset, assetsMetadata] = await Promise.all([chainConnector.send(chainId, "state_getStorage", [assetStateKey]).then(result => assetCoder.value.dec(result) ?? null), chainConnector.send(chainId, "state_getStorage", [metadataStateKey]).then(result => metadataCoder.value.dec(result) ?? null)]);
           const existentialDeposit = assetsAsset?.min_balance?.toString?.() ?? "0";
           const symbol = assetsMetadata?.symbol?.asText?.() ?? "Unit";
-          const name = assetsMetadata?.name?.asText?.() ?? symbol;
           const decimals = assetsMetadata?.decimals ?? 0;
           const isFrozen = assetsMetadata?.is_frozen ?? false;
-          const id = subAssetTokenId(chainId, assetId);
+          const id = subAssetTokenId(chainId, assetId, symbol);
           const token = {
             id,
             type: "substrate-assets",
-            platform: "polkadot",
+            isTestnet,
             isDefault: tokenConfig?.isDefault ?? true,
-            symbol: tokenConfig?.symbol ?? symbol,
-            name: tokenConfig?.name ?? name,
+            symbol,
             decimals,
-            logo: tokenConfig?.logo,
+            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
             existentialDeposit,
             assetId,
             isFrozen,
-            networkId: chainId
+            chain: {
+              id: chainId
+            }
           };
           if (tokenConfig?.symbol) {
             token.symbol = tokenConfig?.symbol;
-            token.id = subAssetTokenId(chainId, assetId);
+            token.id = subAssetTokenId(chainId, assetId, token.symbol);
           }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+          if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokenList[token.id] = token;
+          tokens[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-assets token ${tokenConfig.assetId} (${tokenConfig.symbol}) on ${chainId}`, error);
           continue;
         }
       }
-      return tokenList;
+      return tokens;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
       addressesByToken
     }, callback) {
-      const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
-        const networkId = parseSubAssetTokenId(tokenId).networkId;
-        if (!acc[networkId]) acc[networkId] = {};
-        acc[networkId][tokenId] = addressesByToken[tokenId];
-        return acc;
-      }, {});
-      const controller = new AbortController();
-      const pUnsubs = Promise.all(toPairs(byNetwork).map(async ([networkId, addressesByToken]) => {
-        try {
-          const queries = await buildNetworkQueries$2(networkId, chainConnector, chaindataProvider, addressesByToken, controller.signal);
-          if (controller.signal.aborted) return () => {};
-          const stateHelper = new RpcStateQueryHelper(chainConnector, queries);
-          return await stateHelper.subscribe((error, result) => {
-            if (error) return callback(error);
-            const balances = result?.filter(b => b !== null) ?? [];
-            if (balances.length > 0) callback(null, new Balances(balances));
-          });
-        } catch (err) {
-          if (!isAbortError(err)) log.error(`Failed to subscribe balances for network ${networkId}`, err);
-          return () => {};
-        }
-      }));
-      return () => {
-        pUnsubs.then(unsubs => {
-          unsubs.forEach(unsubscribe => unsubscribe());
-        });
-        controller.abort();
-      };
+      const queries = await buildQueries$4(chaindataProvider, addressesByToken);
+      const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
+        if (error) return callback(error);
+        const balances = result?.filter(b => b !== null) ?? [];
+        if (balances.length > 0) callback(null, new Balances(balances));
+      });
+      return unsubscribe;
     },
     async fetchBalances(addressesByToken) {
       assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const queries = await buildQueries$3(chainConnector, chaindataProvider, addressesByToken);
+      const queries = await buildQueries$4(chaindataProvider, addressesByToken);
       const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
       const balances = result?.filter(b => b !== null) ?? [];
       return new Balances(balances);
@@ -3132,10 +3259,11 @@ const SubAssetsModule = hydrate => {
       transferMethod,
       userExtensions
     }) {
-      const token = await chaindataProvider.getTokenById(tokenId, "substrate-assets");
+      const token = await chaindataProvider.tokenById(tokenId);
       assert(token, `Token ${tokenId} not found in store`);
-      const chainId = token.networkId;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
+      if (token.type !== "substrate-assets") throw new Error(`This module doesn't handle tokens of type ${token.type}`);
+      const chainId = token.chain.id;
+      const chain = await chaindataProvider.chainById(chainId);
       assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
       const {
         genesisHash
@@ -3180,16 +3308,23 @@ const SubAssetsModule = hydrate => {
     }
   };
 };
-async function buildNetworkQueries$2(networkId, chainConnector, chaindataProvider, addressesByToken, signal) {
-  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType$4, signal);
-  const chain = await chaindataProvider.getNetworkById(networkId, "polkadot");
-  const tokensById = await chaindataProvider.getTokensMapById();
-  signal?.throwIfAborted();
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: ["Assets", "Account"]
+async function buildQueries$4(chaindataProvider, addressesByToken) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const uniqueChainIds = getUniqueChainIds(addressesByToken, tokens);
+  const chains = Object.fromEntries(uniqueChainIds.map(chainId => [chainId, allChains[chainId]]));
+  const chainStorageCoders = buildStorageCoders({
+    chainIds: uniqueChainIds,
+    chains,
+    miniMetadatas,
+    moduleType: "substrate-assets",
+    coders: {
+      storage: ["Assets", "Account"]
+    }
   });
   return Object.entries(addressesByToken).flatMap(([tokenId, addresses]) => {
-    const token = tokensById[tokenId];
+    const token = tokens[tokenId];
     if (!token) {
       log.warn(`Token ${tokenId} not found`);
       return [];
@@ -3198,22 +3333,27 @@ async function buildNetworkQueries$2(networkId, chainConnector, chaindataProvide
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return [];
     }
-    //
+    const chainId = token.chain?.id;
+    if (!chainId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      return [];
+    }
+    const chain = chains[chainId];
     if (!chain) {
-      log.warn(`Chain ${networkId} for token ${tokenId} not found`);
+      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
       return [];
     }
     return addresses.flatMap(address => {
-      const scaleCoder = networkStorageCoders?.storage;
-      const stateKey = tryEncode(scaleCoder, Number(token.assetId), address) ?? tryEncode(scaleCoder, BigInt(token.assetId), address);
+      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
+      const stateKey = tryEncode(scaleCoder, BigInt(token.assetId), address) ?? tryEncode(scaleCoder, token.assetId, address);
       if (!stateKey) {
-        log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+        log.warn(`Invalid assetId / address in ${chainId} storage query ${token.assetId} / ${address}`);
         return [];
       }
       const decodeResult = change => {
         /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
-        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${chainId}`) ?? {
           balance: 0n,
           status: {
             type: "Liquid"
@@ -3247,30 +3387,22 @@ async function buildNetworkQueries$2(networkId, chainConnector, chaindataProvide
           source: "substrate-assets",
           status: "live",
           address,
-          networkId,
+          multiChainId: {
+            subChainId: chainId
+          },
+          chainId,
           tokenId: token.id,
           values: balanceValues
         };
       };
       return {
-        chainId: networkId,
+        chainId,
         stateKey,
         decodeResult
       };
     });
   });
 }
-async function buildQueries$3(chainConnector, chaindataProvider, addressesByToken, signal) {
-  const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
-    const networkId = parseSubAssetTokenId(tokenId).networkId;
-    if (!acc[networkId]) acc[networkId] = {};
-    acc[networkId][tokenId] = addressesByToken[tokenId];
-    return acc;
-  }, {});
-  return (await Promise.all(toPairs(byNetwork).map(([networkId, addressesByToken]) => {
-    return buildNetworkQueries$2(networkId, chainConnector, chaindataProvider, addressesByToken, signal);
-  }))).flat();
-}
 // NOTE: Different chains need different formats for assetId when encoding the stateKey
 // E.g. Polkadot Asset Hub needs it to be a string, Astar needs it to be a bigint
 //
@@ -3283,16 +3415,9 @@ const tryEncode = (scaleCoder, ...args) => {
   }
 };
 
-const moduleType$3 = "substrate-foreignassets";
-const UNSUPPORTED_CHAIN_META$1 = {
-  miniMetadata: null,
-  extra: null
-};
-const SubForeignAssetsTokenConfigSchema = z.strictObject({
-  onChainId: SubForeignAssetsTokenSchema.shape.onChainId,
-  ...TokenConfigBaseSchema.shape
-});
-const SubForeignAssetsModule = hydrate => {
+const moduleType$4 = "substrate-equilibrium";
+const subEquilibriumTokenId = (chainId, tokenSymbol) => `${chainId}-substrate-equilibrium-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
+const SubEquilibriumModule = hydrate => {
   const {
     chainConnectors,
     chaindataProvider
@@ -3300,113 +3425,374 @@ const SubForeignAssetsModule = hydrate => {
   const chainConnector = chainConnectors.substrate;
   assert(chainConnector, "This module requires a substrate chain connector");
   return {
-    ...DefaultBalanceModule(moduleType$3),
+    ...DefaultBalanceModule(moduleType$4),
     async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
-      if (metadataRpc === undefined) return UNSUPPORTED_CHAIN_META$1;
+      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
+      if (metadataRpc === undefined) return {
+        isTestnet
+      };
+      if (moduleConfig?.disable !== false) return {
+        isTestnet
+      }; // default to disabled
+
       const metadataVersion = getMetadataVersion(metadataRpc);
-      if (metadataVersion < 14) return UNSUPPORTED_CHAIN_META$1;
       const metadata = decAnyMetadata(metadataRpc);
       compactMetadata(metadata, [{
-        pallet: "ForeignAssets",
-        items: ["Account", "Asset", "Metadata"]
+        pallet: "EqAssets",
+        items: ["Assets"]
+      }, {
+        pallet: "System",
+        items: ["Account"]
       }]);
       const miniMetadata = encodeMetadata(metadata);
       return {
+        isTestnet,
         miniMetadata,
-        extra: null
+        metadataVersion
       };
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig, tokens) {
-      if (!tokens?.length) return {};
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
+      // default to disabled
+      if (moduleConfig?.disable !== false) return {};
       const {
-        miniMetadata
+        isTestnet,
+        miniMetadata,
+        metadataVersion
       } = chainMeta;
-      if (!miniMetadata) return {};
-      const metadata = decAnyMetadata(miniMetadata);
-      const unifiedMetadata = unifyMetadata(metadata);
-      const scaleBuilder = getDynamicBuilder(getLookupFn(unifiedMetadata));
-      const assetCoder = scaleBuilder.buildStorage("ForeignAssets", "Asset");
-      const metadataCoder = scaleBuilder.buildStorage("ForeignAssets", "Metadata");
-      const tokenList = {};
-      for (const tokenConfig of tokens ?? []) {
-        try {
-          const onChainId = (() => {
-            try {
-              return papiParse(tokenConfig.onChainId);
-            } catch (error) {
-              return tokenConfig.onChainId;
+      if (miniMetadata === undefined || metadataVersion === undefined) return {};
+      if (metadataVersion < 14) return {};
+      try {
+        const metadata = unifyMetadata(decAnyMetadata(miniMetadata));
+        const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
+        const assetsCoder = scaleBuilder.buildStorage("EqAssets", "Assets");
+        const stateKey = assetsCoder.keys.enc();
+
+        /** NOTE: Just a guideline, the RPC can return whatever it wants */
+
+        const assetsResult = await chainConnector.send(chainId, "state_getStorage", [stateKey]).then(result => assetsCoder.value.dec(result) ?? null);
+        const tokens = (Array.isArray(assetsResult) ? assetsResult : []).flatMap(asset => {
+          if (!asset) return [];
+          if (!asset?.id) return [];
+          const assetId = asset.id.toString(10);
+          const symbol = tokenSymbolFromU64Id(asset.id);
+          const id = subEquilibriumTokenId(chainId, symbol);
+          const decimals = DEFAULT_DECIMALS$1;
+          const tokenConfig = (moduleConfig?.tokens ?? []).find(token => token.assetId === assetId);
+          const token = {
+            id,
+            type: "substrate-equilibrium",
+            isTestnet,
+            isDefault: tokenConfig?.isDefault ?? true,
+            symbol,
+            decimals,
+            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+            // TODO: Fetch the ED
+            existentialDeposit: "0",
+            assetId,
+            chain: {
+              id: chainId
             }
-          })();
-          if (onChainId === undefined) continue;
+          };
+          if (tokenConfig?.symbol) {
+            token.symbol = tokenConfig?.symbol;
+            token.id = subEquilibriumTokenId(chainId, token.symbol);
+          }
+          if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+          if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
+          if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
+          return [[token.id, token]];
+        });
+        return Object.fromEntries(tokens);
+      } catch (error) {
+        log.error(`Failed to build substrate-equilibrium tokens on ${chainId}`, error?.message ?? error);
+        return {};
+      }
+    },
+    // TODO: Don't create empty subscriptions
+    async subscribeBalances({
+      addressesByToken
+    }, callback) {
+      const queries = await buildQueries$3(chaindataProvider, addressesByToken);
+      const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
+        if (error) return callback(error);
+        const balances = result?.flatMap(balances => balances) ?? [];
+        if (balances.length > 0) callback(null, new Balances(balances));
+      });
+      return unsubscribe;
+    },
+    async fetchBalances(addressesByToken) {
+      assert(chainConnectors.substrate, "This module requires a substrate chain connector");
+      const queries = await buildQueries$3(chaindataProvider, addressesByToken);
+      const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
+      const balances = result?.flatMap(balances => balances) ?? [];
+      return new Balances(balances);
+    },
+    async transferToken({
+      tokenId,
+      from,
+      to,
+      amount,
+      registry,
+      metadataRpc,
+      blockHash,
+      blockNumber,
+      nonce,
+      specVersion,
+      transactionVersion,
+      tip,
+      transferMethod,
+      userExtensions
+    }) {
+      const token = await chaindataProvider.tokenById(tokenId);
+      assert(token, `Token ${tokenId} not found in store`);
+      if (token.type !== "substrate-equilibrium") throw new Error(`This module doesn't handle tokens of type ${token.type}`);
+      const chainId = token.chain.id;
+      const chain = await chaindataProvider.chainById(chainId);
+      assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
+      const {
+        genesisHash
+      } = chain;
+      const {
+        assetId
+      } = token;
+      const pallet = "EqBalances";
+      const method = transferMethod === "transfer_all" ?
+      // the eqBalances pallet has no transfer_all method
+      "transfer" : transferMethod === "transfer_keep_alive" ?
+      // the eqBalances pallet has no transfer_keep_alive method
+      "transfer" : "transfer";
+      const args = {
+        asset: assetId,
+        to,
+        value: amount
+      };
+      const unsigned = defineMethod({
+        method: {
+          pallet: camelCase(pallet),
+          name: camelCase(method),
+          args
+        },
+        address: from,
+        blockHash,
+        blockNumber,
+        eraPeriod: 64,
+        genesisHash,
+        metadataRpc,
+        nonce,
+        specVersion,
+        tip: tip ? Number(tip) : 0,
+        transactionVersion
+      }, {
+        metadataRpc,
+        registry,
+        userExtensions
+      });
+      return {
+        type: "substrate",
+        callData: unsigned.method
+      };
+    }
+  };
+};
+async function buildQueries$3(chaindataProvider, addressesByToken) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const uniqueChainIds = getUniqueChainIds(addressesByToken, tokens);
+  const chains = Object.fromEntries(uniqueChainIds.map(chainId => [chainId, allChains[chainId]]));
+  const chainStorageCoders = buildStorageCoders({
+    chainIds: uniqueChainIds,
+    chains,
+    miniMetadatas,
+    moduleType: "substrate-equilibrium",
+    coders: {
+      storage: ["System", "Account"]
+    }
+  });
+
+  // equilibrium returns all chain tokens for each address in the one query
+  // so, we only need to make one query per address, rather than one query per token per address
+  const addressesByChain = new Map();
+  const tokensByAddress = new Map();
+  Object.entries(addressesByToken).map(([tokenId, addresses]) => {
+    const token = tokens[tokenId];
+    if (!token) return log.warn(`Token ${tokenId} not found`);
+    if (token.type !== "substrate-equilibrium") return log.debug(`This module doesn't handle tokens of type ${token.type}`);
+    const chainId = token?.chain?.id;
+    if (!chainId) return log.warn(`Token ${tokenId} has no chain`);
+    const byChain = addressesByChain.get(chainId) ?? new Set();
+    addresses.forEach(address => {
+      byChain?.add(address);
+      tokensByAddress.set(address, (tokensByAddress.get(address) ?? new Set()).add(token));
+    });
+    addressesByChain.set(chainId, byChain);
+  });
+  return Array.from(addressesByChain).flatMap(([chainId, addresses]) => {
+    const chain = chains[chainId];
+    if (!chain) {
+      log.warn(`Chain ${chainId} not found`);
+      return [];
+    }
+    return Array.from(addresses).flatMap(address => {
+      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
+      const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} storage query ${address}`, address);
+      if (!stateKey) return [];
+      const decodeResult = change => {
+        /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode eqBalances on chain ${chainId}`);
+        const tokenBalances = Object.fromEntries((decoded?.data?.value?.balance ?? []).map(balance => ({
+          id: (balance?.[0] ?? 0n)?.toString?.(),
+          free: balance?.[1]?.type === "Positive" ? (balance?.[1]?.value ?? 0n).toString() : balance?.[1]?.type === "Negative" ? ((balance?.[1]?.value ?? 0n) * -1n).toString() : "0"
+        })).map(({
+          id,
+          free
+        }) => [id, free]).filter(([id, free]) => id !== undefined && free !== undefined));
+        const result = Array.from(tokensByAddress.get(address) ?? []).filter(t => t.chain.id === chainId).map(token => {
+          const value = tokenBalances[token.assetId];
+          return {
+            source: "substrate-equilibrium",
+            status: "live",
+            address,
+            multiChainId: {
+              subChainId: chainId
+            },
+            chainId,
+            tokenId: token.id,
+            value
+          };
+        }).filter(b => b !== undefined);
+        return result;
+      };
+      return {
+        chainId,
+        stateKey,
+        decodeResult
+      };
+    });
+  });
+}
+const DEFAULT_DECIMALS$1 = 9;
+const tokenSymbolFromU64Id = u64 => {
+  const bytes = [];
+  let num = typeof u64 === "number" ? BigInt(u64) : isBigInt(u64) ? u64 : u64.toBigInt();
+  do {
+    bytes.unshift(Number(num % 256n));
+    num = num / 256n;
+  } while (num > 0);
+  return new TextDecoder("utf-8").decode(new Uint8Array(bytes)).toUpperCase();
+};
+
+const moduleType$3 = "substrate-foreignassets";
+const subForeignAssetTokenId = (chainId, tokenSymbol) => `${chainId}-substrate-foreignassets-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
+const SubForeignAssetsModule = hydrate => {
+  const {
+    chainConnectors,
+    chaindataProvider
+  } = hydrate;
+  const chainConnector = chainConnectors.substrate;
+  assert(chainConnector, "This module requires a substrate chain connector");
+  return {
+    ...DefaultBalanceModule(moduleType$3),
+    async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
+      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
+      if (metadataRpc === undefined) return {
+        isTestnet
+      };
+      if ((moduleConfig?.tokens ?? []).length < 1) return {
+        isTestnet
+      };
+      const metadataVersion = getMetadataVersion(metadataRpc);
+      const metadata = decAnyMetadata(metadataRpc);
+      compactMetadata(metadata, [{
+        pallet: "ForeignAssets",
+        items: ["Account", "Asset", "Metadata"]
+      }]);
+      const miniMetadata = encodeMetadata(metadata);
+      return {
+        isTestnet,
+        miniMetadata,
+        metadataVersion
+      };
+    },
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
+      if ((moduleConfig?.tokens ?? []).length < 1) return {};
+      const {
+        isTestnet,
+        miniMetadata,
+        metadataVersion
+      } = chainMeta;
+      if (miniMetadata === undefined || metadataVersion === undefined) return {};
+      if (metadataVersion < 14) return {};
+      const metadata = decAnyMetadata(miniMetadata);
+      const unifiedMetadata = unifyMetadata(metadata);
+      const scaleBuilder = getDynamicBuilder(getLookupFn(unifiedMetadata));
+      const assetCoder = scaleBuilder.buildStorage("ForeignAssets", "Asset");
+      const metadataCoder = scaleBuilder.buildStorage("ForeignAssets", "Metadata");
+      const tokens = {};
+      for (const tokenConfig of moduleConfig?.tokens ?? []) {
+        try {
+          const onChainId = (() => {
+            try {
+              return papiParse(tokenConfig.onChainId);
+            } catch (error) {
+              return tokenConfig.onChainId;
+            }
+          })();
+          if (onChainId === undefined) continue;
           const assetStateKey = assetCoder.keys.enc(onChainId);
           const metadataStateKey = metadataCoder.keys.enc(onChainId);
           const [assetsAsset, assetsMetadata] = await Promise.all([chainConnector.send(chainId, "state_getStorage", [assetStateKey]).then(result => assetCoder.value.dec(result) ?? null), chainConnector.send(chainId, "state_getStorage", [metadataStateKey]).then(result => metadataCoder.value.dec(result) ?? null)]);
           const existentialDeposit = assetsAsset?.min_balance?.toString?.() ?? "0";
           const symbol = assetsMetadata?.symbol?.asText?.() ?? "Unit";
-          const name = assetsMetadata?.name?.asText?.() ?? symbol;
           const decimals = assetsMetadata?.decimals ?? 0;
           const isFrozen = assetsMetadata?.is_frozen ?? false;
-          const id = subForeignAssetTokenId(chainId, tokenConfig.onChainId);
+          const id = subForeignAssetTokenId(chainId, symbol);
           const token = {
             id,
             type: "substrate-foreignassets",
-            platform: "polkadot",
+            isTestnet,
             isDefault: tokenConfig?.isDefault ?? true,
             symbol,
             decimals,
-            name: tokenConfig?.name ?? name,
-            logo: tokenConfig?.logo,
+            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
             existentialDeposit,
             onChainId: tokenConfig.onChainId,
             isFrozen,
-            networkId: chainId
+            chain: {
+              id: chainId
+            }
           };
+          if (tokenConfig?.symbol) {
+            token.symbol = tokenConfig?.symbol;
+            token.id = subForeignAssetTokenId(chainId, token.symbol);
+          }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+          if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokenList[token.id] = token;
+          tokens[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-foreignassets token ${tokenConfig.onChainId} (${tokenConfig.symbol}) on ${chainId}`, error?.message ?? error);
           continue;
         }
       }
-      return tokenList;
+      return tokens;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
       addressesByToken
     }, callback) {
-      const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
-        const networkId = parseSubForeignAssetTokenId(tokenId).networkId;
-        if (!acc[networkId]) acc[networkId] = {};
-        acc[networkId][tokenId] = addressesByToken[tokenId];
-        return acc;
-      }, {});
-      const controller = new AbortController();
-      const pUnsubs = Promise.all(toPairs(byNetwork).map(async ([networkId, addressesByToken]) => {
-        try {
-          const queries = await buildNetworkQueries$1(networkId, chainConnector, chaindataProvider, addressesByToken, controller.signal);
-          if (controller.signal.aborted) return () => {};
-          const stateHelper = new RpcStateQueryHelper(chainConnector, queries);
-          return await stateHelper.subscribe((error, result) => {
-            if (error) return callback(error);
-            const balances = result?.filter(b => b !== null) ?? [];
-            if (balances.length > 0) callback(null, new Balances(balances));
-          });
-        } catch (err) {
-          if (!isAbortError(err)) log.error(`Failed to subscribe ${moduleType$3} balances for network ${networkId}`, err);
-          return () => {};
-        }
-      }));
-      return () => {
-        pUnsubs.then(unsubs => {
-          unsubs.forEach(unsubscribe => unsubscribe());
-        });
-        controller.abort();
-      };
+      const queries = await buildQueries$2(chaindataProvider, addressesByToken);
+      const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
+        if (error) return callback(error);
+        const balances = result?.filter(b => b !== null) ?? [];
+        if (balances.length > 0) callback(null, new Balances(balances));
+      });
+      return unsubscribe;
     },
     async fetchBalances(addressesByToken) {
       assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const queries = await buildQueries$2(chainConnector, chaindataProvider, addressesByToken);
+      const queries = await buildQueries$2(chaindataProvider, addressesByToken);
       const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
       const balances = result?.filter(b => b !== null) ?? [];
       return new Balances(balances);
@@ -3418,10 +3804,11 @@ const SubForeignAssetsModule = hydrate => {
       transferMethod,
       metadataRpc
     }) {
-      const token = await chaindataProvider.getTokenById(tokenId, "substrate-foreignassets");
+      const token = await chaindataProvider.tokenById(tokenId);
       assert(token, `Token ${tokenId} not found in store`);
-      const chainId = token.networkId;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
+      if (token.type !== "substrate-foreignassets") throw new Error(`This module doesn't handle tokens of type ${token.type}`);
+      const chainId = token.chain.id;
+      const chain = await chaindataProvider.chainById(chainId);
       assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
       const onChainId = (() => {
         try {
@@ -3461,16 +3848,23 @@ const SubForeignAssetsModule = hydrate => {
     }
   };
 };
-async function buildNetworkQueries$1(networkId, chainConnector, chaindataProvider, addressesByToken, signal) {
-  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType$3, signal);
-  const chain = await chaindataProvider.getNetworkById(networkId, "polkadot");
-  const tokensById = await chaindataProvider.getTokensMapById();
-  signal?.throwIfAborted();
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: ["ForeignAssets", "Account"]
+async function buildQueries$2(chaindataProvider, addressesByToken) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const uniqueChainIds = getUniqueChainIds(addressesByToken, tokens);
+  const chains = Object.fromEntries(uniqueChainIds.map(chainId => [chainId, allChains[chainId]]));
+  const chainStorageCoders = buildStorageCoders({
+    chainIds: uniqueChainIds,
+    chains,
+    miniMetadatas,
+    moduleType: "substrate-foreignassets",
+    coders: {
+      storage: ["ForeignAssets", "Account"]
+    }
   });
   return Object.entries(addressesByToken).flatMap(([tokenId, addresses]) => {
-    const token = tokensById[tokenId];
+    const token = tokens[tokenId];
     if (!token) {
       log.warn(`Token ${tokenId} not found`);
       return [];
@@ -3479,12 +3873,18 @@ async function buildNetworkQueries$1(networkId, chainConnector, chaindataProvide
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return [];
     }
+    const chainId = token.chain?.id;
+    if (!chainId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      return [];
+    }
+    const chain = chains[chainId];
     if (!chain) {
-      log.warn(`Chain ${networkId} for token ${tokenId} not found`);
+      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
       return [];
     }
     return addresses.flatMap(address => {
-      const scaleCoder = networkStorageCoders?.storage;
+      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
       const onChainId = (() => {
         try {
           return papiParse(token.onChainId);
@@ -3492,12 +3892,12 @@ async function buildNetworkQueries$1(networkId, chainConnector, chaindataProvide
           return token.onChainId;
         }
       })();
-      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${networkId} storage query ${address} / ${token.onChainId}`, onChainId, address);
+      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${chainId} storage query ${address} / ${token.onChainId}`, onChainId, address);
       if (!stateKey) return [];
       const decodeResult = change => {
         /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
-        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-foreignassets balance on chain ${networkId}`) ?? {
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-foreignassets balance on chain ${chainId}`) ?? {
           balance: 0n,
           status: {
             type: "Liquid"
@@ -3531,54 +3931,29 @@ async function buildNetworkQueries$1(networkId, chainConnector, chaindataProvide
           source: "substrate-foreignassets",
           status: "live",
           address,
-          networkId,
+          multiChainId: {
+            subChainId: chainId
+          },
+          chainId,
           tokenId: token.id,
           values: balanceValues
         };
       };
       return {
-        chainId: networkId,
+        chainId,
         stateKey,
         decodeResult
       };
     });
   });
 }
-async function buildQueries$2(chainConnector, chaindataProvider, addressesByToken, signal) {
-  const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
-    const networkId = parseSubForeignAssetTokenId(tokenId).networkId;
-    if (!acc[networkId]) acc[networkId] = {};
-    acc[networkId][tokenId] = addressesByToken[tokenId];
-    return acc;
-  }, {});
-  return (await Promise.all(toPairs(byNetwork).map(([networkId, addressesByToken]) => {
-    return buildNetworkQueries$1(networkId, chainConnector, chaindataProvider, addressesByToken, signal);
-  }))).flat();
-}
-
-const getAddresssesByTokenByNetwork = addressesByToken => {
-  const addressesByTokenByNetwork = toPairs(addressesByToken).reduce((acc, [tokenId, addresses]) => {
-    const networkId = parseTokenId(tokenId).networkId;
-    if (!acc[networkId]) acc[networkId] = {};
-    acc[networkId][tokenId] = addresses;
-    return acc;
-  }, {});
-  return addressesByTokenByNetwork;
-};
 
 async function subscribeBase(queries, chainConnector, callback) {
-  try {
-    const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
-      if (error) callback(error);
-      if (result && result.length > 0) callback(null, result);
-    });
-    return unsubscribe;
-  } catch (err) {
-    if (!isAbortError(err)) log.error("Error subscribing to base queries", {
-      err
-    });
-    return () => {};
-  }
+  const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
+    if (error) callback(error);
+    if (result && result.length > 0) callback(null, result);
+  });
+  return unsubscribe;
 }
 
 /**
@@ -3594,6 +3969,262 @@ const asObservable = handler => (...args) => new Observable(subscriber => {
   return unsubscribe;
 });
 
+/**
+ * Crowdloan contributions are stored in the `childstate` key returned by this function.
+ */
+const crowdloanFundContributionsChildKey = fundIndex => u8aToHex(u8aConcat(":child_storage:default:", blake2AsU8a(u8aConcat("crowdloan", u32.enc(fundIndex)))));
+
+async function subscribeCrowdloans(chaindataProvider, chainConnector, addressesByToken, callback) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const crowdloanTokenIds = Object.entries(tokens).filter(([, token]) => {
+    // ignore non-native tokens
+    if (token.type !== "substrate-native") return;
+    // ignore tokens on chains with no crowdloans pallet
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", allChains[token.chain.id]);
+    return typeof chainMeta?.crowdloanPalletId === "string";
+  }).map(([tokenId]) => tokenId);
+
+  // crowdloan contributions can only be done by the native token on chains with the crowdloan pallet
+  const addressesByCrowdloanToken = Object.fromEntries(Object.entries(addressesByToken)
+  // remove ethereum addresses
+  .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
+  // remove tokens which aren't crowdloan tokens
+  .filter(([tokenId]) => crowdloanTokenIds.includes(tokenId)));
+  const uniqueChainIds = getUniqueChainIds(addressesByCrowdloanToken, tokens);
+  const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
+  const chainStorageCoders = buildStorageCoders({
+    chainIds: uniqueChainIds,
+    chains,
+    miniMetadatas,
+    moduleType: "substrate-native",
+    coders: {
+      parachains: ["Paras", "Parachains"],
+      funds: ["Crowdloan", "Funds"]
+    }
+  });
+  const tokenSubscriptions = [];
+  for (const [tokenId, addresses] of Object.entries(addressesByCrowdloanToken)) {
+    const token = tokens[tokenId];
+    if (!token) {
+      log.warn(`Token ${tokenId} not found`);
+      continue;
+    }
+    if (token.type !== "substrate-native") {
+      log.debug(`This module doesn't handle tokens of type ${token.type}`);
+      continue;
+    }
+    const chainId = token.chain?.id;
+    if (!chainId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      continue;
+    }
+    const chain = chains[chainId];
+    if (!chain) {
+      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      continue;
+    }
+    const subscribeParaIds = callback => {
+      const scaleCoder = chainStorageCoders.get(chainId)?.parachains;
+      const queries = [0].flatMap(() => {
+        const stateKey = encodeStateKey(scaleCoder);
+        if (!stateKey) return [];
+        const decodeResult = change => {
+          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+          const decoded = decodeScale(scaleCoder, change, `Failed to decode parachains on chain ${chainId}`);
+          const paraIds = decoded ?? [];
+          return paraIds;
+        };
+        return {
+          chainId,
+          stateKey,
+          decodeResult
+        };
+      });
+      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+      return () => subscription.then(unsubscribe => unsubscribe());
+    };
+    const subscribeParaFundIndexes = (paraIds, callback) => {
+      const scaleCoder = chainStorageCoders.get(chainId)?.funds;
+      const queries = paraIds.flatMap(paraId => {
+        const stateKey = encodeStateKey(scaleCoder, `Invalid paraId in ${chainId} funds query ${paraId}`, paraId);
+        if (!stateKey) return [];
+        const decodeResult = change => {
+          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+          const decoded = decodeScale(scaleCoder, change, `Failed to decode paras on chain ${chainId}`);
+          const firstPeriod = decoded?.first_period?.toString?.() ?? "";
+          const lastPeriod = decoded?.last_period?.toString?.() ?? "";
+          const fundPeriod = `${firstPeriod}-${lastPeriod}`;
+          const fundIndex = decoded?.fund_index ?? decoded?.trie_index;
+          return {
+            paraId,
+            fundPeriod,
+            fundIndex
+          };
+        };
+        return {
+          chainId,
+          stateKey,
+          decodeResult
+        };
+      });
+      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+      return () => subscription.then(unsubscribe => unsubscribe());
+    };
+    const subscribeFundContributions = (funds, addresses, callback) => {
+      // TODO: Watch system_events in order to subscribe to changes, then redo the contributions query when changes are detected:
+      // https://github.com/polkadot-js/api/blob/8fe02a14345b57e6abb8f7f2c2b624cf70c51b23/packages/api-derive/src/crowdloan/ownContributions.ts#L32-L47
+      //
+      // For now we just re-fetch all contributions on a timer and then only send them to the subscription callback when they have changed
+
+      const queries = funds.map(({
+        paraId,
+        fundIndex
+      }) => ({
+        paraId,
+        fundIndex,
+        addresses,
+        childKey: crowdloanFundContributionsChildKey(fundIndex),
+        storageKeys: addresses.map(address => u8aToHex(decodeAnyAddress(address)))
+      }));
+
+      // track whether our caller is still subscribed
+      let subscriptionActive = true;
+      let previousContributions = null;
+      const fetchContributions = async () => {
+        try {
+          const results = await Promise.all(queries.map(async ({
+            paraId,
+            fundIndex,
+            addresses,
+            childKey,
+            storageKeys
+          }) => ({
+            paraId,
+            fundIndex,
+            addresses,
+            result: await chainConnector.send(chainId, "childstate_getStorageEntries", [childKey, storageKeys])
+          })));
+          const contributions = results.flatMap(queryResult => {
+            const {
+              paraId,
+              fundIndex,
+              addresses,
+              result
+            } = queryResult;
+            return (Array.isArray(result) ? result : []).flatMap((encoded, index) => {
+              const amount = (() => {
+                try {
+                  return typeof encoded === "string" ? u128.dec(encoded) ?? 0n : 0n;
+                } catch {
+                  return 0n;
+                }
+              })().toString();
+              return {
+                paraId,
+                fundIndex,
+                address: addresses[index],
+                amount
+              };
+            });
+          });
+
+          // ignore these results if our caller has tried to close this subscription
+          if (!subscriptionActive) return;
+
+          // ignore these results if they're the same as what we previously fetched
+          if (isEqual(previousContributions, contributions)) return;
+          previousContributions = contributions;
+          callback(null, contributions);
+        } catch (error) {
+          callback(error);
+        }
+      };
+
+      // set up polling for contributions
+      const crowdloanContributionsPollInterval = 60_000; // 60_000ms === 1 minute
+      const pollContributions = async () => {
+        if (!subscriptionActive) return;
+        try {
+          await fetchContributions();
+        } catch (error) {
+          // log any errors, but don't cancel the poll for contributions when one fetch fails
+          log.error(error);
+        }
+        if (!subscriptionActive) return;
+        setTimeout(pollContributions, crowdloanContributionsPollInterval);
+      };
+
+      // start polling
+      pollContributions();
+      return () => {
+        // stop polling
+        subscriptionActive = false;
+      };
+    };
+    const paraIds$ = asObservable(subscribeParaIds)().pipe(scan((_, next) => Array.from(new Set(next.flatMap(paraIds => paraIds))), []), share());
+    const fundIndexesByParaId$ = paraIds$.pipe(map(paraIds => asObservable(subscribeParaFundIndexes)(paraIds)), switchAll(), scan((state, next) => {
+      for (const fund of next) {
+        const {
+          paraId,
+          fundIndex
+        } = fund;
+        if (typeof fundIndex === "number") {
+          state.set(paraId, (state.get(paraId) ?? new Set()).add(fundIndex));
+        }
+      }
+      return state;
+    }, new Map()));
+    const contributionsByAddress$ = fundIndexesByParaId$.pipe(map(fundIndexesByParaId => Array.from(fundIndexesByParaId).flatMap(([paraId, fundIndexes]) => Array.from(fundIndexes).map(fundIndex => ({
+      paraId,
+      fundIndex
+    })))), map(funds => asObservable(subscribeFundContributions)(funds, addresses)), switchAll(), scan((state, next) => {
+      for (const contribution of next) {
+        const {
+          address
+        } = contribution;
+        state.set(address, (state.get(address) ?? new Set()).add(contribution));
+      }
+      return state;
+    }, new Map()));
+    const subscription = contributionsByAddress$.subscribe({
+      next: contributionsByAddress => {
+        const balances = Array.from(contributionsByAddress).map(([address, contributions]) => {
+          return {
+            source: "substrate-native",
+            status: "live",
+            address,
+            multiChainId: {
+              subChainId: chainId
+            },
+            chainId,
+            tokenId,
+            values: Array.from(contributions).map(({
+              amount,
+              paraId
+            }) => ({
+              type: "crowdloan",
+              label: "crowdloan",
+              source: "crowdloan",
+              amount: amount,
+              meta: {
+                paraId
+              }
+            }))
+          };
+        });
+        if (balances.length > 0) callback(null, balances);
+      },
+      error: error => callback(error)
+    });
+    tokenSubscriptions.push(() => subscription.unsubscribe());
+  }
+  return () => tokenSubscriptions.forEach(unsub => unsub());
+}
+
 /**
  * Each nominationPool in the nominationPools pallet has access to some accountIds which have no
  * associated private key. Instead, they are derived from this function.
@@ -3613,293 +4244,280 @@ const nompoolAccountId = (palletId, poolId, index) => {
 /** The stash account for the nomination pool */
 const nompoolStashAccountId = (palletId, poolId) => nompoolAccountId(palletId, poolId, 0);
 
-// TODO make this method chain-specific
-async function subscribeNompoolStaking(chaindataProvider, chainConnector, addressesByToken, callback, signal) {
-  try {
-    const allChains = await chaindataProvider.getNetworksMapById("polkadot");
-    const tokens = await chaindataProvider.getTokensMapById();
-
-    // there should be only one network here when subscribing to balances, we've split it up by network at the top level
-    const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
-    const miniMetadatas = new Map();
-    for (const networkId of networkIds) {
-      const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native");
-      miniMetadatas.set(networkId, miniMetadata);
+async function subscribeNompoolStaking(chaindataProvider, chainConnector, addressesByToken, callback) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const nomPoolTokenIds = Object.entries(tokens).filter(([, token]) => {
+    // ignore non-native tokens
+    if (token.type !== "substrate-native") return false;
+    // ignore tokens on chains with no nompools pallet
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", allChains[token.chain.id]);
+    return typeof chainMeta?.nominationPoolsPalletId === "string";
+  }).map(([tokenId]) => tokenId);
+
+  // staking can only be done by the native token on chains with the staking pallet
+  const addressesByNomPoolToken = Object.fromEntries(Object.entries(addressesByToken)
+  // remove ethereum addresses
+  .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
+  // remove tokens which aren't nom pool tokens
+  .filter(([tokenId]) => nomPoolTokenIds.includes(tokenId)));
+  const uniqueChainIds = getUniqueChainIds(addressesByNomPoolToken, tokens);
+  const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
+  const chainStorageCoders = buildStorageCoders({
+    chainIds: uniqueChainIds,
+    chains,
+    miniMetadatas,
+    moduleType: "substrate-native",
+    coders: {
+      poolMembers: ["NominationPools", "PoolMembers"],
+      bondedPools: ["NominationPools", "BondedPools"],
+      ledger: ["Staking", "Ledger"],
+      metadata: ["NominationPools", "Metadata"]
     }
-    signal?.throwIfAborted();
-    const nomPoolTokenIds = Object.entries(tokens).filter(([, token]) => {
-      // ignore non-native tokens
-      if (token.type !== "substrate-native") return false;
-
-      // ignore tokens on chains with no nompools pallet
-      const miniMetadata = miniMetadatas.get(token.networkId);
-      return typeof miniMetadata?.extra?.nominationPoolsPalletId === "string";
-    }).map(([tokenId]) => tokenId);
-
-    // staking can only be done by the native token on chains with the staking pallet
-    const addressesByNomPoolToken = Object.fromEntries(Object.entries(addressesByToken)
-    // remove ethereum addresses
-    .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
-    // remove tokens which aren't nom pool tokens
-    .filter(([tokenId]) => nomPoolTokenIds.includes(tokenId)));
-    const uniqueChainIds = getUniqueChainIds(addressesByNomPoolToken, tokens);
-    const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
-    const chainStorageCoders = buildStorageCoders({
-      chainIds: uniqueChainIds,
-      chains,
-      miniMetadatas,
-      coders: {
-        poolMembers: ["NominationPools", "PoolMembers"],
-        bondedPools: ["NominationPools", "BondedPools"],
-        ledger: ["Staking", "Ledger"],
-        metadata: ["NominationPools", "Metadata"]
-      }
-    });
-    const resultUnsubscribes = [];
-    for (const [tokenId, addresses] of Object.entries(addressesByNomPoolToken)) {
-      const token = tokens[tokenId];
-      if (!token) {
-        log.warn(`Token ${tokenId} not found`);
-        continue;
-      }
-      if (token.type !== "substrate-native") {
-        log.debug(`This module doesn't handle tokens of type ${token.type}`);
-        continue;
-      }
-      const chainId = token.networkId;
-      if (!chainId) {
-        log.warn(`Token ${tokenId} has no chain`);
-        continue;
-      }
-      const chain = chains[chainId];
-      if (!chain) {
-        log.warn(`Chain ${chainId} for token ${tokenId} not found`);
-        continue;
-      }
-      const miniMetadata = miniMetadatas.get(chainId);
-      const {
-        nominationPoolsPalletId
-      } = miniMetadata?.extra ?? {};
-      const subscribePoolMembers = (addresses, callback) => {
-        const scaleCoder = chainStorageCoders.get(chainId)?.poolMembers;
-        const queries = addresses.flatMap(address => {
-          const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} poolMembers query ${address}`, address);
-          if (!stateKey) return [];
-          const decodeResult = change => {
-            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-            const decoded = decodeScale(scaleCoder, change, `Failed to decode poolMembers on chain ${chainId}`);
-            const poolId = decoded?.pool_id?.toString?.();
-            const points = decoded?.points?.toString?.();
-            const unbondingEras = Array.from(decoded?.unbonding_eras ?? []).flatMap(entry => {
-              if (entry === undefined) return [];
-              const [key, value] = Array.from(entry);
-              const era = key?.toString?.();
-              const amount = value?.toString?.();
-              if (typeof era !== "string" || typeof amount !== "string") return [];
-              return {
-                era,
-                amount
-              };
-            });
-            return {
-              tokenId,
-              address,
-              poolId,
-              points,
-              unbondingEras
-            };
-          };
-          return {
-            chainId,
-            stateKey,
-            decodeResult
-          };
-        });
-        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-        return () => subscription.then(unsubscribe => unsubscribe());
-      };
-      const subscribePoolPoints = (poolIds, callback) => {
-        if (poolIds.length === 0) callback(null, []);
-        const scaleCoder = chainStorageCoders.get(chainId)?.bondedPools;
-        const queries = poolIds.flatMap(poolId => {
-          const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} bondedPools query ${poolId}`, poolId);
-          if (!stateKey) return [];
-          const decodeResult = change => {
-            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-            const decoded = decodeScale(scaleCoder, change, `Failed to decode bondedPools on chain ${chainId}`);
-            const points = decoded?.points?.toString?.();
-            return {
-              poolId,
-              points
-            };
-          };
-          return {
-            chainId,
-            stateKey,
-            decodeResult
-          };
-        });
-        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-        return () => subscription.then(unsubscribe => unsubscribe());
-      };
-      const subscribePoolStake = (poolIds, callback) => {
-        if (poolIds.length === 0) callback(null, []);
-        const scaleCoder = chainStorageCoders.get(chainId)?.ledger;
-        const queries = poolIds.flatMap(poolId => {
-          if (!nominationPoolsPalletId) return [];
-          const stashAddress = nompoolStashAccountId(nominationPoolsPalletId, poolId);
-          const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} ledger query ${stashAddress}`, stashAddress);
-          if (!stateKey) return [];
-          const decodeResult = change => {
-            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-            const decoded = decodeScale(scaleCoder, change, `Failed to decode ledger on chain ${chainId}`);
-            const activeStake = decoded?.active?.toString?.();
-            return {
-              poolId,
-              activeStake
-            };
-          };
-          return {
-            chainId,
-            stateKey,
-            decodeResult
-          };
-        });
-        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-        return () => subscription.then(unsubscribe => unsubscribe());
-      };
-      const subscribePoolMetadata = (poolIds, callback) => {
-        if (poolIds.length === 0) callback(null, []);
-        const scaleCoder = chainStorageCoders.get(chainId)?.metadata;
-        const queries = poolIds.flatMap(poolId => {
-          if (!nominationPoolsPalletId) return [];
-          const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} metadata query ${poolId}`, poolId);
-          if (!stateKey) return [];
-          const decodeResult = change => {
-            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-            const decoded = decodeScale(scaleCoder, change, `Failed to decode metadata on chain ${chainId}`);
-            const metadata = decoded?.asText?.();
+  });
+  const resultUnsubscribes = [];
+  for (const [tokenId, addresses] of Object.entries(addressesByNomPoolToken)) {
+    const token = tokens[tokenId];
+    if (!token) {
+      log.warn(`Token ${tokenId} not found`);
+      continue;
+    }
+    if (token.type !== "substrate-native") {
+      log.debug(`This module doesn't handle tokens of type ${token.type}`);
+      continue;
+    }
+    const chainId = token.chain?.id;
+    if (!chainId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      continue;
+    }
+    const chain = chains[chainId];
+    if (!chain) {
+      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      continue;
+    }
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", chain);
+    const {
+      nominationPoolsPalletId
+    } = chainMeta ?? {};
+    const subscribePoolMembers = (addresses, callback) => {
+      const scaleCoder = chainStorageCoders.get(chainId)?.poolMembers;
+      const queries = addresses.flatMap(address => {
+        const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} poolMembers query ${address}`, address);
+        if (!stateKey) return [];
+        const decodeResult = change => {
+          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+          const decoded = decodeScale(scaleCoder, change, `Failed to decode poolMembers on chain ${chainId}`);
+          const poolId = decoded?.pool_id?.toString?.();
+          const points = decoded?.points?.toString?.();
+          const unbondingEras = Array.from(decoded?.unbonding_eras ?? []).flatMap(entry => {
+            if (entry === undefined) return [];
+            const [key, value] = Array.from(entry);
+            const era = key?.toString?.();
+            const amount = value?.toString?.();
+            if (typeof era !== "string" || typeof amount !== "string") return [];
             return {
-              poolId,
-              metadata
+              era,
+              amount
             };
-          };
+          });
           return {
-            chainId,
-            stateKey,
-            decodeResult
-          };
-        });
-        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-        return () => subscription.then(unsubscribe => unsubscribe());
-      };
-      const poolMembersByAddress$ = asObservable(subscribePoolMembers)(addresses).pipe(scan((state, next) => {
-        for (const poolMembers of next) {
-          const {
-            poolId,
-            points,
-            unbondingEras
-          } = poolMembers;
-          if (typeof poolId === "string" && typeof points === "string") state.set(poolMembers.address, {
+            tokenId,
+            address,
             poolId,
             points,
             unbondingEras
-          });else state.set(poolMembers.address, null);
-        }
-        return state;
-      }, new Map()), share());
-      const poolIdByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.poolId ?? null]))));
-      const pointsByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.points ?? null]))));
-      const unbondingErasByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.unbondingEras ?? null]))));
-      const poolIds$ = poolIdByAddress$.pipe(map(byAddress => [...new Set(Array.from(byAddress.values()).flatMap(poolId => poolId ?? []))]));
-      const pointsByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolPoints)(poolIds)), switchAll(), scan((state, next) => {
-        for (const poolPoints of next) {
-          const {
+          };
+        };
+        return {
+          chainId,
+          stateKey,
+          decodeResult
+        };
+      });
+      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+      return () => subscription.then(unsubscribe => unsubscribe());
+    };
+    const subscribePoolPoints = (poolIds, callback) => {
+      if (poolIds.length === 0) callback(null, []);
+      const scaleCoder = chainStorageCoders.get(chainId)?.bondedPools;
+      const queries = poolIds.flatMap(poolId => {
+        const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} bondedPools query ${poolId}`, poolId);
+        if (!stateKey) return [];
+        const decodeResult = change => {
+          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+          const decoded = decodeScale(scaleCoder, change, `Failed to decode bondedPools on chain ${chainId}`);
+          const points = decoded?.points?.toString?.();
+          return {
             poolId,
             points
-          } = poolPoints;
-          if (typeof points === "string") state.set(poolId, points);else state.delete(poolId);
-        }
-        return state;
-      }, new Map()));
-      const stakeByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolStake)(poolIds)), switchAll(), scan((state, next) => {
-        for (const poolStake of next) {
-          const {
+          };
+        };
+        return {
+          chainId,
+          stateKey,
+          decodeResult
+        };
+      });
+      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+      return () => subscription.then(unsubscribe => unsubscribe());
+    };
+    const subscribePoolStake = (poolIds, callback) => {
+      if (poolIds.length === 0) callback(null, []);
+      const scaleCoder = chainStorageCoders.get(chainId)?.ledger;
+      const queries = poolIds.flatMap(poolId => {
+        if (!nominationPoolsPalletId) return [];
+        const stashAddress = nompoolStashAccountId(nominationPoolsPalletId, poolId);
+        const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} ledger query ${stashAddress}`, stashAddress);
+        if (!stateKey) return [];
+        const decodeResult = change => {
+          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+          const decoded = decodeScale(scaleCoder, change, `Failed to decode ledger on chain ${chainId}`);
+          const activeStake = decoded?.active?.toString?.();
+          return {
             poolId,
             activeStake
-          } = poolStake;
-          if (typeof activeStake === "string") state.set(poolId, activeStake);else state.delete(poolId);
-        }
-        return state;
-      }, new Map()));
-      const metadataByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolMetadata)(poolIds)), switchAll(), scan((state, next) => {
-        for (const poolMetadata of next) {
-          const {
+          };
+        };
+        return {
+          chainId,
+          stateKey,
+          decodeResult
+        };
+      });
+      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+      return () => subscription.then(unsubscribe => unsubscribe());
+    };
+    const subscribePoolMetadata = (poolIds, callback) => {
+      if (poolIds.length === 0) callback(null, []);
+      const scaleCoder = chainStorageCoders.get(chainId)?.metadata;
+      const queries = poolIds.flatMap(poolId => {
+        if (!nominationPoolsPalletId) return [];
+        const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} metadata query ${poolId}`, poolId);
+        if (!stateKey) return [];
+        const decodeResult = change => {
+          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+          const decoded = decodeScale(scaleCoder, change, `Failed to decode metadata on chain ${chainId}`);
+          const metadata = decoded?.asText?.();
+          return {
             poolId,
             metadata
-          } = poolMetadata;
-          if (typeof metadata === "string") state.set(poolId, metadata);else state.delete(poolId);
-        }
-        return state;
-      }, new Map()));
-      const subscription = combineLatest([poolIdByAddress$, pointsByAddress$, unbondingErasByAddress$, pointsByPool$, stakeByPool$, metadataByPool$]).subscribe({
-        next: ([poolIdByAddress, pointsByAddress, unbondingErasByAddress, pointsByPool, stakeByPool, metadataByPool]) => {
-          const balances = Array.from(poolIdByAddress).map(([address, poolId]) => {
-            const parsedPoolId = poolId === null ? undefined : parseInt(poolId);
-            const points = pointsByAddress.get(address) ?? "0";
-            const poolPoints = pointsByPool.get(poolId ?? "") ?? "0";
-            const poolStake = stakeByPool.get(poolId ?? "") ?? "0";
-            const poolMetadata = poolId ? metadataByPool.get(poolId) ?? `Pool ${poolId}` : undefined;
-            const amount = points === "0" || poolPoints === "0" || poolStake === "0" ? 0n : BigInt(poolStake) * BigInt(points) / BigInt(poolPoints);
-            const unbondingAmount = (unbondingErasByAddress.get(address) ?? []).reduce((total, {
-              amount
-            }) => total + BigInt(amount ?? "0"), 0n);
-            return {
-              source: "substrate-native",
-              status: "live",
-              address,
-              networkId: chainId,
-              tokenId,
-              values: [{
-                source: "nompools-staking",
-                type: "nompool",
-                label: "nompools-staking",
-                amount: amount.toString(),
-                meta: {
-                  type: "nompool",
-                  poolId: parsedPoolId,
-                  description: poolMetadata
-                }
-              }, {
-                source: "nompools-staking",
-                type: "nompool",
-                label: "nompools-unbonding",
-                amount: unbondingAmount.toString(),
-                meta: {
-                  poolId: parsedPoolId,
-                  description: poolMetadata,
-                  unbonding: true
-                }
-              }]
-            };
-          }).filter(isNotNil);
-          if (balances.length > 0) callback(null, balances);
-        },
-        error: error => callback(error)
+          };
+        };
+        return {
+          chainId,
+          stateKey,
+          decodeResult
+        };
       });
-      resultUnsubscribes.push(() => subscription.unsubscribe());
-    }
-    return () => resultUnsubscribes.forEach(unsub => unsub());
-  } catch (err) {
-    if (!isAbortError(err)) log.error("Error subscribing to nom pool staking", {
-      err
+      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+      return () => subscription.then(unsubscribe => unsubscribe());
+    };
+    const poolMembersByAddress$ = asObservable(subscribePoolMembers)(addresses).pipe(scan((state, next) => {
+      for (const poolMembers of next) {
+        const {
+          poolId,
+          points,
+          unbondingEras
+        } = poolMembers;
+        if (typeof poolId === "string" && typeof points === "string") state.set(poolMembers.address, {
+          poolId,
+          points,
+          unbondingEras
+        });else state.set(poolMembers.address, null);
+      }
+      return state;
+    }, new Map()), share());
+    const poolIdByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.poolId ?? null]))));
+    const pointsByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.points ?? null]))));
+    const unbondingErasByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.unbondingEras ?? null]))));
+    const poolIds$ = poolIdByAddress$.pipe(map(byAddress => [...new Set(Array.from(byAddress.values()).flatMap(poolId => poolId ?? []))]));
+    const pointsByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolPoints)(poolIds)), switchAll(), scan((state, next) => {
+      for (const poolPoints of next) {
+        const {
+          poolId,
+          points
+        } = poolPoints;
+        if (typeof points === "string") state.set(poolId, points);else state.delete(poolId);
+      }
+      return state;
+    }, new Map()));
+    const stakeByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolStake)(poolIds)), switchAll(), scan((state, next) => {
+      for (const poolStake of next) {
+        const {
+          poolId,
+          activeStake
+        } = poolStake;
+        if (typeof activeStake === "string") state.set(poolId, activeStake);else state.delete(poolId);
+      }
+      return state;
+    }, new Map()));
+    const metadataByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolMetadata)(poolIds)), switchAll(), scan((state, next) => {
+      for (const poolMetadata of next) {
+        const {
+          poolId,
+          metadata
+        } = poolMetadata;
+        if (typeof metadata === "string") state.set(poolId, metadata);else state.delete(poolId);
+      }
+      return state;
+    }, new Map()));
+    const subscription = combineLatest([poolIdByAddress$, pointsByAddress$, unbondingErasByAddress$, pointsByPool$, stakeByPool$, metadataByPool$]).subscribe({
+      next: ([poolIdByAddress, pointsByAddress, unbondingErasByAddress, pointsByPool, stakeByPool, metadataByPool]) => {
+        const balances = Array.from(poolIdByAddress).map(([address, poolId]) => {
+          const parsedPoolId = poolId === null ? undefined : parseInt(poolId);
+          const points = pointsByAddress.get(address) ?? "0";
+          const poolPoints = pointsByPool.get(poolId ?? "") ?? "0";
+          const poolStake = stakeByPool.get(poolId ?? "") ?? "0";
+          const poolMetadata = poolId ? metadataByPool.get(poolId) ?? `Pool ${poolId}` : undefined;
+          const amount = points === "0" || poolPoints === "0" || poolStake === "0" ? 0n : BigInt(poolStake) * BigInt(points) / BigInt(poolPoints);
+          const unbondingAmount = (unbondingErasByAddress.get(address) ?? []).reduce((total, {
+            amount
+          }) => total + BigInt(amount ?? "0"), 0n);
+          return {
+            source: "substrate-native",
+            status: "live",
+            address,
+            multiChainId: {
+              subChainId: chainId
+            },
+            chainId,
+            tokenId,
+            values: [{
+              source: "nompools-staking",
+              type: "nompool",
+              label: "nompools-staking",
+              amount: amount.toString(),
+              meta: {
+                type: "nompool",
+                poolId: parsedPoolId,
+                description: poolMetadata
+              }
+            }, {
+              source: "nompools-staking",
+              type: "nompool",
+              label: "nompools-unbonding",
+              amount: unbondingAmount.toString(),
+              meta: {
+                poolId: parsedPoolId,
+                description: poolMetadata,
+                unbonding: true
+              }
+            }]
+          };
+        }).filter(isNotNil);
+        if (balances.length > 0) callback(null, balances);
+      },
+      error: error => callback(error)
     });
-    return () => {};
+    resultUnsubscribes.push(() => subscription.unsubscribe());
   }
+  return () => resultUnsubscribes.forEach(unsub => unsub());
 }
 
 const SUBTENSOR_ROOT_NETUID = 0;
@@ -3941,236 +4559,225 @@ const calculateTaoFromDynamicInfo = ({
   });
 };
 
-// TODO make this method chain-specific
-async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addressesByToken, callback, signal) {
-  try {
-    const allChains = await chaindataProvider.getNetworksMapById("polkadot");
-    const tokens = await chaindataProvider.getTokensMapById();
-
-    // there should be only one network here when subscribing to balances, we've split it up by network at the top level
-    const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
-    const miniMetadatas = new Map();
-    for (const networkId of networkIds) {
-      const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native", signal);
-      miniMetadatas.set(networkId, miniMetadata);
+async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addressesByToken, callback) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const subtensorTokenIds = Object.entries(tokens).filter(([, token]) => {
+    // ignore non-native tokens
+    if (token.type !== "substrate-native") return false;
+    // ignore tokens on chains with no subtensor pallet
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", allChains[token.chain.id]);
+    return chainMeta?.hasSubtensorPallet === true;
+  }).map(([tokenId]) => tokenId);
+
+  // staking can only be done by the native token on chains with the subtensor pallet
+  const addressesBySubtensorToken = Object.fromEntries(Object.entries(addressesByToken)
+  // remove ethereum addresses
+  .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
+  // remove tokens which aren't subtensor staking tokens
+  .filter(([tokenId]) => subtensorTokenIds.includes(tokenId)));
+  const uniqueChainIds = getUniqueChainIds(addressesBySubtensorToken, tokens);
+  const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
+  const abortController = new AbortController();
+  for (const [tokenId, addresses] of Object.entries(addressesBySubtensorToken)) {
+    const token = tokens[tokenId];
+    if (!token) {
+      log.warn(`Token ${tokenId} not found`);
+      continue;
+    }
+    if (token.type !== "substrate-native") {
+      log.debug(`This module doesn't handle tokens of type ${token.type}`);
+      continue;
+    }
+    const chainId = token.chain?.id;
+    if (!chainId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      continue;
     }
-    signal?.throwIfAborted();
-    const subtensorTokenIds = Object.entries(tokens).filter(([, token]) => {
-      // ignore non-native tokens
-      if (token.type !== "substrate-native") return false;
-      // ignore tokens on chains with no subtensor pallet
-      const miniMetadata = miniMetadatas.get(token.networkId);
-      return miniMetadata?.extra?.hasSubtensorPallet === true;
-    }).map(([tokenId]) => tokenId);
-
-    // staking can only be done by the native token on chains with the subtensor pallet
-    const addressesBySubtensorToken = Object.fromEntries(Object.entries(addressesByToken)
-    // remove ethereum addresses
-    .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
-    // remove tokens which aren't subtensor staking tokens
-    .filter(([tokenId]) => subtensorTokenIds.includes(tokenId)));
-    const uniqueChainIds = getUniqueChainIds(addressesBySubtensorToken, tokens);
-    const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
-    const abortController = new AbortController();
-    for (const [tokenId, addresses] of Object.entries(addressesBySubtensorToken)) {
-      const token = tokens[tokenId];
-      if (!token) {
-        log.warn(`Token ${tokenId} not found`);
-        continue;
-      }
-      if (token.type !== "substrate-native") {
-        log.debug(`This module doesn't handle tokens of type ${token.type}`);
-        continue;
-      }
-      const chainId = token.networkId;
-      const chain = chains[chainId];
-      if (!chain) {
-        log.warn(`Chain ${chainId} for token ${tokenId} not found`);
-        continue;
-      }
-      const miniMetadata = miniMetadatas.get(token.networkId);
-      if (!miniMetadata?.data) {
-        log.warn(`MiniMetadata for chain ${chainId} not found`);
-        continue;
-      }
-      const scaleApi = getScaleApi({
-        chainId,
-        send: (...args) => chainConnector.send(chainId, ...args, {
-          expectErrors: true
-        } // don't pollute the wallet logs when this request fails
-        )
-      }, miniMetadata.data, token, chain.hasCheckMetadataHash, chain.signedExtensions, chain.registryTypes);
-
-      // sets the number of addresses to query in parallel (per chain, since each chain runs in parallel to the others)
-      const concurrency = 4;
-      // In-memory cache for successful dynamic info results
-      const dynamicInfoCache = new Map();
-      const fetchDynamicInfoForNetuids = async uniqueNetuids => {
-        const MAX_RETRIES = 3;
-        const RETRY_DELAY_MS = 500;
-        const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-        const fetchInfo = async netuid => {
-          if (netuid === 0) return null;
-          for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-            try {
-              const params = [netuid];
-              const result = await scaleApi.getRuntimeCallValue("SubnetInfoRuntimeApi", "get_dynamic_info", params);
-              dynamicInfoCache.set(netuid, result); // Cache successful response
-              return result;
-            } catch (error) {
-              log.trace(`Attempt ${attempt} failed for netuid ${netuid}:`, error);
-              if (attempt < MAX_RETRIES) {
-                const backoffTime = RETRY_DELAY_MS * 2 ** (attempt - 1);
-                log.trace(`Retrying in ${backoffTime}ms...`);
-                await delay(backoffTime);
-              }
+    const chain = chains[chainId];
+    if (!chain) {
+      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      continue;
+    }
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", chain);
+    if (!chainMeta?.miniMetadata) {
+      log.warn(`MiniMetadata for chain ${chainId} not found`);
+      continue;
+    }
+    const scaleApi = getScaleApi({
+      chainId,
+      send: (...args) => chainConnector.send(chainId, ...args, {
+        expectErrors: true
+      } // don't pollute the wallet logs when this request fails
+      )
+    }, chainMeta.miniMetadata, token, chain.hasCheckMetadataHash, chain.signedExtensions, chain.registryTypes);
+
+    // sets the number of addresses to query in parallel (per chain, since each chain runs in parallel to the others)
+    const concurrency = 4;
+    // In-memory cache for successful dynamic info results
+    const dynamicInfoCache = new Map();
+    const fetchDynamicInfoForNetuids = async uniqueNetuids => {
+      const MAX_RETRIES = 3;
+      const RETRY_DELAY_MS = 500;
+      const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+      const fetchInfo = async netuid => {
+        if (netuid === 0) return null;
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+          try {
+            const params = [netuid];
+            const result = await scaleApi.getRuntimeCallValue("SubnetInfoRuntimeApi", "get_dynamic_info", params);
+            dynamicInfoCache.set(netuid, result); // Cache successful response
+            return result;
+          } catch (error) {
+            log.trace(`Attempt ${attempt} failed for netuid ${netuid}:`, error);
+            if (attempt < MAX_RETRIES) {
+              const backoffTime = RETRY_DELAY_MS * 2 ** (attempt - 1);
+              log.trace(`Retrying in ${backoffTime}ms...`);
+              await delay(backoffTime);
             }
           }
-          if (dynamicInfoCache.has(netuid)) {
-            return dynamicInfoCache.get(netuid); // Use cached value on failure
-          }
-          log.trace(`Failed to fetch dynamic info for netuid ${netuid} after ${MAX_RETRIES} attempts.`);
-          return null;
-        };
-        return Promise.all(uniqueNetuids.map(fetchInfo));
+        }
+        if (dynamicInfoCache.has(netuid)) {
+          return dynamicInfoCache.get(netuid); // Use cached value on failure
+        }
+        log.trace(`Failed to fetch dynamic info for netuid ${netuid} after ${MAX_RETRIES} attempts.`);
+        return null;
       };
-      const subtensorQueries = from(addresses).pipe(
-      // mergeMap lets us run N concurrent queries, where N is the value of `concurrency`
-      mergeMap(async address => {
-        const queryMethods = [async () => {
-          if (chain.isTestnet) return [];
-          const params = [address];
-          const result = await scaleApi.getRuntimeCallValue("StakeInfoRuntimeApi", "get_stake_info_for_coldkey", params);
-          if (!Array.isArray(result)) return [];
-          const uniqueNetuids = Array.from(new Set(result.map(item => Number(item.netuid)).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID)));
-          await fetchDynamicInfoForNetuids(uniqueNetuids);
-          const stakes = result?.map(({
-            coldkey,
+      return Promise.all(uniqueNetuids.map(fetchInfo));
+    };
+    const subtensorQueries = from(addresses).pipe(
+    // mergeMap lets us run N concurrent queries, where N is the value of `concurrency`
+    mergeMap(async address => {
+      const queryMethods = [async () => {
+        if (chain.isTestnet) return [];
+        const params = [address];
+        const result = await scaleApi.getRuntimeCallValue("StakeInfoRuntimeApi", "get_stake_info_for_coldkey", params);
+        if (!Array.isArray(result)) return [];
+        const uniqueNetuids = Array.from(new Set(result.map(item => Number(item.netuid)).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID)));
+        await fetchDynamicInfoForNetuids(uniqueNetuids);
+        const stakes = result?.map(({
+          coldkey,
+          hotkey,
+          netuid,
+          stake
+        }) => {
+          return {
+            address: coldkey,
             hotkey,
-            netuid,
-            stake
-          }) => {
-            return {
-              address: coldkey,
-              hotkey,
-              netuid: Number(netuid),
-              stake: BigInt(stake),
-              dynamicInfo: dynamicInfoCache.get(Number(netuid))
-            };
-          }).filter(({
-            stake
-          }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK);
-          return stakes;
-        }];
-        const errors = [];
-        for (const queryMethod of queryMethods) {
-          try {
-            // try each query method
-            return await queryMethod();
-          } catch (cause) {
-            // if it fails, keep track of the error and try the next one
-            errors.push(cause);
-          }
+            netuid: Number(netuid),
+            stake: BigInt(stake),
+            dynamicInfo: dynamicInfoCache.get(Number(netuid))
+          };
+        }).filter(({
+          stake
+        }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK);
+        return stakes;
+      }];
+      const errors = [];
+      for (const queryMethod of queryMethods) {
+        try {
+          // try each query method
+          return await queryMethod();
+        } catch (cause) {
+          // if it fails, keep track of the error and try the next one
+          errors.push(cause);
         }
+      }
 
-        // if we get to here, that means that all query methods failed
-        // let's throw the errors back to the native balance module
-        throw new Error([`Failed to fetch ${tokenId} subtensor staked balance for ${address}:`, ...errors.map(error => String(error))].join("\n\t"));
-      }, concurrency),
-      // instead of emitting each balance as it's fetched, toArray waits for them all to fetch and then it collects them into an array
-      toArray(),
-      // this mergeMap flattens our Array<Array<Stakes>> into just an Array<Stakes>
-      mergeMap(stakes => stakes),
-      // convert our Array<Stakes> into Array<Balances>, which we can then return to the native balance module
-      map(stakes => stakes.map(({
+      // if we get to here, that means that all query methods failed
+      // let's throw the errors back to the native balance module
+      throw new Error([`Failed to fetch ${tokenId} subtensor staked balance for ${address}:`, ...errors.map(error => String(error))].join("\n\t"));
+    }, concurrency),
+    // instead of emitting each balance as it's fetched, toArray waits for them all to fetch and then it collects them into an array
+    toArray(),
+    // this mergeMap flattens our Array<Array<Stakes>> into just an Array<Stakes>
+    mergeMap(stakes => stakes),
+    // convert our Array<Stakes> into Array<Balances>, which we can then return to the native balance module
+    map(stakes => stakes.map(({
+      address,
+      hotkey,
+      stake,
+      netuid,
+      dynamicInfo
+    }) => {
+      const {
+        token_symbol,
+        subnet_name,
+        subnet_identity
+      } = dynamicInfo ?? {};
+      const tokenSymbol = new TextDecoder().decode(Uint8Array.from(token_symbol ?? []));
+      const subnetName = new TextDecoder().decode(Uint8Array.from(subnet_name ?? []));
+
+      /** Map from Record<string, Binary> to Record<string, string> */
+      const binaryToText = input => Object.entries(input).reduce((acc, [key, value]) => {
+        acc[key] = value.asText();
+        return acc;
+      }, {});
+      const subnetIdentity = subnet_identity ? binaryToText(subnet_identity) : undefined;
+
+      // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
+      const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
+        dynamicInfo,
+        alphaStaked: stake
+      }) : 1n;
+      const alphaToTaoRate = calculateTaoFromDynamicInfo({
+        dynamicInfo: dynamicInfo ?? null,
+        alphaStaked: ONE_ALPHA_TOKEN
+      }).toString();
+      const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
+      return {
+        source: "substrate-native",
+        status: "live",
         address,
-        hotkey,
-        stake,
-        netuid,
-        dynamicInfo
-      }) => {
-        const {
-          token_symbol,
-          subnet_name,
-          subnet_identity
-        } = dynamicInfo ?? {};
-        const tokenSymbol = new TextDecoder().decode(Uint8Array.from(token_symbol ?? []));
-        const subnetName = new TextDecoder().decode(Uint8Array.from(subnet_name ?? []));
-
-        /** Map from Record<string, Binary> to Record<string, string> */
-        const binaryToText = input => Object.entries(input).reduce((acc, [key, value]) => {
-          acc[key] = value.asText();
-          return acc;
-        }, {});
-        const subnetIdentity = subnet_identity ? binaryToText(subnet_identity) : undefined;
-
-        // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
-        const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
-          dynamicInfo,
-          alphaStaked: stake
-        }) : 1n;
-        const alphaToTaoRate = calculateTaoFromDynamicInfo({
-          dynamicInfo: dynamicInfo ?? null,
-          alphaStaked: ONE_ALPHA_TOKEN
-        }).toString();
-        const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
-        return {
-          source: "substrate-native",
-          status: "live",
-          address,
-          networkId: chainId,
-          tokenId,
-          values: [{
-            source: "subtensor-staking",
-            type: "subtensor",
-            label: "subtensor-staking",
-            amount: stakeByNetuid.toString(),
-            meta: {
-              type: "subtensor-staking",
-              hotkey,
-              netuid,
-              amountStaked: stake.toString(),
-              alphaToTaoRate,
-              dynamicInfo: {
-                tokenSymbol,
-                subnetName,
-                subnetIdentity: {
-                  ...subnetIdentity,
-                  subnetName: subnetIdentity?.subnet_name || subnetName
-                }
+        multiChainId: {
+          subChainId: chainId
+        },
+        chainId,
+        tokenId,
+        values: [{
+          source: "subtensor-staking",
+          type: "subtensor",
+          label: "subtensor-staking",
+          amount: stakeByNetuid.toString(),
+          meta: {
+            type: "subtensor-staking",
+            hotkey,
+            netuid,
+            amountStaked: stake.toString(),
+            alphaToTaoRate,
+            dynamicInfo: {
+              tokenSymbol,
+              subnetName,
+              subnetIdentity: {
+                ...subnetIdentity,
+                subnetName: subnetIdentity?.subnet_name || subnetName
               }
             }
-          }]
-        };
-      })));
-
-      // This observable will run the subtensorQueries on a 30s (30_000ms) interval.
-      // However, if the last run has not yet completed (e.g. its been 30s but we're still fetching some balances),
-      // then exhaustMap will wait until the next interval (so T: 60s, T: 90s, T: 120s, etc) before re-executing the subtensorQueries.
-      const subtensorQueriesInterval = interval(30_000).pipe(startWith(0),
-      // start immediately
-      exhaustMap(() => {
-        return subtensorQueries;
-      }));
+          }
+        }]
+      };
+    })));
 
-      // subscribe to the balances
-      const subscription = subtensorQueriesInterval.subscribe({
-        next: balances => callback(null, balances),
-        error: error => callback(error)
-      });
+    // This observable will run the subtensorQueries on a 30s (30_000ms) interval.
+    // However, if the last run has not yet completed (e.g. its been 30s but we're still fetching some balances),
+    // then exhaustMap will wait until the next interval (so T: 60s, T: 90s, T: 120s, etc) before re-executing the subtensorQueries.
+    const subtensorQueriesInterval = interval(30_000).pipe(startWith(0),
+    // start immediately
+    exhaustMap(() => {
+      return subtensorQueries;
+    }));
 
-      // use the abortController to tear the subscription down when we don't need it anymore
-      abortController.signal.addEventListener("abort", () => {
-        subscription.unsubscribe();
-      });
-    }
-    return () => abortController.abort();
-  } catch (err) {
-    if (!isAbortError(err)) log.error("Error subscribing to subtensor staking", {
-      err
+    // subscribe to the balances
+    const subscription = subtensorQueriesInterval.subscribe({
+      next: balances => callback(null, balances),
+      error: error => callback(error)
     });
-    return () => {};
+
+    // use the abortController to tear the subscription down when we don't need it anymore
+    abortController.signal.onabort = () => subscription.unsubscribe();
   }
+  return () => abortController.abort();
 }
 
 const getOtherType = input => `other-${input}`;
@@ -4226,14 +4833,18 @@ const filterBaseLocks = locks => {
 };
 
 // TODO: Make these titles translatable
-const getLockTitle = (lock,
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-{
+const getLockTitle = (lock, {
   balance
 } = {}) => {
   if (!lock.label) return lock.label;
   if (lock.label === "democracy") return "Governance";
-  if (lock.label === "crowdloan") return "Crowdloan";
+  if (lock.label === "crowdloan") {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const paraId = lock.meta?.paraId;
+    if (!paraId) return "Crowdloan";
+    const name = balance?.chain?.parathreads?.find(parathread => parathread?.paraId === paraId)?.name;
+    return `${name ? name : `Parachain ${paraId}`} Crowdloan`;
+  }
   if (lock.label === "nompools-staking") return "Pooled Staking";
   if (lock.label === "nompools-unbonding") return "Pooled Staking";
   if (lock.label === "subtensor-staking") return "Root Staking";
@@ -4245,6 +4856,7 @@ const getLockTitle = (lock,
 };
 
 const moduleType$2 = "substrate-native";
+const subNativeTokenId = chainId => `${chainId}-substrate-native`.toLowerCase().replace(/ /g, "-");
 
 /**
  * Function to merge two 'sub sources' of the same balance together, or
@@ -4322,7 +4934,7 @@ async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas,
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return outerResult;
     }
-    const chainId = token.networkId;
+    const chainId = token.chain?.id;
     if (!chainId) {
       log.warn(`Token ${tokenId} has no chain`);
       return outerResult;
@@ -4332,10 +4944,10 @@ async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas,
       log.warn(`Chain ${chainId} for token ${tokenId} not found`);
       return outerResult;
     }
-    const miniMetadata = miniMetadatas.get(chainId);
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", chain);
     const {
       useLegacyTransferableCalculation
-    } = miniMetadata?.extra ?? {};
+    } = chainMeta ?? {};
     addresses.flat().forEach(address => {
       const queryKey = `${tokenId}-${address}`;
       // We share this balanceJson between the base and the lock query for this address
@@ -4343,7 +4955,10 @@ async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas,
         source: "substrate-native",
         status: "live",
         address,
-        networkId: chainId,
+        multiChainId: {
+          subChainId: chainId
+        },
+        chainId,
         tokenId,
         values: []
       };
@@ -4615,19 +5230,75 @@ const updateStakingLocksUsingUnbondingLocks = values => {
   return [...otherValues, ...stakingLocks];
 };
 
+const detectMiniMetadataChanges = () => {
+  let previousMap = null;
+  return pipe(map(currMap => {
+    if (!currMap) return null;
+    const changes = new Set();
+    if (previousMap) {
+      // Check for added or changed keys/values
+      for (const [key, value] of currMap) {
+        if (!previousMap.has(key) || !isEqual(previousMap.get(key), value)) {
+          changes.add(value.chainId);
+        }
+      }
+
+      // Check for removed keys
+      for (const [key, value] of previousMap) {
+        if (!currMap.has(key)) {
+          changes.add(value.chainId);
+        }
+      }
+    }
+    previousMap = currMap;
+    return changes.size > 0 ? changes : null;
+  }),
+  // Filter out null emissions (no changes)
+  filter(changes => changes !== null));
+};
+
+// NOTE: `liveQuery` is not initialized until commonMetadataObservable is subscribed to.
+const commonMetadataObservable = from(liveQuery(() => db.miniMetadatas.where("source").equals("substrate-native").toArray())).pipe(map(items => new Map(items.map(item => [item.id, item]))),
+// `refCount: true` will unsubscribe from the DB when commonMetadataObservable has no more subscribers
+shareReplay({
+  bufferSize: 1,
+  refCount: true
+}));
 class QueryCache {
-  #chaindataProvider;
-  #chainConnector;
-  miniMetadatas = new Map();
   balanceQueryCache = new Map();
-  constructor(chaindataProvider, chainConnector) {
+  metadataSub = null;
+  constructor(chaindataProvider) {
     this.chaindataProvider = chaindataProvider;
-    this.#chaindataProvider = chaindataProvider;
-    this.#chainConnector = chainConnector;
+  }
+  ensureSetup() {
+    if (this.metadataSub) return;
+    this.metadataSub = commonMetadataObservable.pipe(firstThenDebounce(500), detectMiniMetadataChanges(), combineLatestWith(this.chaindataProvider.tokensObservable), distinctUntilChanged()).subscribe(([miniMetadataChanges, tokens]) => {
+      // invalidate cache entries for any chains with new metadata
+      const tokensByChainId = tokens.filter(token => token.type === "substrate-native").reduce((result, token) => {
+        if (!token.chain?.id) return result;
+        result[token.chain.id] ? result[token.chain.id].push(token) : result[token.chain.id] = [token];
+        return result;
+      }, {});
+      miniMetadataChanges.forEach(chainId => {
+        const chainTokens = tokensByChainId[chainId];
+        if (!chainTokens) return;
+        chainTokens.forEach(token => {
+          const tokenId = token.id;
+          const cacheKeys = this.balanceQueryCache.keys();
+          for (const key of cacheKeys) {
+            if (key.startsWith(`${tokenId}-`)) this.balanceQueryCache.delete(key);
+          }
+        });
+      });
+    });
+  }
+  destroy() {
+    this.metadataSub?.unsubscribe();
   }
   async getQueries(addressesByToken) {
-    const chains = await this.chaindataProvider.getNetworksMapById("polkadot");
-    const tokens = await this.chaindataProvider.getTokensMapById();
+    this.ensureSetup();
+    const chains = await this.chaindataProvider.chainsById();
+    const tokens = await this.chaindataProvider.tokensById();
     const queryResults = Object.entries(addressesByToken).reduce((result, [tokenId, addresses]) => {
       addresses.forEach(address => {
         const key = `${tokenId}-${address}`;
@@ -4643,19 +5314,15 @@ class QueryCache {
       existing: [],
       newAddressesByToken: {}
     });
-    const byNetwork = getAddresssesByTokenByNetwork(addressesByToken);
-    for (const networkId of keys(byNetwork)) {
-      if (this.miniMetadatas.has(networkId)) continue;
-      const miniMetadata = await getMiniMetadata(this.#chaindataProvider, this.#chainConnector, networkId, "substrate-native");
-      this.miniMetadatas.set(networkId, miniMetadata);
-    }
 
     // build queries for token/address pairs which have not been queried before
-    const uniqueChainIds = keys(byNetwork); // getUniqueChainIds(queryResults.newAddressesByToken, tokens)
+    const miniMetadatas = await firstValueFrom(commonMetadataObservable);
+    const uniqueChainIds = getUniqueChainIds(queryResults.newAddressesByToken, tokens);
     const chainStorageCoders = buildStorageCoders({
       chainIds: uniqueChainIds,
       chains,
-      miniMetadatas: this.miniMetadatas,
+      miniMetadatas,
+      moduleType: "substrate-native",
       coders: {
         base: ["System", "Account"],
         stakingLedger: ["Staking", "Ledger"],
@@ -4665,7 +5332,7 @@ class QueryCache {
         freezes: ["Balances", "Freezes"]
       }
     });
-    const queries = await buildQueries$1(chains, tokens, chainStorageCoders, this.miniMetadatas, queryResults.newAddressesByToken);
+    const queries = await buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas, queryResults.newAddressesByToken);
     // now update the cache
     Object.entries(queries).forEach(([key, query]) => {
       this.balanceQueryCache.set(key, query);
@@ -4674,11 +5341,14 @@ class QueryCache {
   }
 }
 
-const IMPORTANT_TOKENS = [subNativeTokenId("polkadot"), subNativeTokenId("kusama"), subNativeTokenId("polkadot-asset-hub"), subNativeTokenId("kusama-asset-hub"), subNativeTokenId("bittensor")];
-const sortChainsNativeTokensByPriority = (a, b) => {
+const RELAY_TOKENS = ["polkadot-substrate-native", "kusama-substrate-native"];
+const PUBLIC_GOODS_TOKENS = ["polkadot-asset-hub-substrate-native", "kusama-asset-hub-substrate-native"];
+const sortChains = (a, b) => {
   // polkadot and kusama should be checked first
-  if (IMPORTANT_TOKENS.includes(a)) return -1;
-  if (IMPORTANT_TOKENS.includes(b)) return 1;
+  if (RELAY_TOKENS.includes(a)) return -1;
+  if (RELAY_TOKENS.includes(b)) return 1;
+  if (PUBLIC_GOODS_TOKENS.includes(a)) return -1;
+  if (PUBLIC_GOODS_TOKENS.includes(b)) return 1;
   return 0;
 };
 
@@ -4694,30 +5364,10 @@ class SubNativeBalanceError extends Error {
   }
 }
 
-const DotNetworkPropertiesSimple = z.object({
-  tokenDecimals: z.number().optional().default(0),
-  tokenSymbol: z.string().optional().default("Unit")
-});
-const DotNetworkPropertiesArray = z.object({
-  tokenDecimals: z.array(z.number()).nonempty(),
-  tokenSymbol: z.array(z.string()).nonempty()
-});
-const DotNetworkPropertiesSchema = z.union([DotNetworkPropertiesSimple, DotNetworkPropertiesArray]).transform(val => ({
-  tokenDecimals: Array.isArray(val.tokenDecimals) ? val.tokenDecimals[0] : val.tokenDecimals,
-  tokenSymbol: Array.isArray(val.tokenSymbol) ? val.tokenSymbol[0] : val.tokenSymbol
-}));
-const getChainProperties = async (chainConnector, networkId) => {
-  const properties = await chainConnector.send(networkId, "system_properties", [], true);
-  return DotNetworkPropertiesSchema.parse(properties);
-};
-
+const DEFAULT_SYMBOL = "Unit";
+const DEFAULT_DECIMALS = 0;
 const POLLING_WINDOW_SIZE = 20;
 const MAX_SUBSCRIPTION_SIZE = 40;
-const EMPTY_CHAIN_META = {
-  miniMetadata: null,
-  extra: null
-};
-const SubNativeTokenConfigSchema = TokenConfigBaseSchema;
 const SubNativeModule = hydrate => {
   const {
     chainConnectors,
@@ -4725,198 +5375,33 @@ const SubNativeModule = hydrate => {
   } = hydrate;
   const chainConnector = chainConnectors.substrate;
   assert(chainConnector, "This module requires a substrate chain connector");
-  const queryCache = new QueryCache(chaindataProvider, chainConnector);
+  const queryCache = new QueryCache(chaindataProvider);
   const getModuleTokens = async () => {
-    return await chaindataProvider.getTokensMapById(moduleType$2);
-  };
-
-  // subscribeBalances was split by network to prevent all subs to wait for all minimetadatas to be ready.
-  // however the multichain logic in there is so deep in the function below that i had to keep it as-is, and call it by per-network chunks
-  // TODO refactor this be actually network specific
-  // Note: had to extract this function from the result object or this.subscribeBalances wouldn't be typed correctly
-  const subscribeChainBalances = (chainId, opts, callback, signal) => {
-    const {
-      addressesByToken,
-      initialBalances
-    } = opts;
-    // full record of balances for this module
-    const subNativeBalances = new BehaviorSubject(Object.fromEntries(initialBalances?.map(b => [getBalanceId(b), b]) ?? []));
-    // tokens which have a known positive balance
-    const positiveBalanceTokens = subNativeBalances.pipe(map(balances => Array.from(new Set(Object.values(balances).map(b => b.tokenId)))), share());
-
-    // tokens that will be subscribed to, simply a slice of the positive balance tokens of size MAX_SUBSCRIPTION_SIZE
-    const subscriptionTokens = positiveBalanceTokens.pipe(map(tokens => tokens.sort(sortChainsNativeTokensByPriority).slice(0, MAX_SUBSCRIPTION_SIZE)));
-
-    // an initialised balance is one where we have received a response for any type of 'subsource',
-    // until then they are initialising. We only need to maintain one map of tokens to addresses for this
-    const initialisingBalances = Object.entries(addressesByToken).reduce((acc, [tokenId, addresses]) => {
-      acc.set(tokenId, new Set(addresses));
-      return acc;
-    }, new Map());
-
-    // after thirty seconds, we need to kill the initialising balances
-    const initBalancesTimeout = setTimeout(() => {
-      initialisingBalances.clear();
-      // manually call the callback to ensure the caller gets the correct status
-      callback(null, {
-        status: "live",
-        data: Object.values(subNativeBalances.getValue())
-      });
-    }, 30_000);
-    const _callbackSub = subNativeBalances.pipe(debounceTime(100)).subscribe({
-      next: balances => {
-        callback(null, {
-          status: initialisingBalances.size > 0 ? "initialising" : "live",
-          data: Object.values(balances)
-        });
-      },
-      error: error => callback(error),
-      complete: () => {
-        initialisingBalances.clear();
-        clearTimeout(initBalancesTimeout);
-      }
-    });
-    const unsubDeferred = Deferred();
-    // we return this to the caller so that they can let us know when they're no longer interested in this subscription
-    const callerUnsubscribe = () => {
-      subNativeBalances.complete();
-      _callbackSub.unsubscribe();
-      return unsubDeferred.reject(new Error(`Caller unsubscribed`));
-    };
-    // we queue up our work to clean up our subscription when this promise rejects
-    const callerUnsubscribed = unsubDeferred.promise;
-
-    // The update handler is to allow us to merge balances with the same id, and manage initialising and positive balances state for each
-    // balance type and network
-    const handleUpdateForSource = source => (error, result) => {
-      if (result) {
-        const currentBalances = subNativeBalances.getValue();
-
-        // first merge any balances with the same id within the result
-        const accumulatedUpdates = result.filter(b => b.values.length > 0).reduce((acc, b) => {
-          const bId = getBalanceId(b);
-          acc[bId] = mergeBalances(acc[bId], b, source, false);
-          return acc;
-        }, {});
-
-        // then merge these with the current balances
-        const mergedBalances = {};
-        Object.entries(accumulatedUpdates).forEach(([bId, b]) => {
-          // merge the values from the new balance into the existing balance, if there is one
-          mergedBalances[bId] = mergeBalances(currentBalances[bId], b, source, true);
-
-          // update initialisingBalances to remove balances which have been updated
-          const intialisingForToken = initialisingBalances.get(b.tokenId);
-          if (intialisingForToken) {
-            intialisingForToken.delete(b.address);
-            if (intialisingForToken.size === 0) initialisingBalances.delete(b.tokenId);else initialisingBalances.set(b.tokenId, intialisingForToken);
-          }
-        });
-        subNativeBalances.next({
-          ...currentBalances,
-          ...mergedBalances
-        });
-      }
-      if (error) {
-        if (error instanceof SubNativeBalanceError) {
-          // this type of error doesn't need to be handled by the caller
-          initialisingBalances.delete(error.tokenId);
-        } else return callback(error);
-      }
-    };
-
-    // subscribe to addresses and tokens for which we have a known positive balance
-    const positiveSub = subscriptionTokens.pipe(debounceTime(1000), takeUntil(callerUnsubscribed), map(tokenIds => tokenIds.reduce((acc, tokenId) => {
-      acc[tokenId] = addressesByToken[tokenId];
-      return acc;
-    }, {})), distinctUntilChanged(isEqual), switchMap(newAddressesByToken => {
-      return from(queryCache.getQueries(newAddressesByToken)).pipe(switchMap(baseQueries => {
-        return new Observable(subscriber => {
-          if (!chainConnectors.substrate) return;
-          const unsubSubtensorStaking = subscribeSubtensorStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("subtensor-staking"), signal);
-          const unsubNompoolStaking = subscribeNompoolStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("nompools-staking"), signal);
-          const unsubBase = subscribeBase(baseQueries, chainConnectors.substrate, handleUpdateForSource("base"));
-          subscriber.add(async () => (await unsubSubtensorStaking)());
-          subscriber.add(async () => (await unsubNompoolStaking)());
-          subscriber.add(async () => (await unsubBase)());
-        });
-      }));
-    })).subscribe();
-
-    // for chains where we don't have a known positive balance, poll rather than subscribe
-    const poll = async (addressesByToken = {}) => {
-      const handleUpdate = handleUpdateForSource("base");
-      try {
-        const balances = await fetchBalances(addressesByToken);
-        handleUpdate(null, Object.values(balances.toJSON()));
-      } catch (error) {
-        if (error instanceof ChainConnectionError) {
-          // coerce ChainConnection errors into SubNativeBalance errors
-          const errorChainId = error.chainId;
-          Object.entries(await getModuleTokens()).filter(([, token]) => token.networkId === errorChainId).forEach(([tokenId]) => {
-            const wrappedError = new SubNativeBalanceError(tokenId, error.message);
-            handleUpdate(wrappedError);
-          });
-        } else {
-          log.error("unknown substrate native balance error", error);
-          handleUpdate(error);
-        }
-      }
-    };
-    // do one poll to get things started
-    const currentBalances = subNativeBalances.getValue();
-    const currentTokens = new Set(Object.values(currentBalances).map(b => b.tokenId));
-    const nonCurrentTokens = Object.keys(addressesByToken).filter(tokenId => !currentTokens.has(tokenId)).sort(sortChainsNativeTokensByPriority);
-
-    // break nonCurrentTokens into chunks of POLLING_WINDOW_SIZE
-    const pool = new PQueue({
-      concurrency: POLLING_WINDOW_SIZE
-    });
-    nonCurrentTokens.forEach(nonCurrentTokenId => pool.add(() => poll({
-      [nonCurrentTokenId]: addressesByToken[nonCurrentTokenId]
-    }), {
-      signal
-    }));
-
-    // now poll every 30s on chains which are not subscriptionTokens
-    // we chunk this observable into batches of positive token ids, to prevent eating all the websocket connections
-    const pollingSub = interval(30_000) // emit values every 30 seconds
-    .pipe(takeUntil(callerUnsubscribed), withLatestFrom(subscriptionTokens),
-    // Combine latest value from subscriptionTokens with each interval tick
-    map(([, subscribedTokenIds]) =>
-    // Filter out tokens that are not subscribed
-    Object.keys(addressesByToken).filter(tokenId => !subscribedTokenIds.includes(tokenId))), exhaustMap(tokenIds => from(arrayChunk(tokenIds, POLLING_WINDOW_SIZE)).pipe(concatMap(async tokenChunk => {
-      // tokenChunk is a chunk of tokenIds with size POLLING_WINDOW_SIZE
-      const pollingTokenAddresses = Object.fromEntries(tokenChunk.map(tokenId => [tokenId, addressesByToken[tokenId]]));
-      await pool.add(() => poll(pollingTokenAddresses), {
-        signal
-      });
-      return true;
-    })))).subscribe();
-    return () => {
-      callerUnsubscribe();
-      positiveSub.unsubscribe();
-      pollingSub.unsubscribe();
-    };
-  };
-  const fetchBalances = async addressesByToken => {
-    assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-    const queries = await queryCache.getQueries(addressesByToken);
-    assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-    const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
-    return new Balances(result ?? []);
+    return await chaindataProvider.tokensByIdForType(moduleType$2);
   };
   return {
     ...DefaultBalanceModule(moduleType$2),
-    async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
-      if (moduleConfig?.disable) return EMPTY_CHAIN_META;
-      if (!metadataRpc) return EMPTY_CHAIN_META;
+    async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc, systemProperties) {
+      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
+      if (moduleConfig?.disable === true || metadataRpc === undefined) return {
+        isTestnet
+      };
+
+      //
+      // extract system_properties
+      //
+
+      const {
+        tokenSymbol,
+        tokenDecimals
+      } = systemProperties ?? {};
+      const symbol = (Array.isArray(tokenSymbol) ? tokenSymbol[0] : tokenSymbol) ?? DEFAULT_SYMBOL;
+      const decimals = (Array.isArray(tokenDecimals) ? tokenDecimals[0] : tokenDecimals) ?? DEFAULT_DECIMALS;
 
       //
       // process metadata into SCALE encoders/decoders
       //
       const metadataVersion = getMetadataVersion(metadataRpc);
-      if (metadataVersion < 14) return EMPTY_CHAIN_META;
       const metadata = decAnyMetadata(metadataRpc);
       const unifiedMetadata = unifyMetadata(metadata);
 
@@ -4936,6 +5421,7 @@ const SubNativeModule = hydrate => {
       };
       const existentialDeposit = getConstantValue("Balances", "ExistentialDeposit")?.toString();
       const nominationPoolsPalletId = getConstantValue("NominationPools", "PalletId")?.asText();
+      const crowdloanPalletId = getConstantValue("Crowdloan", "PalletId")?.asText();
       const hasSubtensorPallet = getConstantValue("SubtensorModule", "KeySwapCost") !== undefined;
 
       //
@@ -4955,10 +5441,15 @@ const SubNativeModule = hydrate => {
       }, {
         pallet: "Staking",
         items: ["Ledger"]
+      }, {
+        pallet: "Crowdloan",
+        items: ["Funds"]
+      }, {
+        pallet: "Paras",
+        items: ["Parachains"]
       },
       // TotalColdkeyStake is used until v.2.2.1, then it is replaced by StakingHotkeys+Stake
       // Need to keep TotalColdkeyStake for a while so chaindata keeps including it in miniMetadatas, so it doesnt break old versions of the wallet
-      // TODO: Since chaindata v4 this is safe to now delete
       {
         pallet: "SubtensorModule",
         items: ["TotalColdkeyStake", "StakingHotkeys", "Stake"]
@@ -4977,40 +5468,47 @@ const SubNativeModule = hydrate => {
       }) => name === "Freezes"));
       const useLegacyTransferableCalculation = !hasFreezesItem;
       const chainMeta = {
+        isTestnet,
+        useLegacyTransferableCalculation,
+        symbol,
+        decimals,
+        existentialDeposit,
+        nominationPoolsPalletId,
+        crowdloanPalletId,
+        hasSubtensorPallet,
         miniMetadata,
-        extra: {
-          useLegacyTransferableCalculation,
-          existentialDeposit,
-          nominationPoolsPalletId,
-          hasSubtensorPallet
-        }
+        metadataVersion
       };
-      if (!useLegacyTransferableCalculation) delete chainMeta.extra?.useLegacyTransferableCalculation;
-      if (!hasSubtensorPallet) delete chainMeta.extra?.hasSubtensorPallet;
+      if (!useLegacyTransferableCalculation) delete chainMeta.useLegacyTransferableCalculation;
+      if (!hasSubtensorPallet) delete chainMeta.hasSubtensorPallet;
       return chainMeta;
     },
     async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
       if (moduleConfig?.disable === true) return {};
       const {
-        tokenSymbol: symbol,
-        tokenDecimals: decimals
-      } = await getChainProperties(chainConnector, chainId);
-      const {
+        isTestnet,
+        symbol,
+        decimals,
         existentialDeposit
-      } = chainMeta.extra ?? {};
-      if (existentialDeposit === undefined) log.warn("Substrate native module: existentialDeposit is undefined for %s, using 0", chainId);
+      } = chainMeta;
       const id = subNativeTokenId(chainId);
       const nativeToken = {
         id,
         type: "substrate-native",
-        platform: "polkadot",
-        isDefault: true,
-        symbol: symbol,
-        name: symbol,
-        decimals: decimals,
+        isTestnet,
+        isDefault: moduleConfig?.isDefault ?? true,
+        symbol: symbol ?? DEFAULT_SYMBOL,
+        decimals: decimals ?? DEFAULT_DECIMALS,
+        logo: moduleConfig?.logo || githubTokenLogoUrl(id),
         existentialDeposit: existentialDeposit ?? "0",
-        networkId: chainId
+        chain: {
+          id: chainId
+        }
       };
+      if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol;
+      if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId;
+      if (moduleConfig?.dcentName) nativeToken.dcentName = moduleConfig?.dcentName;
+      if (moduleConfig?.mirrorOf) nativeToken.mirrorOf = moduleConfig?.mirrorOf;
       return {
         [nativeToken.id]: nativeToken
       };
@@ -5020,36 +5518,169 @@ const SubNativeModule = hydrate => {
       initialBalances
     }, callback) {
       assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const addressesByTokenByNetwork = getAddresssesByTokenByNetwork(addressesByToken);
-      const initialBalancesByNetwork = groupBy$1(initialBalances ?? [], "networkId");
-      const controller = new AbortController();
-      const safeCallback = (error, result) => {
-        if (controller.signal.aborted) return;
-        if (isAbortError(error)) return;
-        // typescript isnt happy with fowarding parameters as is
-        return error ? callback(error, undefined) : callback(error, result);
+
+      // full record of balances for this module
+      const subNativeBalances = new BehaviorSubject(Object.fromEntries(initialBalances?.map(b => [getBalanceId(b), b]) ?? []));
+      // tokens which have a known positive balance
+      const positiveBalanceTokens = subNativeBalances.pipe(map(balances => Array.from(new Set(Object.values(balances).map(b => b.tokenId)))), share());
+
+      // tokens that will be subscribed to, simply a slice of the positive balance tokens of size MAX_SUBSCRIPTION_SIZE
+      const subscriptionTokens = positiveBalanceTokens.pipe(map(tokens => tokens.sort(sortChains).slice(0, MAX_SUBSCRIPTION_SIZE)));
+
+      // an initialised balance is one where we have received a response for any type of 'subsource',
+      // until then they are initialising. We only need to maintain one map of tokens to addresses for this
+      const initialisingBalances = Object.entries(addressesByToken).reduce((acc, [tokenId, addresses]) => {
+        acc.set(tokenId, new Set(addresses));
+        return acc;
+      }, new Map());
+
+      // after thirty seconds, we need to kill the initialising balances
+      const initBalancesTimeout = setTimeout(() => {
+        initialisingBalances.clear();
+        // manually call the callback to ensure the caller gets the correct status
+        callback(null, {
+          status: "live",
+          data: Object.values(subNativeBalances.getValue())
+        });
+      }, 30_000);
+      const _callbackSub = subNativeBalances.pipe(debounceTime(100)).subscribe({
+        next: balances => {
+          callback(null, {
+            status: initialisingBalances.size > 0 ? "initialising" : "live",
+            data: Object.values(balances)
+          });
+        },
+        error: error => callback(error),
+        complete: () => {
+          initialisingBalances.clear();
+          clearTimeout(initBalancesTimeout);
+        }
+      });
+      const unsubDeferred = Deferred();
+      // we return this to the caller so that they can let us know when they're no longer interested in this subscription
+      const callerUnsubscribe = () => {
+        subNativeBalances.complete();
+        _callbackSub.unsubscribe();
+        return unsubDeferred.reject(new Error(`Caller unsubscribed`));
       };
-      const unsubsribeFns = Promise.all(keys(addressesByTokenByNetwork).map(async networkId => {
+      // we queue up our work to clean up our subscription when this promise rejects
+      const callerUnsubscribed = unsubDeferred.promise;
+
+      // The update handler is to allow us to merge balances with the same id, and manage initialising and positive balances state for each
+      // balance type and network
+      const handleUpdateForSource = source => (error, result) => {
+        if (result) {
+          const currentBalances = subNativeBalances.getValue();
+
+          // first merge any balances with the same id within the result
+          const accumulatedUpdates = result.filter(b => b.values.length > 0).reduce((acc, b) => {
+            const bId = getBalanceId(b);
+            acc[bId] = mergeBalances(acc[bId], b, source, false);
+            return acc;
+          }, {});
+
+          // then merge these with the current balances
+          const mergedBalances = {};
+          Object.entries(accumulatedUpdates).forEach(([bId, b]) => {
+            // merge the values from the new balance into the existing balance, if there is one
+            mergedBalances[bId] = mergeBalances(currentBalances[bId], b, source, true);
+
+            // update initialisingBalances to remove balances which have been updated
+            const intialisingForToken = initialisingBalances.get(b.tokenId);
+            if (intialisingForToken) {
+              intialisingForToken.delete(b.address);
+              if (intialisingForToken.size === 0) initialisingBalances.delete(b.tokenId);else initialisingBalances.set(b.tokenId, intialisingForToken);
+            }
+          });
+          subNativeBalances.next({
+            ...currentBalances,
+            ...mergedBalances
+          });
+        }
+        if (error) {
+          if (error instanceof SubNativeBalanceError) {
+            // this type of error doesn't need to be handled by the caller
+            initialisingBalances.delete(error.tokenId);
+          } else return callback(error);
+        }
+      };
+
+      // subscribe to addresses and tokens for which we have a known positive balance
+      const positiveSub = subscriptionTokens.pipe(debounceTime(1000), takeUntil(callerUnsubscribed), map(tokenIds => tokenIds.reduce((acc, tokenId) => {
+        acc[tokenId] = addressesByToken[tokenId];
+        return acc;
+      }, {})), distinctUntilChanged(isEqual), switchMap(newAddressesByToken => {
+        return from(queryCache.getQueries(newAddressesByToken)).pipe(switchMap(baseQueries => {
+          return new Observable(subscriber => {
+            if (!chainConnectors.substrate) return;
+            const unsubSubtensorStaking = subscribeSubtensorStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("subtensor-staking"));
+            const unsubNompoolStaking = subscribeNompoolStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("nompools-staking"));
+            const unsubCrowdloans = subscribeCrowdloans(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("crowdloan"));
+            const unsubBase = subscribeBase(baseQueries, chainConnectors.substrate, handleUpdateForSource("base"));
+            subscriber.add(async () => (await unsubSubtensorStaking)());
+            subscriber.add(async () => (await unsubNompoolStaking)());
+            subscriber.add(async () => (await unsubCrowdloans)());
+            subscriber.add(async () => (await unsubBase)());
+          });
+        }));
+      })).subscribe();
+
+      // for chains where we don't have a known positive balance, poll rather than subscribe
+      const poll = async (addressesByToken = {}) => {
+        const handleUpdate = handleUpdateForSource("base");
         try {
-          // this is what we want to be done separately for each network
-          // this will update the DB so minimetadata will be available when it's used, everywhere else down the tree of subscribeChainBalances
-          await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType$2, controller.signal);
-        } catch (err) {
-          if (!isAbortError(err)) log.warn("Failed to get native token miniMetadata for network", networkId, err);
-          return () => {};
+          const balances = await this.fetchBalances(addressesByToken);
+          handleUpdate(null, Object.values(balances.toJSON()));
+        } catch (error) {
+          if (error instanceof ChainConnectionError) {
+            // coerce ChainConnection errors into SubNativeBalance errors
+            const errorChainId = error.chainId;
+            Object.entries(await getModuleTokens()).filter(([, token]) => token.chain?.id === errorChainId).forEach(([tokenId]) => {
+              const wrappedError = new SubNativeBalanceError(tokenId, error.message);
+              handleUpdate(wrappedError);
+            });
+          } else {
+            log.error("unknown substrate native balance error", error);
+            handleUpdate(error);
+          }
         }
-        if (controller.signal.aborted) return () => {};
-        return subscribeChainBalances(networkId, {
-          addressesByToken: addressesByTokenByNetwork[networkId] ?? {},
-          initialBalances: initialBalancesByNetwork[networkId] ?? []
-        }, safeCallback, controller.signal);
+      };
+      // do one poll to get things started
+      const currentBalances = subNativeBalances.getValue();
+      const currentTokens = new Set(Object.values(currentBalances).map(b => b.tokenId));
+      const nonCurrentTokens = Object.keys(addressesByToken).filter(tokenId => !currentTokens.has(tokenId)).sort(sortChains);
+
+      // break nonCurrentTokens into chunks of POLLING_WINDOW_SIZE
+      await PromisePool$1.withConcurrency(POLLING_WINDOW_SIZE).for(nonCurrentTokens).process(async nonCurrentTokenId => await poll({
+        [nonCurrentTokenId]: addressesByToken[nonCurrentTokenId]
       }));
+
+      // now poll every 30s on chains which are not subscriptionTokens
+      // we chunk this observable into batches of positive token ids, to prevent eating all the websocket connections
+      const pollingSub = interval(30_000) // emit values every 30 seconds
+      .pipe(takeUntil(callerUnsubscribed), withLatestFrom(subscriptionTokens),
+      // Combine latest value from subscriptionTokens with each interval tick
+      map(([, subscribedTokenIds]) =>
+      // Filter out tokens that are not subscribed
+      Object.keys(addressesByToken).filter(tokenId => !subscribedTokenIds.includes(tokenId))), exhaustMap(tokenIds => from(arrayChunk(tokenIds, POLLING_WINDOW_SIZE)).pipe(concatMap(async tokenChunk => {
+        // tokenChunk is a chunk of tokenIds with size POLLING_WINDOW_SIZE
+        const pollingTokenAddresses = Object.fromEntries(tokenChunk.map(tokenId => [tokenId, addressesByToken[tokenId]]));
+        await poll(pollingTokenAddresses);
+        return true;
+      })))).subscribe();
       return () => {
-        unsubsribeFns.then(fns => fns.forEach(unsubscribe => unsubscribe()));
-        controller.abort();
+        callerUnsubscribe();
+        positiveSub.unsubscribe();
+        pollingSub.unsubscribe();
       };
     },
-    fetchBalances,
+    async fetchBalances(addressesByToken) {
+      assert(chainConnectors.substrate, "This module requires a substrate chain connector");
+      const queries = await queryCache.getQueries(addressesByToken);
+      assert(chainConnectors.substrate, "This module requires a substrate chain connector");
+      const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
+      return new Balances(result ?? []);
+    },
     async transferToken({
       tokenId,
       from,
@@ -5066,10 +5697,11 @@ const SubNativeModule = hydrate => {
       transferMethod,
       userExtensions
     }) {
-      const token = await chaindataProvider.getTokenById(tokenId, "substrate-native");
+      const token = await chaindataProvider.tokenById(tokenId);
       assert(token, `Token ${tokenId} not found in store`);
-      const chainId = token.networkId;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
+      if (token.type !== "substrate-native") throw new Error(`This module doesn't handle tokens of type ${token.type}`);
+      const chainId = token.chain.id;
+      const chain = await chaindataProvider.chainById(chainId);
       assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
       const {
         genesisHash
@@ -6263,10 +6895,7 @@ var psp22Abi = {
 };
 
 const moduleType$1 = "substrate-psp22";
-const SubPsp22TokenConfigSchema = z.strictObject({
-  contractAddress: SubPsp22TokenSchema.shape.contractAddress,
-  ...TokenConfigBaseSchema.shape
-});
+const subPsp22TokenId = (chainId, tokenSymbol) => `${chainId}-substrate-psp22-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
 const SubPsp22Module = hydrate => {
   const {
     chainConnectors,
@@ -6276,15 +6905,16 @@ const SubPsp22Module = hydrate => {
   assert(chainConnector, "This module requires a substrate chain connector");
   return {
     ...DefaultBalanceModule(moduleType$1),
-    async fetchSubstrateChainMeta(_chainId) {
-      // we dont need anything
+    async fetchSubstrateChainMeta(chainId) {
+      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
       return {
-        miniMetadata: null,
-        extra: null
+        isTestnet
       };
     },
-    async fetchSubstrateChainTokens(chainId, _chainMeta, moduleConfig, tokens) {
-      if (!tokens?.length) return {};
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
+      const {
+        isTestnet
+      } = chainMeta;
       const registry = new TypeRegistry();
       const Psp22Abi = new Abi(psp22Abi);
 
@@ -6294,11 +6924,12 @@ const SubPsp22Module = hydrate => {
         chainId,
         registry
       });
-      const tokenList = {};
-      for (const tokenConfig of tokens ?? []) {
+      const tokens = {};
+      for (const tokenConfig of moduleConfig?.tokens ?? []) {
         try {
           let symbol = tokenConfig?.symbol ?? "Unit";
           let decimals = tokenConfig?.decimals ?? 0;
+          const existentialDeposit = tokenConfig?.ed ?? "0";
           const contractAddress = tokenConfig?.contractAddress ?? undefined;
           if (contractAddress === undefined) continue;
           await (async () => {
@@ -6314,28 +6945,35 @@ const SubPsp22Module = hydrate => {
             const decimalsData = decimalsResult.toJSON()?.result?.ok?.data;
             decimals = typeof decimalsData === "string" && decimalsData.startsWith("0x") ? hexToNumber(decimalsData) : decimals;
           })();
-          const id = subPsp22TokenId(chainId, contractAddress);
+          const id = subPsp22TokenId(chainId, symbol);
           const token = {
             id,
             type: "substrate-psp22",
-            platform: "polkadot",
+            isTestnet,
             isDefault: tokenConfig.isDefault ?? true,
             symbol,
             decimals,
-            name: tokenConfig?.name || symbol,
-            logo: tokenConfig?.logo,
+            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+            existentialDeposit,
             contractAddress,
-            networkId: chainId
+            chain: {
+              id: chainId
+            }
           };
+          if (tokenConfig?.symbol) {
+            token.symbol = tokenConfig?.symbol;
+            token.id = subPsp22TokenId(chainId, token.symbol);
+          }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+          if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokenList[token.id] = token;
+          tokens[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-psp22 token ${tokenConfig.contractAddress} (${tokenConfig.symbol}) on ${chainId}`, error?.message ?? error);
           continue;
         }
       }
-      return tokenList;
+      return tokens;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
@@ -6345,7 +6983,7 @@ const SubPsp22Module = hydrate => {
       const subscriptionInterval = 12_000; // 12_000ms == 12 seconds
       const initDelay = 3_000; // 3000ms == 3 seconds
       const cache = new Map();
-      const tokens = await chaindataProvider.getTokensMapById();
+      const tokens = await chaindataProvider.tokensById();
       const poll = async () => {
         if (!subscriptionActive) return;
         try {
@@ -6372,7 +7010,7 @@ const SubPsp22Module = hydrate => {
     },
     async fetchBalances(addressesByToken) {
       assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const tokens = await chaindataProvider.getTokensMapById();
+      const tokens = await chaindataProvider.tokensById();
       return fetchBalances(chainConnectors.substrate, tokens, addressesByToken);
     },
     async transferToken({
@@ -6390,11 +7028,11 @@ const SubPsp22Module = hydrate => {
       tip,
       userExtensions
     }) {
-      const token = await chaindataProvider.getTokenById(tokenId, "substrate-psp22");
+      const token = await chaindataProvider.tokenById(tokenId);
       assert(token, `Token ${tokenId} not found in store`);
       if (token.type !== "substrate-psp22") throw new Error(`This module doesn't handle tokens of type ${token.type}`);
-      const chainId = token.networkId;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
+      const chainId = token.chain.id;
+      const chain = await chaindataProvider.chainById(chainId);
       assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
       const {
         genesisHash
@@ -6470,7 +7108,7 @@ const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
     // TODO: Use `decodeOutput` from `./util/decodeOutput`
     const contractCall = makeContractCaller({
       chainConnector,
-      chainId: token.networkId,
+      chainId: token.chain.id,
       registry
     });
     if (token.contractAddress === undefined) {
@@ -6487,7 +7125,10 @@ const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
       source: "substrate-psp22",
       status: "live",
       address,
-      networkId: token.networkId,
+      multiChainId: {
+        subChainId: token.chain.id
+      },
+      chainId: token.chain.id,
       tokenId,
       value: balance
     };
@@ -6510,16 +7151,8 @@ const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
 };
 
 const moduleType = "substrate-tokens";
-const SubTokensTokenConfigSchema = z.strictObject({
-  onChainId: SubTokensTokenSchema.shape.onChainId,
-  ...TokenConfigBaseSchema.shape,
-  existentialDeposit: SubTokensTokenSchema.shape.existentialDeposit.optional()
-});
 const defaultPalletId = "Tokens";
-const UNSUPPORTED_CHAIN_META = {
-  miniMetadata: null,
-  extra: {}
-};
+const subTokensTokenId = (chainId, onChainId) => `${chainId}-substrate-tokens-${compressToEncodedURIComponent(String(onChainId))}`;
 const SubTokensModule = hydrate => {
   const {
     chainConnectors,
@@ -6530,7 +7163,14 @@ const SubTokensModule = hydrate => {
   return {
     ...DefaultBalanceModule(moduleType),
     async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
-      if (metadataRpc === undefined) return UNSUPPORTED_CHAIN_META;
+      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
+      if (metadataRpc === undefined) return {
+        isTestnet
+      };
+      if ((moduleConfig?.tokens ?? []).length < 1) return {
+        isTestnet
+      };
+      const metadataVersion = getMetadataVersion(metadataRpc);
       const metadata = decAnyMetadata(metadataRpc);
       const palletId = moduleConfig?.palletId ?? defaultPalletId;
       compactMetadata(metadata, [{
@@ -6538,83 +7178,74 @@ const SubTokensModule = hydrate => {
         items: ["Accounts"]
       }]);
       const miniMetadata = encodeMetadata(metadata);
-      return {
+      return palletId === defaultPalletId ? {
+        isTestnet,
         miniMetadata,
-        extra: {
-          palletId
-        }
+        metadataVersion
+      } : {
+        isTestnet,
+        palletId,
+        miniMetadata,
+        metadataVersion
       };
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig, tokens) {
-      const tokenList = {};
-      for (const tokenConfig of tokens ?? []) {
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
+      const {
+        isTestnet
+      } = chainMeta;
+      const tokens = {};
+      for (const tokenConfig of moduleConfig?.tokens ?? []) {
         try {
-          // TODO fetch metadata from chain, like we do for assets
           const symbol = tokenConfig?.symbol ?? "Unit";
           const decimals = tokenConfig?.decimals ?? 0;
-          const existentialDeposit = tokenConfig?.existentialDeposit ?? "0";
+          const existentialDeposit = tokenConfig?.ed ?? "0";
           const onChainId = tokenConfig?.onChainId ?? undefined;
           if (onChainId === undefined) continue;
           const id = subTokensTokenId(chainId, onChainId);
           const token = {
             id,
             type: "substrate-tokens",
-            platform: "polkadot",
+            isTestnet,
             isDefault: tokenConfig.isDefault ?? true,
             symbol,
             decimals,
-            name: tokenConfig?.name ?? symbol,
-            logo: tokenConfig?.logo,
+            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
             existentialDeposit,
             onChainId,
-            networkId: chainId
+            chain: {
+              id: chainId
+            }
           };
+          if (tokenConfig?.symbol) {
+            token.symbol = tokenConfig?.symbol;
+            token.id = subTokensTokenId(chainId, token.onChainId);
+          }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+          if (tokenConfig?.dcentName) token.dcentName = tokenConfig?.dcentName;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokenList[token.id] = token;
+          tokens[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-tokens token ${tokenConfig.onChainId} (${tokenConfig.symbol}) on ${chainId}`, error?.message ?? error);
           continue;
         }
       }
-      return tokenList;
+      return tokens;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
       addressesByToken
     }, callback) {
-      const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
-        const networkId = parseSubTokensTokenId(tokenId).networkId;
-        if (!acc[networkId]) acc[networkId] = {};
-        acc[networkId][tokenId] = addressesByToken[tokenId];
-        return acc;
-      }, {});
-      const controller = new AbortController();
-      const pUnsubs = Promise.all(toPairs(byNetwork).map(async ([networkId, addressesByToken]) => {
-        try {
-          const queries = await buildNetworkQueries(networkId, chainConnector, chaindataProvider, addressesByToken, controller.signal);
-          if (controller.signal.aborted) return () => {};
-          const stateHelper = new RpcStateQueryHelper(chainConnector, queries);
-          return await stateHelper.subscribe((error, result) => {
-            if (error) return callback(error);
-            const balances = result?.filter(b => b !== null) ?? [];
-            if (balances.length > 0) callback(null, new Balances(balances));
-          });
-        } catch (err) {
-          if (!isAbortError(err)) log.error(`Failed to subscribe balances for network ${networkId}`, err);
-          return () => {};
-        }
-      }));
-      return () => {
-        pUnsubs.then(unsubs => {
-          unsubs.forEach(unsubscribe => unsubscribe());
-        });
-        controller.abort();
-      };
+      const queries = await buildQueries(chaindataProvider, addressesByToken);
+      const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
+        if (error) return callback(error);
+        const balances = result?.filter(b => b !== null) ?? [];
+        if (balances.length > 0) callback(null, new Balances(balances));
+      });
+      return unsubscribe;
     },
     async fetchBalances(addressesByToken) {
       assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const queries = await buildQueries(chainConnector, chaindataProvider, addressesByToken);
+      const queries = await buildQueries(chaindataProvider, addressesByToken);
       const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
       const balances = result?.filter(b => b !== null) ?? [];
       return new Balances(balances);
@@ -6626,13 +7257,15 @@ const SubTokensModule = hydrate => {
       transferMethod,
       metadataRpc
     }) {
-      const token = await chaindataProvider.getTokenById(tokenId, "substrate-tokens");
+      const token = await chaindataProvider.tokenById(tokenId);
       assert(token, `Token ${tokenId} not found in store`);
-      const chainId = token.networkId;
-      const chain = await chaindataProvider.getNetworkById(chainId, "polkadot");
+      if (token.type !== "substrate-tokens") throw new Error(`This module doesn't handle tokens of type ${token.type}`);
+      const chainId = token.chain.id;
+      const chain = await chaindataProvider.chainById(chainId);
       assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
-      const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, chainId, moduleType);
-      const tokensPallet = miniMetadata?.extra?.palletId ?? defaultPalletId;
+      const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+      const [chainMeta] = findChainMeta(miniMetadatas, moduleType, chain);
+      const tokensPallet = chainMeta?.palletId ?? defaultPalletId;
       const onChainId = (() => {
         try {
           return papiParse(token.onChainId);
@@ -6731,15 +7364,23 @@ const SubTokensModule = hydrate => {
     }
   };
 };
-async function buildNetworkQueries(networkId, chainConnector, chaindataProvider, addressesByToken, signal) {
-  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType, signal);
-  const chain = await chaindataProvider.getNetworkById(networkId, "polkadot");
-  const tokens = await chaindataProvider.getTokensMapById();
-  if (!chain) return [];
-  signal?.throwIfAborted();
-  const palletId = miniMetadata.extra.palletId ?? defaultPalletId;
-  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
-    storage: [palletId, "Accounts"]
+async function buildQueries(chaindataProvider, addressesByToken) {
+  const allChains = await chaindataProvider.chainsById();
+  const tokens = await chaindataProvider.tokensById();
+  const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
+  const tokensPalletByChain = new Map(Object.values(allChains).map(chain => [chain.id, findChainMeta(miniMetadatas, moduleType, chain)[0]?.palletId]));
+  const uniqueChainIds = getUniqueChainIds(addressesByToken, tokens);
+  const chains = Object.fromEntries(uniqueChainIds.map(chainId => [chainId, allChains[chainId]]));
+  const chainStorageCoders = buildStorageCoders({
+    chainIds: uniqueChainIds,
+    chains,
+    miniMetadatas,
+    moduleType: "substrate-tokens",
+    coders: {
+      storage: ({
+        chainId
+      }) => [tokensPalletByChain.get(chainId) ?? defaultPalletId, "Accounts"]
+    }
   });
   return Object.entries(addressesByToken).flatMap(([tokenId, addresses]) => {
     const token = tokens[tokenId];
@@ -6751,8 +7392,18 @@ async function buildNetworkQueries(networkId, chainConnector, chaindataProvider,
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return [];
     }
+    const chainId = token.chain?.id;
+    if (!chainId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      return [];
+    }
+    const chain = chains[chainId];
+    if (!chain) {
+      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      return [];
+    }
     return addresses.flatMap(address => {
-      const scaleCoder = networkStorageCoders?.storage;
+      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
       const onChainId = (() => {
         try {
           return papiParse(token.onChainId);
@@ -6760,12 +7411,12 @@ async function buildNetworkQueries(networkId, chainConnector, chaindataProvider,
           return token.onChainId;
         }
       })();
-      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${networkId} storage query ${address} / ${token.onChainId}`, address, onChainId);
+      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${chainId} storage query ${address} / ${token.onChainId}`, address, onChainId);
       if (!stateKey) return [];
       const decodeResult = change => {
         /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
-        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-tokens balance on chain ${networkId}`) ?? {
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-tokens balance on chain ${chainId}`) ?? {
           free: 0n,
           reserved: 0n,
           frozen: 0n
@@ -6790,31 +7441,49 @@ async function buildNetworkQueries(networkId, chainConnector, chaindataProvider,
           source: "substrate-tokens",
           status: "live",
           address,
-          networkId,
+          multiChainId: {
+            subChainId: chainId
+          },
+          chainId,
           tokenId: token.id,
           values: balanceValues
         };
       };
       return {
-        chainId: networkId,
+        chainId,
         stateKey,
         decodeResult
       };
     });
   });
 }
-async function buildQueries(chainConnector, chaindataProvider, addressesByToken, signal) {
-  const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
-    const networkId = parseSubTokensTokenId(tokenId).networkId;
-    if (!acc[networkId]) acc[networkId] = {};
-    acc[networkId][tokenId] = addressesByToken[tokenId];
-    return acc;
-  }, {});
-  return (await Promise.all(toPairs(byNetwork).map(([networkId, addressesByToken]) => {
-    return buildNetworkQueries(networkId, chainConnector, chaindataProvider, addressesByToken, signal);
-  }))).flat();
-}
 
-const defaultBalanceModules = [EvmErc20Module, EvmNativeModule, EvmUniswapV2Module, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule];
+const defaultBalanceModules = [EvmErc20Module, EvmNativeModule, EvmUniswapV2Module, SubAssetsModule, SubEquilibriumModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule];
+
+/** Pulls the latest chaindata from https://github.com/TalismanSociety/chaindata */
+const hydrateChaindataAndMiniMetadata = async (chaindataProvider, miniMetadataUpdater) => {
+  // need chains to be provisioned first, or substrate balances won't fetch on first subscription
+  await chaindataProvider.hydrateChains();
+  await Promise.all([miniMetadataUpdater.hydrateFromChaindata(), miniMetadataUpdater.hydrateCustomChains()]);
+  const chains = await chaindataProvider.chains();
+  const {
+    statusesByChain
+  } = await miniMetadataUpdater.statuses(chains);
+  const goodChains = [...statusesByChain.entries()].flatMap(([chainId, status]) => status === "good" ? chainId : []);
+  await chaindataProvider.hydrateSubstrateTokens(goodChains);
+};
+
+/** Builds any missing miniMetadatas (e.g. for the user's custom substrate chains) */
+const updateCustomMiniMetadata = async (chaindataProvider, miniMetadataUpdater) => {
+  const chainIds = await chaindataProvider.chainIds();
+  await miniMetadataUpdater.update(chainIds);
+};
+
+/** Fetches any missing Evm Tokens */
+const updateEvmTokens = async (chaindataProvider, evmTokenFetcher) => {
+  await chaindataProvider.hydrateEvmNetworks();
+  const evmNetworkIds = await chaindataProvider.evmNetworkIds();
+  await evmTokenFetcher.update(evmNetworkIds);
+};
 
-export { Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20Module, EvmErc20TokenConfigSchema, EvmNativeModule, EvmNativeTokenConfigSchema, EvmUniswapV2Module, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsModule, SubAssetsTokenConfigSchema, SubForeignAssetsModule, SubForeignAssetsTokenConfigSchema, SubNativeModule, SubNativeTokenConfigSchema, SubPsp22Module, SubPsp22TokenConfigSchema, SubTokensModule, SubTokensTokenConfigSchema, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildNetworkStorageCoders, buildStorageCoders, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20Abi, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getUniqueChainIds, getValueId, includeInTotalExtraAmount, makeContractCaller, uniswapV2PairAbi };
+export { Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20Module, EvmNativeModule, EvmTokenFetcher, EvmUniswapV2Module, FiatSumBalancesFormatter, MiniMetadataUpdater, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsModule, SubEquilibriumModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildStorageCoders, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20Abi, erc20BalancesAggregatorAbi, evmErc20TokenId, evmNativeTokenId, evmUniswapV2TokenId, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, findChainMeta, getBalanceId, getLockTitle, getUniqueChainIds, getValueId, hydrateChaindataAndMiniMetadata, includeInTotalExtraAmount, makeContractCaller, subAssetTokenId, subEquilibriumTokenId, subForeignAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId, uniswapV2PairAbi, updateCustomMiniMetadata, updateEvmTokens };