@talismn/balances 0.0.0-pr2075-20250703111149 → 0.0.0-pr2075-20250707031602

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

@@ -9,8 +9,8 @@ var BigNumber = require('bignumber.js');
 var util$1 = require('@polkadot/util');
 var utilCrypto = require('@polkadot/util-crypto');
 var pako = require('pako');
-var z = require('zod/v4');
 var viem = require('viem');
+var z = require('zod/v4');
 var lodash = require('lodash');
 var isEqual = require('lodash/isEqual');
 var txwrapperCore = require('@substrate/txwrapper-core');
@@ -73,11 +73,10 @@ const DefaultBalanceModule = type => ({
 // internal
 //
 
-var pkg = {
-	name: "@talismn/balances",
-	version: "0.0.0-pr2075-20250703111149"};
+var packageJson = {
+	name: "@talismn/balances"};
 
-var log = anylogger__default.default(pkg.name);
+var log = anylogger__default.default(packageJson.name);
 
 function excludeFromTransferableAmount(locks) {
   if (typeof locks === "string") return BigInt(locks);
@@ -861,9 +860,8 @@ const getValueId = amount => {
 const deriveMiniMetadataId = ({
   source,
   chainId,
-  specVersion,
-  libVersion
-}) => util$1.u8aToHex(utilCrypto.xxhashAsU8a(new TextEncoder().encode(`${source}${chainId}${specVersion}${libVersion}`), 64), undefined, false);
+  specVersion
+}) => util$1.u8aToHex(utilCrypto.xxhashAsU8a(new TextEncoder().encode(`${source}${chainId}${specVersion}${chaindataProvider.MINIMETADATA_VERSION}`), 64), undefined, false);
 
 // for DB version 3, Wallet version 1.21.0
 const upgradeRemoveSymbolFromNativeTokenId = async tx => {
@@ -962,234 +960,6 @@ const TokenConfigBaseSchema = chaindataProvider.TokenBaseSchema.partial().omit({
   id: true
 });
 
-const erc20Abi = [{
-  constant: true,
-  inputs: [],
-  name: "name",
-  outputs: [{
-    name: "",
-    type: "string"
-  }],
-  payable: false,
-  stateMutability: "view",
-  type: "function"
-}, {
-  constant: false,
-  inputs: [{
-    name: "_spender",
-    type: "address"
-  }, {
-    name: "_value",
-    type: "uint256"
-  }],
-  name: "approve",
-  outputs: [{
-    name: "",
-    type: "bool"
-  }],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  constant: true,
-  inputs: [],
-  name: "totalSupply",
-  outputs: [{
-    name: "",
-    type: "uint256"
-  }],
-  payable: false,
-  stateMutability: "view",
-  type: "function"
-}, {
-  constant: false,
-  inputs: [{
-    name: "_from",
-    type: "address"
-  }, {
-    name: "_to",
-    type: "address"
-  }, {
-    name: "_value",
-    type: "uint256"
-  }],
-  name: "transferFrom",
-  outputs: [{
-    name: "",
-    type: "bool"
-  }],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  constant: true,
-  inputs: [],
-  name: "decimals",
-  outputs: [{
-    name: "",
-    type: "uint8"
-  }],
-  payable: false,
-  stateMutability: "view",
-  type: "function"
-}, {
-  constant: false,
-  inputs: [{
-    name: "_to",
-    type: "address"
-  }, {
-    name: "_value",
-    type: "uint256"
-  }, {
-    name: "_data",
-    type: "bytes"
-  }],
-  name: "transferAndCall",
-  outputs: [{
-    name: "success",
-    type: "bool"
-  }],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  constant: false,
-  inputs: [{
-    name: "_spender",
-    type: "address"
-  }, {
-    name: "_subtractedValue",
-    type: "uint256"
-  }],
-  name: "decreaseApproval",
-  outputs: [{
-    name: "success",
-    type: "bool"
-  }],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  constant: true,
-  inputs: [{
-    name: "_owner",
-    type: "address"
-  }],
-  name: "balanceOf",
-  outputs: [{
-    name: "balance",
-    type: "uint256"
-  }],
-  payable: false,
-  stateMutability: "view",
-  type: "function"
-}, {
-  constant: true,
-  inputs: [],
-  name: "symbol",
-  outputs: [{
-    name: "",
-    type: "string"
-  }],
-  payable: false,
-  stateMutability: "view",
-  type: "function"
-}, {
-  constant: false,
-  inputs: [{
-    name: "_to",
-    type: "address"
-  }, {
-    name: "_value",
-    type: "uint256"
-  }],
-  name: "transfer",
-  outputs: [{
-    name: "success",
-    type: "bool"
-  }],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  constant: false,
-  inputs: [{
-    name: "_spender",
-    type: "address"
-  }, {
-    name: "_addedValue",
-    type: "uint256"
-  }],
-  name: "increaseApproval",
-  outputs: [{
-    name: "success",
-    type: "bool"
-  }],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "function"
-}, {
-  constant: true,
-  inputs: [{
-    name: "_owner",
-    type: "address"
-  }, {
-    name: "_spender",
-    type: "address"
-  }],
-  name: "allowance",
-  outputs: [{
-    name: "remaining",
-    type: "uint256"
-  }],
-  payable: false,
-  stateMutability: "view",
-  type: "function"
-}, {
-  inputs: [],
-  payable: false,
-  stateMutability: "nonpayable",
-  type: "constructor"
-}, {
-  anonymous: false,
-  inputs: [{
-    indexed: true,
-    name: "from",
-    type: "address"
-  }, {
-    indexed: true,
-    name: "to",
-    type: "address"
-  }, {
-    indexed: false,
-    name: "value",
-    type: "uint256"
-  }, {
-    indexed: false,
-    name: "data",
-    type: "bytes"
-  }],
-  name: "Transfer",
-  type: "event"
-}, {
-  anonymous: false,
-  inputs: [{
-    indexed: true,
-    name: "owner",
-    type: "address"
-  }, {
-    indexed: true,
-    name: "spender",
-    type: "address"
-  }, {
-    indexed: false,
-    name: "value",
-    type: "uint256"
-  }],
-  name: "Approval",
-  type: "event"
-}];
-
 const erc20BalancesAggregatorAbi = viem.parseAbi(["struct AccountToken {address account; address token;}", "function balances(AccountToken[] memory accountTokens) public view returns (uint256[] memory)"]);
 
 const moduleType$7 = "evm-erc20";
@@ -1345,7 +1115,7 @@ const EvmErc20Module = hydrate => {
               const {
                 errors,
                 results
-              } = await fetchBalances$3(chainConnectors.evm, {
+              } = await fetchBalances$c(chainConnectors.evm, {
                 [evmNetworkId]: fetchesPerNetwork[evmNetworkId]
               }, aggregators);
 
@@ -1403,7 +1173,7 @@ const EvmErc20Module = hydrate => {
       if (!chainConnectors.evm) throw new Error(`This module requires an evm chain connector`);
       const [aggregators, tokens] = await Promise.all([getErc20Aggregators(), getModuleTokens()]);
       const fetchesPerNetwork = await prepareFetchParameters(addressesByToken, tokens);
-      const balances = await fetchBalances$3(chainConnectors.evm, fetchesPerNetwork, aggregators);
+      const balances = await fetchBalances$c(chainConnectors.evm, fetchesPerNetwork, aggregators);
       return new Balances(balances.results);
     }
   };
@@ -1425,7 +1195,7 @@ class EvmErc20NetworkError extends Error {
     this.evmNetworkId = evmNetworkId;
   }
 }
-const fetchBalances$3 = async (evmChainConnector, tokenAddressesByNetwork, erc20Aggregators = {}) => {
+const fetchBalances$c = async (evmChainConnector, tokenAddressesByNetwork, erc20Aggregators = {}) => {
   const result = {
     results: [],
     errors: []
@@ -1458,7 +1228,7 @@ const getEvmTokenBalancesWithoutAggregator = async (client, balanceDefs, errors)
   }) => {
     try {
       const balance = await client.readContract({
-        abi: erc20Abi,
+        abi: viem.erc20Abi,
         address: token.contractAddress,
         functionName: "balanceOf",
         args: [address]
@@ -1600,7 +1370,7 @@ const EvmNativeModule = hydrate => {
             if (!tokenId) throw new Error(`No native token for evm network ${evmNetworkId}`);
             try {
               if (!chainConnectors.evm) throw new Error(`This module requires an evm chain connector`);
-              const balances = await fetchBalances$2(chainConnectors.evm, {
+              const balances = await fetchBalances$b(chainConnectors.evm, {
                 [tokenId]: addresses
               }, tokens);
               const resultBalances = [];
@@ -1642,7 +1412,7 @@ const EvmNativeModule = hydrate => {
     async fetchBalances(addressesByToken) {
       if (!chainConnectors.evm) throw new Error(`This module requires an evm chain connector`);
       const tokens = await getModuleTokens();
-      const balanceResults = await fetchBalances$2(chainConnectors.evm, addressesByToken, tokens);
+      const balanceResults = await fetchBalances$b(chainConnectors.evm, addressesByToken, tokens);
       const pureBalances = balanceResults.flat().filter(b => !(b instanceof EvmNativeBalanceError) && BigInt(b.value) > 0n);
       return new Balances(pureBalances);
     }
@@ -1658,7 +1428,7 @@ class EvmNativeBalanceError extends Error {
     }
   }
 }
-const fetchBalances$2 = async (evmChainConnector, addressesByToken, tokens) => {
+const fetchBalances$b = 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];
@@ -2410,7 +2180,7 @@ const EvmUniswapV2Module = hydrate => {
             }
             try {
               if (!chainConnectors.evm) throw new Error(`This module requires an evm chain connector`);
-              const balances = await fetchBalances$1(chainConnectors.evm, evmNetworks, tokens, addressesByToken);
+              const balances = await fetchBalances$a(chainConnectors.evm, evmNetworks, tokens, addressesByToken);
 
               // Don't call callback with balances which have not changed since the last poll.
               const json = balances.toJSON();
@@ -2439,11 +2209,11 @@ const EvmUniswapV2Module = hydrate => {
       if (!chainConnectors.evm) throw new Error(`This module requires an evm chain connector`);
       const evmNetworks = await chaindataProvider$1.getNetworksMapById("ethereum");
       const tokens = await chaindataProvider$1.getTokensMapById();
-      return fetchBalances$1(chainConnectors.evm, evmNetworks, tokens, addressesByToken);
+      return fetchBalances$a(chainConnectors.evm, evmNetworks, tokens, addressesByToken);
     }
   };
 };
-const fetchBalances$1 = async (evmChainConnector, evmNetworks, tokens, addressesByToken) => {
+const fetchBalances$a = async (evmChainConnector, evmNetworks, tokens, addressesByToken) => {
   const addressesByTokenGroupedByEvmNetwork = groupAddressesByTokenByEvmNetwork(addressesByToken, tokens);
   const balances = (await Promise.allSettled(Object.entries(addressesByTokenGroupedByEvmNetwork).map(async ([networkId, addressesByToken]) => {
     if (!evmChainConnector) throw new Error(`This module requires an evm chain connector`);
@@ -2583,8 +2353,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) => {
@@ -2660,7 +2428,7 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
   }
 };
 const DotBalanceModuleTypeSchema = z__default.default.keyof(chaindataProvider.DotNetworkBalancesConfigSchema);
-const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
+const fetchMiniMetadatas = async (chainConnector, chaindataProvider$1, chainId, specVersion, signal) => {
   const start = performance.now();
   log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
   try {
@@ -2672,11 +2440,11 @@ const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, sp
     };
     const modules = defaultBalanceModules.map(mod => mod({
       chainConnectors,
-      chaindataProvider
+      chaindataProvider: chaindataProvider$1
     })).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 chain = await chaindataProvider$1.getNetworkById(chainId, "polkadot");
       const balancesConfig = chain?.balancesConfig?.[mod.type];
       const chainMeta = await mod.fetchSubstrateChainMeta(chainId, balancesConfig,
       // TODO better typing
@@ -2685,13 +2453,12 @@ const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, sp
         id: deriveMiniMetadataId({
           source,
           chainId,
-          specVersion,
-          libVersion
+          specVersion
         }),
         source,
         chainId,
         specVersion,
-        libVersion,
+        version: chaindataProvider.MINIMETADATA_VERSION,
         data: chainMeta?.miniMetadata ?? null,
         extra: chainMeta?.extra ?? null
       };
@@ -2713,24 +2480,23 @@ const getUpdatedMiniMetadatas = async (chainConnector, chaindataProvider, chainI
   return miniMetadatas;
 };
 
-const getMiniMetadata = async (chaindataProvider, chainConnector, chainId, source, signal) => {
+const getMiniMetadata$9 = async (chaindataProvider$1, chainConnector, chainId, source, signal) => {
   const specVersion = await getSpecVersion(chainConnector, chainId);
   signal?.throwIfAborted();
   const miniMetadataId = deriveMiniMetadataId({
     source,
     chainId,
-    specVersion,
-    libVersion
+    specVersion
   });
 
   // lookup local ones
-  const [dbMiniMetadata, ghMiniMetadata] = await Promise.all([db.miniMetadatas.get(miniMetadataId), chaindataProvider.miniMetadataById(miniMetadataId)]);
+  const [dbMiniMetadata, ghMiniMetadata] = await Promise.all([db.miniMetadatas.get(miniMetadataId), chaindataProvider$1.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);
+  const miniMetadatas = await getUpdatedMiniMetadatas(chainConnector, chaindataProvider$1, chainId, specVersion, signal);
   signal?.throwIfAborted();
   const found = miniMetadatas.find(m => m.id === miniMetadataId);
   if (!found) {
@@ -2738,7 +2504,7 @@ const getMiniMetadata = async (chaindataProvider, chainConnector, chainId, sourc
       source,
       chainId,
       specVersion,
-      libVersion,
+      version: chaindataProvider.MINIMETADATA_VERSION,
       miniMetadataId,
       miniMetadatas
     });
@@ -2794,6 +2560,8 @@ const buildStorageCoders = ({
     return [];
   }
 }));
+// type StorageCoder<TCoders extends NetworkCoders> = ReturnType<ReturnType<typeof getDynamicBuilder>["buildStorage"]>[keyof TCoders]
+
 const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
   if (!miniMetadata.data) return null;
   const metadata = scale.unifyMetadata(scale.decAnyMetadata(miniMetadata.data));
@@ -3052,8 +2820,8 @@ const SubAssetsModule = hydrate => {
       for (const tokenConfig of tokens ?? []) {
         try {
           const assetId = String(tokenConfig.assetId);
-          const assetStateKey = tryEncode(assetCoder, BigInt(assetId)) ?? tryEncode(assetCoder, assetId);
-          const metadataStateKey = tryEncode(metadataCoder, BigInt(assetId)) ?? tryEncode(metadataCoder, assetId);
+          const assetStateKey = tryEncode$1(assetCoder, BigInt(assetId)) ?? tryEncode$1(assetCoder, assetId);
+          const metadataStateKey = tryEncode$1(metadataCoder, BigInt(assetId)) ?? tryEncode$1(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";
@@ -3073,6 +2841,7 @@ const SubAssetsModule = hydrate => {
             logo: tokenConfig?.logo,
             existentialDeposit,
             assetId,
+            isSufficient: false,
             isFrozen,
             networkId: chainId
           };
@@ -3125,7 +2894,7 @@ const SubAssetsModule = hydrate => {
     },
     async fetchBalances(addressesByToken) {
       util$1.assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const queries = await buildQueries$3(chainConnector, chaindataProvider$1, addressesByToken);
+      const queries = await buildQueries$6(chainConnector, chaindataProvider$1, addressesByToken);
       const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
       const balances = result?.filter(b => b !== null) ?? [];
       return new Balances(balances);
@@ -3195,7 +2964,7 @@ const SubAssetsModule = hydrate => {
   };
 };
 async function buildNetworkQueries$2(networkId, chainConnector, chaindataProvider, addressesByToken, signal) {
-  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType$4, signal);
+  const miniMetadata = await getMiniMetadata$9(chaindataProvider, chainConnector, networkId, moduleType$4, signal);
   const chain = await chaindataProvider.getNetworkById(networkId, "polkadot");
   const tokensById = await chaindataProvider.getTokensMapById();
   signal?.throwIfAborted();
@@ -3219,7 +2988,7 @@ async function buildNetworkQueries$2(networkId, chainConnector, chaindataProvide
     }
     return addresses.flatMap(address => {
       const scaleCoder = networkStorageCoders?.storage;
-      const stateKey = tryEncode(scaleCoder, Number(token.assetId), address) ?? tryEncode(scaleCoder, BigInt(token.assetId), address);
+      const stateKey = tryEncode$1(scaleCoder, Number(token.assetId), address) ?? tryEncode$1(scaleCoder, BigInt(token.assetId), address);
       if (!stateKey) {
         log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
         return [];
@@ -3274,7 +3043,7 @@ async function buildNetworkQueries$2(networkId, chainConnector, chaindataProvide
     });
   });
 }
-async function buildQueries$3(chainConnector, chaindataProvider$1, addressesByToken, signal) {
+async function buildQueries$6(chainConnector, chaindataProvider$1, addressesByToken, signal) {
   const byNetwork = lodash.keys(addressesByToken).reduce((acc, tokenId) => {
     const networkId = chaindataProvider.parseSubAssetTokenId(tokenId).networkId;
     if (!acc[networkId]) acc[networkId] = {};
@@ -3289,7 +3058,7 @@ async function buildQueries$3(chainConnector, chaindataProvider$1, addressesByTo
 // E.g. Polkadot Asset Hub needs it to be a string, Astar needs it to be a bigint
 //
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const tryEncode = (scaleCoder, ...args) => {
+const tryEncode$1 = (scaleCoder, ...args) => {
   try {
     return scaleCoder?.keys?.enc?.(...args);
   } catch {
@@ -3372,6 +3141,7 @@ const SubForeignAssetsModule = hydrate => {
             logo: tokenConfig?.logo,
             existentialDeposit,
             onChainId: tokenConfig.onChainId,
+            isSufficient: assetsAsset?.is_sufficient ?? false,
             isFrozen,
             networkId: chainId
           };
@@ -3420,7 +3190,7 @@ const SubForeignAssetsModule = hydrate => {
     },
     async fetchBalances(addressesByToken) {
       util$1.assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const queries = await buildQueries$2(chainConnector, chaindataProvider$1, addressesByToken);
+      const queries = await buildQueries$5(chainConnector, chaindataProvider$1, addressesByToken);
       const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
       const balances = result?.filter(b => b !== null) ?? [];
       return new Balances(balances);
@@ -3476,7 +3246,7 @@ const SubForeignAssetsModule = hydrate => {
   };
 };
 async function buildNetworkQueries$1(networkId, chainConnector, chaindataProvider, addressesByToken, signal) {
-  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType$3, signal);
+  const miniMetadata = await getMiniMetadata$9(chaindataProvider, chainConnector, networkId, moduleType$3, signal);
   const chain = await chaindataProvider.getNetworkById(networkId, "polkadot");
   const tokensById = await chaindataProvider.getTokensMapById();
   signal?.throwIfAborted();
@@ -3558,7 +3328,7 @@ async function buildNetworkQueries$1(networkId, chainConnector, chaindataProvide
     });
   });
 }
-async function buildQueries$2(chainConnector, chaindataProvider$1, addressesByToken, signal) {
+async function buildQueries$5(chainConnector, chaindataProvider$1, addressesByToken, signal) {
   const byNetwork = lodash.keys(addressesByToken).reduce((acc, tokenId) => {
     const networkId = chaindataProvider.parseSubForeignAssetTokenId(tokenId).networkId;
     if (!acc[networkId]) acc[networkId] = {};
@@ -3612,7 +3382,7 @@ const asObservable = handler => (...args) => new rxjs.Observable(subscriber => {
  * Each nominationPool in the nominationPools pallet has access to some accountIds which have no
  * associated private key. Instead, they are derived from this function.
  */
-const nompoolAccountId = (palletId, poolId, index) => {
+const nompoolAccountId$1 = (palletId, poolId, index) => {
   const utf8Encoder = new TextEncoder();
   const encModPrefix = utf8Encoder.encode("modl");
   const encPalletId = utf8Encoder.encode(palletId);
@@ -3625,7 +3395,7 @@ const nompoolAccountId = (palletId, poolId, index) => {
   return polkadotApi.AccountId().dec(bytes);
 };
 /** The stash account for the nomination pool */
-const nompoolStashAccountId = (palletId, poolId) => nompoolAccountId(palletId, poolId, 0);
+const nompoolStashAccountId$1 = (palletId, poolId) => nompoolAccountId$1(palletId, poolId, 0);
 
 // TODO make this method chain-specific
 async function subscribeNompoolStaking(chaindataProvider$1, chainConnector, addressesByToken, callback, signal) {
@@ -3637,7 +3407,7 @@ async function subscribeNompoolStaking(chaindataProvider$1, chainConnector, addr
     const networkIds = lodash.keys(addressesByToken).map(tokenId => chaindataProvider.parseTokenId(tokenId).networkId);
     const miniMetadatas = new Map();
     for (const networkId of networkIds) {
-      const miniMetadata = await getMiniMetadata(chaindataProvider$1, chainConnector, networkId, "substrate-native");
+      const miniMetadata = await getMiniMetadata$9(chaindataProvider$1, chainConnector, networkId, "substrate-native");
       miniMetadatas.set(networkId, miniMetadata);
     }
     signal?.throwIfAborted();
@@ -3763,7 +3533,7 @@ async function subscribeNompoolStaking(chaindataProvider$1, chainConnector, addr
         const scaleCoder = chainStorageCoders.get(chainId)?.ledger;
         const queries = poolIds.flatMap(poolId => {
           if (!nominationPoolsPalletId) return [];
-          const stashAddress = nompoolStashAccountId(nominationPoolsPalletId, poolId);
+          const stashAddress = nompoolStashAccountId$1(nominationPoolsPalletId, poolId);
           const stateKey = scale.encodeStateKey(scaleCoder, `Invalid address in ${chainId} ledger query ${stashAddress}`, stashAddress);
           if (!stateKey) return [];
           const decodeResult = change => {
@@ -3916,12 +3686,12 @@ async function subscribeNompoolStaking(chaindataProvider$1, chainConnector, addr
   }
 }
 
-const SUBTENSOR_ROOT_NETUID = 0;
-const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = 1000000n;
-const TAO_DECIMALS = 9n;
-const SCALE_FACTOR = 10n ** TAO_DECIMALS; // Equivalent to 10e9 for precision
-const ONE_ALPHA_TOKEN = SCALE_FACTOR;
-const calculateAlphaPrice = ({
+const SUBTENSOR_ROOT_NETUID$1 = 0;
+const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1 = 1000000n;
+const TAO_DECIMALS$1 = 9n;
+const SCALE_FACTOR$1 = 10n ** TAO_DECIMALS$1; // Equivalent to 10e9 for precision
+const ONE_ALPHA_TOKEN$1 = SCALE_FACTOR$1;
+const calculateAlphaPrice$1 = ({
   dynamicInfo
 }) => {
   if (!dynamicInfo) return 0n;
@@ -3931,25 +3701,25 @@ const calculateAlphaPrice = ({
   } = dynamicInfo;
 
   // Scale taoIn before division to preserve precision
-  const result = tao_in * SCALE_FACTOR / alpha_in;
+  const result = tao_in * SCALE_FACTOR$1 / alpha_in;
   return result; // Scaled price as bigint
 };
-const calculateTaoAmountFromAlpha = ({
+const calculateTaoAmountFromAlpha$1 = ({
   alphaPrice,
   alphaStaked
 }) => {
   if (!alphaStaked || !alphaPrice) return 0n;
   const expectedAlpha = alphaStaked * alphaPrice;
-  return expectedAlpha / SCALE_FACTOR;
+  return expectedAlpha / SCALE_FACTOR$1;
 };
-const calculateTaoFromDynamicInfo = ({
+const calculateTaoFromDynamicInfo$1 = ({
   dynamicInfo,
   alphaStaked
 }) => {
-  const alphaPrice = calculateAlphaPrice({
+  const alphaPrice = calculateAlphaPrice$1({
     dynamicInfo
   });
-  return calculateTaoAmountFromAlpha({
+  return calculateTaoAmountFromAlpha$1({
     alphaPrice,
     alphaStaked
   });
@@ -3965,7 +3735,7 @@ async function subscribeSubtensorStaking(chaindataProvider$1, chainConnector, ad
     const networkIds = lodash.keys(addressesByToken).map(tokenId => chaindataProvider.parseTokenId(tokenId).networkId);
     const miniMetadatas = new Map();
     for (const networkId of networkIds) {
-      const miniMetadata = await getMiniMetadata(chaindataProvider$1, chainConnector, networkId, "substrate-native", signal);
+      const miniMetadata = await getMiniMetadata$9(chaindataProvider$1, chainConnector, networkId, "substrate-native", signal);
       miniMetadatas.set(networkId, miniMetadata);
     }
     signal?.throwIfAborted();
@@ -4056,7 +3826,7 @@ async function subscribeSubtensorStaking(chaindataProvider$1, chainConnector, ad
           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)));
+          const uniqueNetuids = Array.from(new Set(result.map(item => Number(item.netuid)).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID$1)));
           await fetchDynamicInfoForNetuids(uniqueNetuids);
           const stakes = result?.map(({
             coldkey,
@@ -4073,7 +3843,7 @@ async function subscribeSubtensorStaking(chaindataProvider$1, chainConnector, ad
             };
           }).filter(({
             stake
-          }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK);
+          }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1);
           return stakes;
         }];
         const errors = [];
@@ -4119,15 +3889,15 @@ async function subscribeSubtensorStaking(chaindataProvider$1, chainConnector, ad
         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({
+        const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo$1({
           dynamicInfo,
           alphaStaked: stake
         }) : 1n;
-        const alphaToTaoRate = calculateTaoFromDynamicInfo({
+        const alphaToTaoRate = calculateTaoFromDynamicInfo$1({
           dynamicInfo: dynamicInfo ?? null,
-          alphaStaked: ONE_ALPHA_TOKEN
+          alphaStaked: ONE_ALPHA_TOKEN$1
         }).toString();
-        const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
+        const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID$1 ? stake : alphaStakedInTao;
         return {
           source: "substrate-native",
           status: "live",
@@ -4187,14 +3957,14 @@ async function subscribeSubtensorStaking(chaindataProvider$1, chainConnector, ad
   }
 }
 
-const getOtherType = input => `other-${input}`;
+const getOtherType$1 = input => `other-${input}`;
 
 /**
  * For converting the value of `lock?.id?.toUtf8?.()` which is retrieved from
  * the Balances.Locks storage key into a useful classification for our UI
  */
-const getLockedType = input => {
-  if (typeof input !== "string") return getOtherType("unknown");
+const getLockedType$1 = input => {
+  if (typeof input !== "string") return getOtherType$1("unknown");
   if (input.includes("vesting")) return "vesting";
   if (input.includes("calamvst")) return "vesting"; // vesting on manta network
   if (input.includes("ormlvest")) return "vesting"; // vesting ORML tokens
@@ -4216,19 +3986,19 @@ const getLockedType = input => {
   if (input.includes("councilo")) return "democracy"; // Councilor
   if (input.includes("proposal")) return "democracy";
   if (input.includes("boundsta")) return "staking"; // Bound Staking Account
-  if (input.includes("invitemb")) return getOtherType(input); // Invite member
-  if (input.includes("bounty")) return getOtherType(input);
-  if (input.startsWith("wg-")) return getOtherType(input);
+  if (input.includes("invitemb")) return getOtherType$1(input); // Invite member
+  if (input.includes("bounty")) return getOtherType$1(input);
+  if (input.startsWith("wg-")) return getOtherType$1(input);
 
   // ignore technical or undocumented lock types
-  if (input.includes("pdexlock")) return getOtherType(input);
-  if (input.includes("phala/sp")) return getOtherType(input);
-  if (input.includes("aca/earn")) return getOtherType(input);
-  if (input.includes("stk_stks")) return getOtherType(input);
+  if (input.includes("pdexlock")) return getOtherType$1(input);
+  if (input.includes("phala/sp")) return getOtherType$1(input);
+  if (input.includes("aca/earn")) return getOtherType$1(input);
+  if (input.includes("stk_stks")) return getOtherType$1(input);
 
   // eslint-disable-next-line no-console
   console.warn(`unknown locked type: ${input}`);
-  return getOtherType(input);
+  return getOtherType$1(input);
 };
 const baseLockLabels = ["fees", "misc"];
 const isBaseLock = lock => baseLockLabels.includes(lock.label);
@@ -4325,7 +4095,7 @@ const AccountInfoOverrides = {
   // nftmart is not yet on metadata v14
   "nftmart": RegularAccountInfoFallback
 };
-async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas, addressesByToken) {
+async function buildQueries$4(chains, tokens, chainStorageCoders, miniMetadatas, addressesByToken) {
   return Object.entries(addressesByToken).reduce((outerResult, [tokenId, addresses]) => {
     const token = tokens[tokenId];
     if (!token) {
@@ -4457,7 +4227,7 @@ async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas,
           locksQueryLocks = decoded?.map?.(lock => ({
             type: "locked",
             source: "substrate-native-locks",
-            label: getLockedType(lock?.id?.asText?.()),
+            label: getLockedType$1(lock?.id?.asText?.()),
             meta: {
               id: lock?.id?.asText?.()
             },
@@ -4521,7 +4291,7 @@ async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas,
           freezesQueryLocks = decoded?.map?.(lock => ({
             type: "locked",
             source: "substrate-native-freezes",
-            label: getLockedType(lock?.id?.type?.toLowerCase?.()),
+            label: getLockedType$1(lock?.id?.type?.toLowerCase?.()),
             amount: lock?.amount?.toString?.() ?? "0"
           })) ?? [];
 
@@ -4660,7 +4430,7 @@ class QueryCache {
     const byNetwork = getAddresssesByTokenByNetwork(addressesByToken);
     for (const networkId of lodash.keys(byNetwork)) {
       if (this.miniMetadatas.has(networkId)) continue;
-      const miniMetadata = await getMiniMetadata(this.#chaindataProvider, this.#chainConnector, networkId, "substrate-native");
+      const miniMetadata = await getMiniMetadata$9(this.#chaindataProvider, this.#chainConnector, networkId, "substrate-native");
       this.miniMetadatas.set(networkId, miniMetadata);
     }
 
@@ -4679,7 +4449,7 @@ class QueryCache {
         freezes: ["Balances", "Freezes"]
       }
     });
-    const queries = await buildQueries$1(chains, tokens, chainStorageCoders, this.miniMetadatas, queryResults.newAddressesByToken);
+    const queries = await buildQueries$4(chains, tokens, chainStorageCoders, this.miniMetadatas, queryResults.newAddressesByToken);
     // now update the cache
     Object.entries(queries).forEach(([key, query]) => {
       this.balanceQueryCache.set(key, query);
@@ -4708,21 +4478,21 @@ class SubNativeBalanceError extends Error {
   }
 }
 
-const DotNetworkPropertiesSimple = z__default.default.object({
+const DotNetworkPropertiesSimple$1 = z__default.default.object({
   tokenDecimals: z__default.default.number().optional().default(0),
   tokenSymbol: z__default.default.string().optional().default("Unit")
 });
-const DotNetworkPropertiesArray = z__default.default.object({
+const DotNetworkPropertiesArray$1 = z__default.default.object({
   tokenDecimals: z__default.default.array(z__default.default.number()).nonempty(),
   tokenSymbol: z__default.default.array(z__default.default.string()).nonempty()
 });
-const DotNetworkPropertiesSchema = z__default.default.union([DotNetworkPropertiesSimple, DotNetworkPropertiesArray]).transform(val => ({
+const DotNetworkPropertiesSchema$1 = z__default.default.union([DotNetworkPropertiesSimple$1, DotNetworkPropertiesArray$1]).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 getChainProperties$1 = async (chainConnector, networkId) => {
   const properties = await chainConnector.send(networkId, "system_properties", [], true);
-  return DotNetworkPropertiesSchema.parse(properties);
+  return DotNetworkPropertiesSchema$1.parse(properties);
 };
 
 const POLLING_WINDOW_SIZE = 20;
@@ -5008,7 +4778,7 @@ const SubNativeModule = hydrate => {
       const {
         tokenSymbol: symbol,
         tokenDecimals: decimals
-      } = await getChainProperties(chainConnector$1, chainId);
+      } = await getChainProperties$1(chainConnector$1, chainId);
       const {
         existentialDeposit
       } = chainMeta.extra ?? {};
@@ -5047,7 +4817,7 @@ const SubNativeModule = hydrate => {
         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$1, chainConnector$1, networkId, moduleType$2, controller.signal);
+          await getMiniMetadata$9(chaindataProvider$1, chainConnector$1, networkId, moduleType$2, controller.signal);
         } catch (err) {
           if (!util.isAbortError(err)) log.warn("Failed to get native token miniMetadata for network", networkId, err);
           return () => {};
@@ -6364,7 +6134,7 @@ const SubPsp22Module = hydrate => {
         if (!subscriptionActive) return;
         try {
           util$1.assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-          const balances = await fetchBalances(chainConnectors.substrate, tokens, addressesByToken);
+          const balances = await fetchBalances$9(chainConnectors.substrate, tokens, addressesByToken);
 
           // Don't call callback with balances which have not changed since the last poll.
           const updatedBalances = new Balances([...balances].filter(b => {
@@ -6387,7 +6157,7 @@ const SubPsp22Module = hydrate => {
     async fetchBalances(addressesByToken) {
       util$1.assert(chainConnectors.substrate, "This module requires a substrate chain connector");
       const tokens = await chaindataProvider$1.getTokensMapById();
-      return fetchBalances(chainConnectors.substrate, tokens, addressesByToken);
+      return fetchBalances$9(chainConnectors.substrate, tokens, addressesByToken);
     },
     async transferToken({
       tokenId,
@@ -6467,7 +6237,7 @@ const SubPsp22Module = hydrate => {
     }
   };
 };
-const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
+const fetchBalances$9 = async (chainConnector, tokens, addressesByToken) => {
   const registry = new types.TypeRegistry();
   const Psp22Abi = new apiContract.Abi(psp22Abi);
   const balanceRequests = Object.entries(addressesByToken).flatMap(([tokenId, addresses]) => addresses.map(address => [tokenId, address])).flatMap(async ([tokenId, address]) => {
@@ -6628,7 +6398,7 @@ const SubTokensModule = hydrate => {
     },
     async fetchBalances(addressesByToken) {
       util$1.assert(chainConnectors.substrate, "This module requires a substrate chain connector");
-      const queries = await buildQueries(chainConnector, chaindataProvider$1, addressesByToken);
+      const queries = await buildQueries$3(chainConnector, chaindataProvider$1, addressesByToken);
       const result = await new RpcStateQueryHelper(chainConnectors.substrate, queries).fetch();
       const balances = result?.filter(b => b !== null) ?? [];
       return new Balances(balances);
@@ -6645,7 +6415,7 @@ const SubTokensModule = hydrate => {
       const chainId = token.networkId;
       const chain = await chaindataProvider$1.getNetworkById(chainId, "polkadot");
       util$1.assert(chain?.genesisHash, `Chain ${chainId} not found in store`);
-      const miniMetadata = await getMiniMetadata(chaindataProvider$1, chainConnector, chainId, moduleType);
+      const miniMetadata = await getMiniMetadata$9(chaindataProvider$1, chainConnector, chainId, moduleType);
       const tokensPallet = miniMetadata?.extra?.palletId ?? defaultPalletId;
       const onChainId = (() => {
         try {
@@ -6746,7 +6516,7 @@ const SubTokensModule = hydrate => {
   };
 };
 async function buildNetworkQueries(networkId, chainConnector, chaindataProvider, addressesByToken, signal) {
-  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType, signal);
+  const miniMetadata = await getMiniMetadata$9(chaindataProvider, chainConnector, networkId, moduleType, signal);
   const chain = await chaindataProvider.getNetworkById(networkId, "polkadot");
   const tokens = await chaindataProvider.getTokensMapById();
   if (!chain) return [];
@@ -6817,7 +6587,7 @@ async function buildNetworkQueries(networkId, chainConnector, chaindataProvider,
     });
   });
 }
-async function buildQueries(chainConnector, chaindataProvider$1, addressesByToken, signal) {
+async function buildQueries$3(chainConnector, chaindataProvider$1, addressesByToken, signal) {
   const byNetwork = lodash.keys(addressesByToken).reduce((acc, tokenId) => {
     const networkId = chaindataProvider.parseSubTokensTokenId(tokenId).networkId;
     if (!acc[networkId]) acc[networkId] = {};
@@ -6831,6 +6601,3806 @@ async function buildQueries(chainConnector, chaindataProvider$1, addressesByToke
 
 const defaultBalanceModules = [EvmErc20Module, EvmNativeModule, EvmUniswapV2Module, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule];
 
+const MODULE_TYPE$8 = chaindataProvider.EvmErc20TokenSchema.shape.type.value;
+const PLATFORM$8 = chaindataProvider.EvmErc20TokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  contractAddress: chaindataProvider.EvmErc20TokenSchema.shape.contractAddress,
+  ...TokenConfigBaseSchema.shape
+});
+
+class BalanceFetchError extends Error {
+  constructor(message, tokenId, address, cause) {
+    super(message);
+    this.name = "BalanceFetchError";
+    this.tokenId = tokenId;
+    this.address = address;
+    if (cause) this.cause = cause;
+  }
+}
+class BalanceFetchNetworkError extends Error {
+  constructor(message, evmNetworkId, cause) {
+    super(message);
+    this.name = "BalanceFetchNetworkError";
+    this.evmNetworkId = evmNetworkId;
+    if (cause) this.cause = cause;
+  }
+}
+
+const getBalanceDefs = addressesByToken => {
+  return addressesByToken.flatMap(([token, addresses]) => addresses.map(address => ({
+    token,
+    address
+  })));
+};
+
+const fetchBalances$8 = async ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  const client = await connector.getPublicClientForEvmNetwork(networkId);
+  if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
+  for (const [token, addresses] of addressesByToken) {
+    if (token.type !== MODULE_TYPE$8 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    for (const address of addresses) if (!util.isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
+  }
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (client.chain?.contracts?.erc20Aggregator && balanceDefs.length > 1) {
+    const erc20Aggregator = client.chain.contracts.erc20Aggregator;
+    return fetchWithAggregator$1(client, balanceDefs, erc20Aggregator.address);
+  }
+  return fetchWithoutAggregator$1(client, balanceDefs);
+};
+const fetchWithoutAggregator$1 = async (client, balanceDefs) => {
+  if (balanceDefs.length === 0) return {
+    success: [],
+    errors: []
+  };
+  log.debug("fetching %s balances without aggregator", MODULE_TYPE$8, balanceDefs.length);
+  const results = await Promise.allSettled(balanceDefs.map(async ({
+    token,
+    address
+  }) => {
+    try {
+      const result = await client.readContract({
+        abi: viem.erc20Abi,
+        address: token.contractAddress,
+        functionName: "balanceOf",
+        args: [address]
+      });
+      const balance = {
+        address,
+        tokenId: token.id,
+        value: result.toString(),
+        source: MODULE_TYPE$8,
+        networkId: chaindataProvider.parseEvmErc20TokenId(token.id).networkId,
+        status: "cache"
+      };
+      return balance;
+    } catch (err) {
+      throw new BalanceFetchError(`Failed to get balance for token ${token.id} and address ${address} on chain ${client.chain?.id}`, token.id, address, err);
+    }
+  }));
+  return results.reduce((acc, result) => {
+    if (result.status === "fulfilled") acc.success.push(result.value);else {
+      const error = result.reason;
+      acc.errors.push({
+        tokenId: error.tokenId,
+        address: error.address,
+        error
+      });
+    }
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+const fetchWithAggregator$1 = async (client, balanceDefs, erc20BalancesAggregatorAddress) => {
+  if (balanceDefs.length === 0) return {
+    success: [],
+    errors: []
+  };
+  log.debug("fetching %s balances with aggregator", MODULE_TYPE$8, balanceDefs.length);
+  try {
+    const erc20Balances = await client.readContract({
+      abi: erc20BalancesAggregatorAbi,
+      address: erc20BalancesAggregatorAddress,
+      functionName: "balances",
+      args: [balanceDefs.map(b => ({
+        account: b.address,
+        token: b.token.contractAddress
+      }))]
+    });
+    const success = balanceDefs.map((balanceDef, index) => ({
+      address: balanceDef.address,
+      tokenId: balanceDef.token.id,
+      value: erc20Balances[index].toString(),
+      source: MODULE_TYPE$8,
+      networkId: chaindataProvider.parseTokenId(balanceDef.token.id).networkId,
+      status: "cache"
+    }));
+    return {
+      success,
+      errors: []
+    };
+  } catch (err) {
+    const errors = balanceDefs.map(balanceDef => ({
+      tokenId: balanceDef.token.id,
+      address: balanceDef.address,
+      error: new BalanceFetchNetworkError(`Failed to get balances for evm-erc20 tokens on chain ${client.chain?.id}`, String(client.chain?.id), err)
+    }));
+    return {
+      success: [],
+      errors
+    };
+  }
+};
+
+const getErc20ContractData$1 = async (client, contractAddress) => {
+  try {
+    const contract = getTypedContract$1(client, viem.erc20Abi, contractAddress);
+
+    // eslint-disable-next-line no-var
+    var [symbol, decimals, name] = await Promise.all([contract.read.symbol(), contract.read.decimals(), contract.read.name()]);
+  } catch (e) {
+    if (e instanceof viem.ContractFunctionExecutionError) {
+      // try to perform the contract read with bytes32 symbol
+      const contract = getTypedContract$1(client, viem.erc20Abi_bytes32, contractAddress);
+
+      // eslint-disable-next-line no-var
+      var [bytesSymbol, decimals, nameSymbol] = await Promise.all([contract.read.symbol(), contract.read.decimals(), contract.read.name()]);
+      symbol = viem.hexToString(bytesSymbol).replace(/\0/g, "").trim(); // remove NULL characters
+      name = viem.hexToString(nameSymbol).replace(/\0/g, "").trim(); // remove NULL characters
+    } else throw e;
+  }
+  return {
+    symbol,
+    decimals,
+    name
+  };
+};
+const getTypedContract$1 = (client, abi, contractAddress) => viem.getContract({
+  address: contractAddress,
+  abi,
+  client: {
+    public: client
+  }
+});
+
+const TokenCacheSchema$1 = chaindataProvider.EvmErc20TokenSchema.pick({
+  symbol: true,
+  decimals: true,
+  name: true
+});
+const fetchTokens$8 = async ({
+  networkId,
+  tokens,
+  connector,
+  cache
+}) => {
+  const result = [];
+  for (const tokenConfig of tokens) {
+    const tokenId = chaindataProvider.evmErc20TokenId(networkId, tokenConfig.contractAddress);
+    if (!cache[tokenId] || !TokenCacheSchema$1.safeParse(cache[tokenId]).success) {
+      const client = await connector.getPublicClientForEvmNetwork(networkId);
+      if (!client) {
+        log.warn(`No client found for network ${networkId} while fetching EVM ERC20 tokens`);
+        continue;
+      }
+      try {
+        const {
+          name,
+          decimals,
+          symbol
+        } = await getErc20ContractData$1(client, tokenConfig.contractAddress);
+        cache[tokenId] = {
+          id: tokenId,
+          symbol,
+          decimals,
+          name
+        };
+      } catch (err) {
+        log.warn(`Failed to fetch ERC20 token data for ${tokenConfig.contractAddress}`, err);
+        continue;
+      }
+    }
+    const base = {
+      type: MODULE_TYPE$8,
+      platform: PLATFORM$8,
+      networkId
+    };
+    const token = lodash.assign(base, cache[tokenId], tokenConfig);
+    const parsed = chaindataProvider.EvmErc20TokenSchema.safeParse(token);
+    if (!parsed.success) {
+      log.warn("Ignoring token with invalid EvmErc20TokenSchema", token);
+      continue;
+    }
+    result.push(parsed.data);
+  }
+  return result;
+};
+
+const getMiniMetadata$8 = () => {
+  throw new Error("MiniMetadata is not supported for ethereum tokens");
+};
+
+const getTransferCallData$8 = ({
+  from,
+  to,
+  value,
+  token
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$8)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$8}.`);
+  if (!util.isEthereumAddress(from)) throw new Error("Invalid from address");
+  if (!util.isEthereumAddress(to)) throw new Error("Invalid to address");
+  const data = viem.encodeFunctionData({
+    abi: viem.erc20Abi,
+    functionName: "transfer",
+    args: [to, BigInt(value)]
+  });
+  return {
+    from,
+    to: token.contractAddress,
+    data
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$8 = 6_000;
+const subscribeBalances$8 = ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$8({
+          networkId,
+          addressesByToken,
+          connector
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$8);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$8,
+          networkId,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const EvmErc20BalanceModule = {
+  type: MODULE_TYPE$8,
+  platform: PLATFORM$8,
+  getMiniMetadata: getMiniMetadata$8,
+  fetchTokens: fetchTokens$8,
+  fetchBalances: fetchBalances$8,
+  subscribeBalances: subscribeBalances$8,
+  getTransferCallData: getTransferCallData$8
+};
+
+const MODULE_TYPE$7 = chaindataProvider.EvmNativeTokenSchema.shape.type.value;
+const PLATFORM$7 = chaindataProvider.EvmNativeTokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  ...TokenConfigBaseSchema.shape
+});
+
+const fetchBalances$7 = async ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  const client = await connector.getPublicClientForEvmNetwork(networkId);
+  if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
+  for (const [token, addresses] of addressesByToken) {
+    if (token.type !== MODULE_TYPE$7 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    for (const address of addresses) if (!util.isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
+  }
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (client.chain?.contracts?.multicall3 && balanceDefs.length > 1) {
+    const multicall3 = client.chain.contracts.multicall3;
+    return fetchWithMulticall(client, balanceDefs, multicall3.address);
+  }
+  return fetchWithoutMulticall(client, balanceDefs);
+};
+const fetchWithoutMulticall = async (client, balanceDefs) => {
+  if (balanceDefs.length === 0) return {
+    success: [],
+    errors: []
+  };
+  log.debug("fetching %s balances without multicall3", MODULE_TYPE$7, balanceDefs.length);
+  const results = await Promise.allSettled(balanceDefs.map(async ({
+    token,
+    address
+  }) => {
+    try {
+      const result = await client.getBalance({
+        address
+      });
+      const balance = {
+        address,
+        tokenId: token.id,
+        value: result.toString(),
+        source: MODULE_TYPE$7,
+        networkId: chaindataProvider.parseTokenId(token.id).networkId,
+        status: "live"
+      };
+      return balance;
+    } catch (err) {
+      throw new BalanceFetchError(`Failed to get balance for token ${token.id} and address ${address} on chain ${client.chain?.id}`, token.id, address, err);
+    }
+  }));
+  return results.reduce((acc, result) => {
+    if (result.status === "fulfilled") acc.success.push(result.value);else {
+      const error = result.reason;
+      acc.errors.push({
+        tokenId: error.tokenId,
+        address: error.address,
+        error
+      });
+    }
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+const fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
+  if (balanceDefs.length === 0) return {
+    success: [],
+    errors: []
+  };
+  log.debug("fetching %s balances with multicall3", MODULE_TYPE$7, balanceDefs.length);
+  try {
+    const callResults = await client.multicall({
+      contracts: balanceDefs.map(({
+        address
+      }) => ({
+        address: multicall3Address,
+        abi: abiMulticall,
+        functionName: "getEthBalance",
+        args: [address]
+      }))
+    });
+    return callResults.reduce((acc, result, index) => {
+      if (result.status === "success") {
+        acc.success.push({
+          address: balanceDefs[index].address,
+          tokenId: balanceDefs[index].token.id,
+          value: result.result.toString(),
+          source: MODULE_TYPE$7,
+          networkId: chaindataProvider.parseTokenId(balanceDefs[index].token.id).networkId,
+          status: "live"
+        });
+      }
+      if (result.status === "failure") {
+        acc.errors.push({
+          tokenId: balanceDefs[index].token.id,
+          address: balanceDefs[index].address,
+          error: new BalanceFetchError(`Failed to get balance for token ${balanceDefs[index].token.id} and address ${balanceDefs[index].address} on chain ${client.chain?.id}`, balanceDefs[index].token.id, balanceDefs[index].address, result.error)
+        });
+      }
+      return acc;
+    }, {
+      success: [],
+      errors: []
+    });
+  } catch (err) {
+    const errors = balanceDefs.map(balanceDef => ({
+      tokenId: balanceDef.token.id,
+      address: balanceDef.address,
+      error: new BalanceFetchNetworkError(`Failed to get balances for evm-erc20 tokens on chain ${client.chain?.id}`, String(client.chain?.id), err)
+    }));
+    return {
+      success: [],
+      errors
+    };
+  }
+};
+
+const fetchTokens$7 = async ({
+  networkId,
+  tokens
+}) => {
+  // assume there is one and only one token in the array
+  if (tokens.length !== 1) throw new Error("EVM Native module expects the nativeCurrency to be passed as a single token in the array");
+  const token = lodash.assign({
+    id: chaindataProvider.evmNativeTokenId(networkId),
+    type: MODULE_TYPE$7,
+    platform: PLATFORM$7,
+    networkId,
+    isDefault: true
+  }, tokens[0]);
+  const parsed = chaindataProvider.EvmNativeTokenSchema.safeParse(token);
+  if (!parsed.success) {
+    log.warn("Ignoring token with invalid EvmErc20TokenSchema", token);
+    return [];
+  }
+  return [parsed.data];
+};
+
+const getMiniMetadata$7 = () => {
+  throw new Error("MiniMetadata is not supported for ethereum tokens");
+};
+
+const getTransferCallData$7 = ({
+  from,
+  to,
+  value,
+  token
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$7)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$7}.`);
+  if (!util.isEthereumAddress(from)) throw new Error("Invalid from address");
+  if (!util.isEthereumAddress(to)) throw new Error("Invalid to address");
+  return {
+    from,
+    to,
+    value,
+    data: "0x"
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$7 = 6_000;
+const subscribeBalances$7 = ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$7({
+          networkId,
+          addressesByToken,
+          connector
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$7);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$7,
+          networkId,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const EvmNativeBalanceModule = {
+  type: MODULE_TYPE$7,
+  platform: PLATFORM$7,
+  getMiniMetadata: getMiniMetadata$7,
+  fetchTokens: fetchTokens$7,
+  fetchBalances: fetchBalances$7,
+  subscribeBalances: subscribeBalances$7,
+  getTransferCallData: getTransferCallData$7
+};
+
+const MODULE_TYPE$6 = chaindataProvider.EvmUniswapV2TokenSchema.shape.type.value;
+const PLATFORM$6 = chaindataProvider.EvmUniswapV2TokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  contractAddress: chaindataProvider.EvmUniswapV2TokenSchema.shape.contractAddress,
+  ...TokenConfigBaseSchema.shape
+});
+
+const fetchBalances$6 = async ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  const client = await connector.getPublicClientForEvmNetwork(networkId);
+  if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
+  for (const [token, addresses] of addressesByToken) {
+    if (token.type !== MODULE_TYPE$6 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    for (const address of addresses) if (!util.isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
+  }
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (client.chain?.contracts?.erc20Aggregator && balanceDefs.length > 1) {
+    const erc20Aggregator = client.chain.contracts.erc20Aggregator;
+    return fetchWithAggregator(client, balanceDefs, erc20Aggregator.address);
+  }
+  return fetchWithoutAggregator(client, balanceDefs);
+};
+const fetchWithoutAggregator = async (client, balanceDefs) => {
+  if (balanceDefs.length === 0) return {
+    success: [],
+    errors: []
+  };
+  log.debug("fetching %s balances without aggregator", MODULE_TYPE$6, balanceDefs.length);
+  const results = await Promise.allSettled(balanceDefs.map(async ({
+    token,
+    address
+  }) => {
+    try {
+      const result = await client.readContract({
+        abi: viem.erc20Abi,
+        address: token.contractAddress,
+        functionName: "balanceOf",
+        args: [address]
+      });
+      const balance = {
+        address,
+        tokenId: token.id,
+        value: result.toString(),
+        source: MODULE_TYPE$6,
+        networkId: chaindataProvider.parseTokenId(token.id).networkId,
+        status: "cache"
+      };
+      return balance;
+    } catch (err) {
+      throw new BalanceFetchError(`Failed to get balance for token ${token.id} and address ${address} on chain ${client.chain?.id}`, token.id, address, err);
+    }
+  }));
+  return results.reduce((acc, result) => {
+    if (result.status === "fulfilled") acc.success.push(result.value);else {
+      const error = result.reason;
+      acc.errors.push({
+        tokenId: error.tokenId,
+        address: error.address,
+        error
+      });
+    }
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+const fetchWithAggregator = async (client, balanceDefs, erc20BalancesAggregatorAddress) => {
+  if (balanceDefs.length === 0) return {
+    success: [],
+    errors: []
+  };
+  log.debug("fetching %s balances with aggregator", MODULE_TYPE$6, balanceDefs.length);
+  try {
+    const erc20Balances = await client.readContract({
+      abi: erc20BalancesAggregatorAbi,
+      address: erc20BalancesAggregatorAddress,
+      functionName: "balances",
+      args: [balanceDefs.map(b => ({
+        account: b.address,
+        token: b.token.contractAddress
+      }))]
+    });
+    const success = balanceDefs.map((balanceDef, index) => ({
+      address: balanceDef.address,
+      tokenId: balanceDef.token.id,
+      value: erc20Balances[index].toString(),
+      source: MODULE_TYPE$6,
+      networkId: chaindataProvider.parseTokenId(balanceDef.token.id).networkId,
+      status: "cache"
+    }));
+    return {
+      success,
+      errors: []
+    };
+  } catch (err) {
+    const errors = balanceDefs.map(balanceDef => ({
+      tokenId: balanceDef.token.id,
+      address: balanceDef.address,
+      error: new BalanceFetchNetworkError(`Failed to get balances for evm-erc20 tokens on chain ${client.chain?.id}`, String(client.chain?.id), err)
+    }));
+    return {
+      success: [],
+      errors
+    };
+  }
+};
+
+const getErc20ContractData = async (client, contractAddress) => {
+  try {
+    const contract = getTypedContract(client, viem.erc20Abi, contractAddress);
+
+    // eslint-disable-next-line no-var
+    var [symbol, decimals, name] = await Promise.all([contract.read.symbol(), contract.read.decimals(), contract.read.name()]);
+  } catch (e) {
+    if (e instanceof viem.ContractFunctionExecutionError) {
+      // try to perform the contract read with bytes32 symbol
+      const contract = getTypedContract(client, viem.erc20Abi_bytes32, contractAddress);
+
+      // eslint-disable-next-line no-var
+      var [bytesSymbol, decimals, nameSymbol] = await Promise.all([contract.read.symbol(), contract.read.decimals(), contract.read.name()]);
+      symbol = viem.hexToString(bytesSymbol).replace(/\0/g, "").trim(); // remove NULL characters
+      name = viem.hexToString(nameSymbol).replace(/\0/g, "").trim(); // remove NULL characters
+    } else throw e;
+  }
+  return {
+    symbol,
+    decimals,
+    name
+  };
+};
+const getTypedContract = (client, abi, contractAddress) => viem.getContract({
+  address: contractAddress,
+  abi,
+  client: {
+    public: client
+  }
+});
+const getUniswapV2PairContractData = async (client, contractAddress) => {
+  const contract = getTypedContract(client, uniswapV2PairAbi, contractAddress);
+
+  // eslint-disable-next-line no-var
+  var [token0, token1, decimals, name] = await Promise.all([contract.read.token0(), contract.read.token1(), contract.read.decimals(), contract.read.name()]);
+  return {
+    token0,
+    token1,
+    decimals,
+    name
+  };
+};
+
+const TokenCacheSchema = chaindataProvider.EvmUniswapV2TokenSchema.pick({
+  symbol: true,
+  decimals: true,
+  name: true,
+  tokenAddress0: true,
+  tokenAddress1: true,
+  decimals0: true,
+  decimals1: true,
+  symbol0: true,
+  symbol1: true
+});
+const fetchTokens$6 = async ({
+  networkId,
+  tokens,
+  connector,
+  cache
+}) => {
+  const result = [];
+  for (const tokenConfig of tokens) {
+    const tokenId = chaindataProvider.evmUniswapV2TokenId(networkId, tokenConfig.contractAddress);
+    if (!cache[tokenId] || !TokenCacheSchema.safeParse(cache[tokenId]).success) {
+      const client = await connector.getPublicClientForEvmNetwork(networkId);
+      if (!client) {
+        log.warn(`No client found for network ${networkId} while fetching EVM ERC20 tokens`);
+        continue;
+      }
+      try {
+        const {
+          token0,
+          token1,
+          name,
+          decimals
+        } = await getUniswapV2PairContractData(client, tokenConfig.contractAddress);
+        const {
+          symbol: symbol0,
+          decimals: decimals0
+        } = await getErc20ContractData(client, token0);
+        const {
+          symbol: symbol1,
+          decimals: decimals1
+        } = await getErc20ContractData(client, token1);
+        cache[tokenId] = {
+          id: tokenId,
+          symbol: `${symbol0}/${symbol1}`,
+          decimals,
+          name,
+          tokenAddress0: token0,
+          tokenAddress1: token1,
+          decimals0,
+          decimals1,
+          symbol0,
+          symbol1
+        };
+      } catch (err) {
+        log.warn(`Failed to fetch UniswapV2 token data for ${tokenConfig.contractAddress}`, err.shortMessage);
+        continue;
+      }
+    }
+    const base = {
+      type: MODULE_TYPE$6,
+      platform: PLATFORM$6,
+      networkId
+    };
+    const token = lodash.assign(base, cache[tokenId], tokenConfig);
+    const parsed = chaindataProvider.EvmUniswapV2TokenSchema.safeParse(token);
+    if (!parsed.success) {
+      log.warn("Ignoring token with invalid EvmErc20TokenSchema", token);
+      continue;
+    }
+    result.push(parsed.data);
+  }
+  return result;
+};
+
+const getMiniMetadata$6 = () => {
+  throw new Error("MiniMetadata is not supported for ethereum tokens");
+};
+
+const getTransferCallData$6 = ({
+  from,
+  to,
+  value,
+  token
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$6)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$6}.`);
+  if (!util.isEthereumAddress(from)) throw new Error("Invalid from address");
+  if (!util.isEthereumAddress(to)) throw new Error("Invalid to address");
+  const data = viem.encodeFunctionData({
+    abi: viem.erc20Abi,
+    functionName: "transfer",
+    args: [to, BigInt(value)]
+  });
+  return {
+    from,
+    to: token.contractAddress,
+    data
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$6 = 6_000;
+const subscribeBalances$6 = ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$6({
+          networkId,
+          addressesByToken,
+          connector
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$6,
+          networkId,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const EvmUniswapV2BalanceModule = {
+  type: MODULE_TYPE$6,
+  platform: PLATFORM$6,
+  getMiniMetadata: getMiniMetadata$6,
+  fetchTokens: fetchTokens$6,
+  fetchBalances: fetchBalances$6,
+  subscribeBalances: subscribeBalances$6,
+  getTransferCallData: getTransferCallData$6
+};
+
+const MODULE_TYPE$5 = chaindataProvider.SubAssetsTokenSchema.shape.type.value;
+const PLATFORM$5 = chaindataProvider.SubAssetsTokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  assetId: chaindataProvider.SubAssetsTokenSchema.shape.assetId,
+  ...TokenConfigBaseSchema.shape
+});
+
+const fetchBalances$5 = async ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (!miniMetadata?.data) {
+    log.warn("MiniMetadata is required for fetching balances");
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE$5) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$5}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$5}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$5}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const queries = buildQueries$2(networkId, balanceDefs, miniMetadata);
+  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
+  return balanceDefs.reduce((acc, def) => {
+    const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
+    if (balance) acc.success.push(balance);
+    //if no entry consider empty balance
+    else acc.success.push({
+      address: def.address,
+      networkId,
+      tokenId: def.token.id,
+      source: MODULE_TYPE$5,
+      status: "live",
+      values: [{
+        type: "free",
+        label: "free",
+        amount: "0"
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: "0"
+      }]
+    });
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+const buildQueries$2 = (networkId, balanceDefs, miniMetadata) => {
+  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
+    storage: ["Assets", "Account"]
+  });
+  return balanceDefs.map(({
+    token,
+    address
+  }) => {
+    const scaleCoder = networkStorageCoders?.storage;
+    const stateKey = tryEncode(scaleCoder, Number(token.assetId), address) ??
+    // Asset Hub
+    tryEncode(scaleCoder, BigInt(token.assetId), address); // Astar
+
+    if (!stateKey) {
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+      return null;
+    }
+    const decodeResult = change => {
+      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+      const decoded = scale.decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
+        balance: 0n,
+        status: {
+          type: "Liquid"
+        }};
+      const isFrozen = decoded?.status?.type === "Frozen";
+      const amount = (decoded?.balance ?? 0n).toString();
+
+      // due to the following balance calculations, which are made in the `Balance` type:
+      //
+      // total balance        = (free balance) + (reserved balance)
+      // transferable balance = (free balance) - (frozen balance)
+      //
+      // when `isFrozen` is true we need to set **both** the `free` and `frozen` amounts
+      // of this balance to the value we received from the RPC.
+      //
+      // if we only set the `frozen` amount, then the `total` calculation will be incorrect!
+      const free = amount;
+      const frozen = token.isFrozen || isFrozen ? amount : "0";
+
+      // include balance values even if zero, so that newly-zero values overwrite old values
+      const balanceValues = [{
+        type: "free",
+        label: "free",
+        amount: free.toString()
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: frozen.toString()
+      }];
+      const balance = {
+        source: "substrate-assets",
+        status: "live",
+        address,
+        networkId,
+        tokenId: token.id,
+        values: balanceValues
+      };
+      return balance;
+    };
+    return {
+      chainId: networkId,
+      stateKey,
+      decodeResult
+    };
+  }).filter(util.isNotNil);
+};
+const tryEncode = (scaleCoder, ...args) => {
+  try {
+    return scaleCoder?.keys?.enc?.(...args);
+  } catch {
+    return null;
+  }
+};
+
+const fetchTokens$5 = async ({
+  networkId,
+  tokens,
+  connector,
+  miniMetadata
+}) => {
+  const anyMiniMetadata = miniMetadata;
+  if (!anyMiniMetadata?.data) return [];
+  const {
+    builder
+  } = scale.parseMetadataRpc(anyMiniMetadata.data);
+  const assetCodec = builder.buildStorage("Assets", "Asset");
+  const metadataCodec = builder.buildStorage("Assets", "Metadata");
+  const [allAssetStorageKeys, allMetadataStorageKeys] = await Promise.all([connector.send(networkId, "state_getKeys", [scale.getStorageKeyPrefix("Assets", "Asset")]), connector.send(networkId, "state_getKeys", [scale.getStorageKeyPrefix("Assets", "Metadata")])]);
+  const [assetStorageResults, metadataStorageResults] = await Promise.all([connector.send(networkId, "state_queryStorageAt", [allAssetStorageKeys]), connector.send(networkId, "state_queryStorageAt", [allMetadataStorageKeys])]);
+  const assetStorageEntries = assetStorageResults[0].changes;
+  const metadataStorageEntries = metadataStorageResults[0].changes;
+  const assetByAssetId = lodash.keyBy(assetStorageEntries.map(([key, value]) => {
+    const [assetId] = assetCodec.keys.dec(key);
+    const asset = assetCodec.value.dec(value);
+    return {
+      assetId,
+      existentialDeposit: asset.min_balance,
+      isSufficient: asset.is_sufficient
+    };
+  }), a => a.assetId);
+  const metadataByAssetId = lodash.keyBy(metadataStorageEntries.map(([key, value]) => {
+    const [assetId] = metadataCodec.keys.dec(key);
+    const metadata = metadataCodec.value.dec(value);
+    return {
+      assetId,
+      decimals: metadata.decimals,
+      isFrozen: metadata.is_frozen,
+      name: metadata.name?.asText(),
+      symbol: metadata.symbol?.asText()
+    };
+  }), a => a.assetId);
+  const allTokens = lodash.keys(assetByAssetId).map(assetId => lodash.assign({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? undefined));
+  const configTokenByAssetId = lodash.keyBy(tokens, t => t.assetId);
+  return allTokens.map(asset => ({
+    id: chaindataProvider.subAssetTokenId(networkId, String(asset.assetId)),
+    type: MODULE_TYPE$5,
+    platform: "polkadot",
+    networkId,
+    assetId: String(asset.assetId),
+    isSufficient: asset.isSufficient,
+    isFrozen: asset.isFrozen,
+    name: asset.name,
+    symbol: asset.symbol,
+    decimals: asset.decimals ?? 0,
+    existentialDeposit: String(asset.existentialDeposit),
+    isDefault: true
+  }))
+  // keep all tokens listed in the config + all tokens marked as sufficient
+  .filter(token => {
+    const configToken = configTokenByAssetId[token.assetId];
+    return configToken || token.isSufficient;
+  })
+  // apply config overrides
+  .map(token => {
+    const configToken = configTokenByAssetId[token.assetId];
+    return configToken ? lodash.assign({}, token, configToken) : token;
+  })
+  // validate results
+  .filter(t => {
+    const parsed = chaindataProvider.SubAssetsTokenSchema.safeParse(t);
+    if (!parsed.success) log.warn(`Ignoring invalid token ${MODULE_TYPE$5}`, t);
+    return parsed.success;
+  });
+};
+
+const getConstantValue = (metadataRpc, pallet, constant) => {
+  const {
+    unifiedMetadata,
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const codec = builder.buildConstant(pallet, constant);
+  const encodedValue = unifiedMetadata.pallets.find(({
+    name
+  }) => name === pallet)?.constants.find(({
+    name
+  }) => name === constant)?.value;
+  if (!encodedValue) throw new Error(`Constant ${pallet}.${constant} not found`);
+  return codec.dec(encodedValue);
+};
+
+const hasStorageItem = (metadata, palletName, itemName) => {
+  const pallet = metadata.pallets.find(p => p.name === palletName);
+  if (!pallet || !pallet.storage) return false;
+  return pallet.storage.items.some(item => item.name === itemName);
+};
+const hasStorageItems = (metadata, palletName, itemNames) => {
+  const pallet = metadata.pallets.find(p => p.name === palletName);
+  if (!pallet || !pallet.storage) return false;
+  return itemNames.every(itemName => pallet.storage?.items.some(item => item.name === itemName));
+};
+const hasRuntimeApi = (metadata, apiName, method) => {
+  const api = metadata.apis.find(api => api.name === apiName);
+  if (!api || !api.methods) return false;
+  return api.methods.some(m => m.name === method);
+};
+
+const getMiniMetadata$5 = ({
+  networkId,
+  specVersion,
+  metadataRpc
+}) => {
+  const source = MODULE_TYPE$5;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) log.warn("specVersion mismatch", {
+    networkId,
+    specVersion,
+    systemVersion
+  });
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: getData$3(metadataRpc),
+    extra: null
+  };
+};
+const getData$3 = metadataRpc => {
+  const {
+    metadata,
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+
+  // ensure the network has all the required bits
+  if (!hasStorageItems(unifiedMetadata, "Assets", ["Account", "Asset", "Metadata"])) return null;
+  scale.compactMetadata(metadata, [{
+    pallet: "Assets",
+    items: ["Account", "Asset", "Metadata"]
+  }]);
+  return scale.encodeMetadata(metadata);
+};
+
+const getTransferCallData$5 = ({
+  from,
+  to,
+  value,
+  token,
+  type,
+  metadataRpc
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$5)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$5}.`);
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const method = getTransferMethod$3(type);
+  const {
+    codec,
+    location
+  } = builder.buildCall("Assets", method);
+  const args = getEncodedArgs$2(method, token.assetId, to, value, codec);
+  const callData = polkadotApi.Binary.fromBytes(utils.mergeUint8([new Uint8Array(location), args]));
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+const getTransferMethod$3 = type => {
+  switch (type) {
+    case "keep-alive":
+      return "transfer_keep_alive";
+    case "all":
+      return "transfer_all";
+    case "allow-death":
+      return "transfer";
+  }
+};
+const getEncodedArgs$2 = (method, assetId, to, value, argsCodec) => {
+  try {
+    switch (method) {
+      case "transfer_keep_alive":
+      case "transfer":
+        return getTransferEncodedArgs$2(assetId, to, value, argsCodec);
+      case "transfer_all":
+        return getTransferAllEncodedArgs$2(assetId, to, argsCodec);
+    }
+  } catch {
+    throw new Error(`Failed to encode arguments for method ${method}: ${assetId}, ${to}, ${value}`);
+  }
+};
+const getEncodedValue$2 = (codec, possibleValue) => {
+  for (const getArgs of possibleValue) {
+    try {
+      return codec.enc(getArgs());
+    } catch (error) {
+      // wrong inputs, ignore and try the next one
+    }
+  }
+  throw new Error("Failed to encode");
+};
+
+// same inputs for both KeepAlive and allowDeath
+const getTransferEncodedArgs$2 = (assetId, to, value, codec) => {
+  return getEncodedValue$2(codec, [() => ({
+    id: Number(assetId),
+    // for most networks
+    target: polkadotApi.Enum("Id", to),
+    amount: BigInt(value)
+  }), () => ({
+    id: BigInt(assetId),
+    // for Astar
+    target: polkadotApi.Enum("Id", to),
+    amount: BigInt(value)
+  })]);
+};
+const getTransferAllEncodedArgs$2 = (assetId, to, codec) => {
+  return getEncodedValue$2(codec, [() => ({
+    id: Number(assetId),
+    // for most networks
+    target: polkadotApi.Enum("Id", to),
+    keep_alive: false
+  }), () => ({
+    id: BigInt(assetId),
+    // for Astar
+    target: polkadotApi.Enum("Id", to),
+    keep_alive: false
+  })]);
+};
+
+const SUBSCRIPTION_INTERVAL$5 = 6_000;
+const subscribeBalances$5 = ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$5({
+          networkId,
+          addressesByToken,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$5,
+          networkId,
+          miniMetadata,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const SubAssetsBalanceModule = {
+  type: MODULE_TYPE$5,
+  platform: PLATFORM$5,
+  getMiniMetadata: getMiniMetadata$5,
+  fetchTokens: fetchTokens$5,
+  fetchBalances: fetchBalances$5,
+  subscribeBalances: subscribeBalances$5,
+  getTransferCallData: getTransferCallData$5
+};
+
+const MODULE_TYPE$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.type.value;
+const PLATFORM$4 = chaindataProvider.SubForeignAssetsTokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  onChainId: chaindataProvider.SubForeignAssetsTokenSchema.shape.onChainId,
+  ...TokenConfigBaseSchema.shape
+});
+
+const fetchBalances$4 = async ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (!miniMetadata?.data) {
+    log.warn("MiniMetadata is required for fetching balances");
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE$4) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$4}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$4}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$4}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const queries = buildQueries$1(networkId, balanceDefs, miniMetadata);
+  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
+  return balanceDefs.reduce((acc, def) => {
+    const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
+    if (balance) acc.success.push(balance);
+    //if no entry consider empty balance
+    else acc.success.push({
+      address: def.address,
+      networkId,
+      tokenId: def.token.id,
+      source: MODULE_TYPE$4,
+      status: "live",
+      values: [{
+        type: "free",
+        label: "free",
+        amount: "0"
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: "0"
+      }]
+    });
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+const buildQueries$1 = (networkId, balanceDefs, miniMetadata) => {
+  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
+    storage: ["ForeignAssets", "Account"]
+  });
+  return balanceDefs.map(({
+    token,
+    address
+  }) => {
+    const scaleCoder = networkStorageCoders?.storage;
+    const getStateKey = onChainId => {
+      try {
+        return scaleCoder?.keys?.enc?.(scale.papiParse(onChainId), address);
+      } catch {
+        return null;
+      }
+    };
+    const stateKey = getStateKey(token.onChainId);
+    if (!stateKey) {
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${address}`);
+      return null;
+    }
+    const decodeResult = change => {
+      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+      const decoded = scale.decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
+        balance: 0n,
+        is_frozen: false,
+        status: {
+          type: "Liquid"
+        }};
+      const isFrozen = decoded.is_frozen ?? decoded?.status?.type === "Frozen";
+      const amount = (decoded?.balance ?? 0n).toString();
+
+      // due to the following balance calculations, which are made in the `Balance` type:
+      //
+      // total balance        = (free balance) + (reserved balance)
+      // transferable balance = (free balance) - (frozen balance)
+      //
+      // when `isFrozen` is true we need to set **both** the `free` and `frozen` amounts
+      // of this balance to the value we received from the RPC.
+      //
+      // if we only set the `frozen` amount, then the `total` calculation will be incorrect!
+      const free = amount;
+      const frozen = token.isFrozen || isFrozen ? amount : "0";
+
+      // include balance values even if zero, so that newly-zero values overwrite old values
+      const balanceValues = [{
+        type: "free",
+        label: "free",
+        amount: free.toString()
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: frozen.toString()
+      }];
+      const balance = {
+        source: "substrate-assets",
+        status: "live",
+        address,
+        networkId,
+        tokenId: token.id,
+        values: balanceValues
+      };
+      return balance;
+    };
+    return {
+      chainId: networkId,
+      stateKey,
+      decodeResult
+    };
+  }).filter(util.isNotNil);
+};
+
+const fetchTokens$4 = async ({
+  networkId,
+  tokens,
+  connector,
+  miniMetadata
+}) => {
+  const anyMiniMetadata = miniMetadata;
+  if (!anyMiniMetadata?.data) return [];
+  const {
+    builder
+  } = scale.parseMetadataRpc(anyMiniMetadata.data);
+  const assetCodec = builder.buildStorage("ForeignAssets", "Asset");
+  const metadataCodec = builder.buildStorage("ForeignAssets", "Metadata");
+  const [allAssetStorageKeys, allMetadataStorageKeys] = await Promise.all([connector.send(networkId, "state_getKeys", [scale.getStorageKeyPrefix("ForeignAssets", "Asset")]), connector.send(networkId, "state_getKeys", [scale.getStorageKeyPrefix("ForeignAssets", "Metadata")])]);
+  const [assetStorageResults, metadataStorageResults] = await Promise.all([connector.send(networkId, "state_queryStorageAt", [allAssetStorageKeys]), connector.send(networkId, "state_queryStorageAt", [allMetadataStorageKeys])]);
+  const assetStorageEntries = assetStorageResults[0].changes;
+  const metadataStorageEntries = metadataStorageResults[0].changes;
+  const assetByOnChainId = lodash.keyBy(assetStorageEntries.map(([key, value]) => {
+    const [decodedKey] = assetCodec.keys.dec(key);
+    const onChainId = scale.papiStringify(decodedKey);
+    const asset = assetCodec.value.dec(value);
+    return {
+      onChainId,
+      existentialDeposit: asset.min_balance,
+      isSufficient: asset.is_sufficient
+    };
+  }), a => a.onChainId);
+  const metadataByOnChainId = lodash.keyBy(metadataStorageEntries.map(([key, value]) => {
+    const [decodedKey] = metadataCodec.keys.dec(key);
+    const onChainId = scale.papiStringify(decodedKey);
+    const metadata = metadataCodec.value.dec(value);
+    return {
+      onChainId,
+      decimals: metadata.decimals,
+      isFrozen: metadata.is_frozen,
+      name: metadata.name?.asText(),
+      symbol: metadata.symbol?.asText()
+    };
+  }), a => a.onChainId);
+  const allTokens = lodash.keys(assetByOnChainId).map(onChainId => lodash.assign({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? undefined));
+  const configTokenByOnChainId = lodash.keyBy(tokens, t => t.onChainId);
+  return allTokens.map(asset => ({
+    id: chaindataProvider.subForeignAssetTokenId(networkId, asset.onChainId),
+    type: MODULE_TYPE$4,
+    platform: "polkadot",
+    networkId,
+    onChainId: String(asset.onChainId),
+    isSufficient: asset.isSufficient,
+    isFrozen: asset.isFrozen,
+    name: asset.name,
+    symbol: asset.symbol,
+    decimals: asset.decimals ?? 0,
+    existentialDeposit: String(asset.existentialDeposit),
+    isDefault: true
+  }))
+  // keep all tokens listed in the config + all tokens marked as sufficient
+  .filter(token => {
+    const configToken = configTokenByOnChainId[token.onChainId];
+    return configToken || token.isSufficient;
+  })
+  // apply config overrides
+  .map(token => {
+    const configToken = configTokenByOnChainId[token.onChainId];
+    return configToken ? lodash.assign({}, token, configToken) : token;
+  })
+  // validate results
+  .filter(t => {
+    const parsed = chaindataProvider.SubForeignAssetsTokenSchema.safeParse(t);
+    if (!parsed.success) log.warn(`Ignoring invalid token ${MODULE_TYPE$4}`, t);
+    return parsed.success;
+  });
+};
+
+const getMiniMetadata$4 = ({
+  networkId,
+  specVersion,
+  metadataRpc
+}) => {
+  const source = MODULE_TYPE$4;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) log.warn("specVersion mismatch", {
+    networkId,
+    specVersion,
+    systemVersion
+  });
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: getData$2(metadataRpc),
+    extra: null
+  };
+};
+const getData$2 = metadataRpc => {
+  const {
+    metadata,
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+
+  // ensure the network has all the required bits
+  if (!hasStorageItems(unifiedMetadata, "ForeignAssets", ["Account", "Asset", "Metadata"])) return null;
+  scale.compactMetadata(metadata, [{
+    pallet: "ForeignAssets",
+    items: ["Account", "Asset", "Metadata"]
+  }]);
+  return scale.encodeMetadata(metadata);
+};
+
+const getTransferCallData$4 = ({
+  from,
+  to,
+  value,
+  token,
+  type,
+  metadataRpc
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$4)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$4}.`);
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const method = getTransferMethod$2(type);
+  const {
+    codec,
+    location
+  } = builder.buildCall("ForeignAssets", method);
+  const args = getEncodedArgs$1(method, token.onChainId, to, value, codec);
+  const callData = polkadotApi.Binary.fromBytes(utils.mergeUint8([new Uint8Array(location), args]));
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+const getTransferMethod$2 = type => {
+  switch (type) {
+    case "keep-alive":
+      return "transfer_keep_alive";
+    case "all":
+      return "transfer_all";
+    case "allow-death":
+      return "transfer";
+  }
+};
+const getEncodedArgs$1 = (method, onChainId, to, value, argsCodec) => {
+  try {
+    switch (method) {
+      case "transfer_keep_alive":
+      case "transfer":
+        return getTransferEncodedArgs$1(onChainId, to, value, argsCodec);
+      case "transfer_all":
+        return getTransferAllEncodedArgs$1(onChainId, to, argsCodec);
+    }
+  } catch {
+    throw new Error(`Failed to encode arguments for method ${method}: ${onChainId}, ${to}, ${value}`);
+  }
+};
+const getEncodedValue$1 = (codec, possibleValue) => {
+  for (const getArgs of possibleValue) {
+    try {
+      return codec.enc(getArgs());
+    } catch (error) {
+      // wrong inputs, ignore and try the next one
+    }
+  }
+  throw new Error("Failed to encode");
+};
+
+// same inputs for both KeepAlive and allowDeath
+const getTransferEncodedArgs$1 = (onChainId, to, value, codec) => {
+  return getEncodedValue$1(codec, [() => ({
+    id: scale.papiParse(onChainId),
+    // for most networks
+    target: polkadotApi.Enum("Id", to),
+    amount: BigInt(value)
+  })]);
+};
+const getTransferAllEncodedArgs$1 = (onChainId, to, codec) => {
+  return getEncodedValue$1(codec, [() => ({
+    id: scale.papiParse(onChainId),
+    // for most networks
+    target: polkadotApi.Enum("Id", to),
+    keep_alive: false
+  })]);
+};
+
+const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const subscribeBalances$4 = ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$4({
+          networkId,
+          addressesByToken,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$4,
+          networkId,
+          miniMetadata,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const SubForeignAssetsBalanceModule = {
+  type: MODULE_TYPE$4,
+  platform: PLATFORM$4,
+  getMiniMetadata: getMiniMetadata$4,
+  fetchTokens: fetchTokens$4,
+  fetchBalances: fetchBalances$4,
+  subscribeBalances: subscribeBalances$4,
+  getTransferCallData: getTransferCallData$4
+};
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  onChainId: chaindataProvider.SubHydrationTokenSchema.shape.onChainId,
+  ...TokenConfigBaseSchema.shape
+});
+
+const MODULE_TYPE$3 = chaindataProvider.SubHydrationTokenSchema.shape.type.value;
+const PLATFORM$3 = chaindataProvider.SubHydrationTokenSchema.shape.platform.value;
+
+const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const call = builder.buildRuntimeCall(apiName, method);
+  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, scale.toHex(call.args.enc(args))]);
+  return call.value.dec(hex);
+};
+
+const tryGetConstantValue = (metadataRpc, pallet, constant) => {
+  const {
+    unifiedMetadata,
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const encodedValue = unifiedMetadata.pallets.find(({
+    name
+  }) => name === pallet)?.constants.find(({
+    name
+  }) => name === constant)?.value;
+  if (!encodedValue) return null;
+  const codec = builder.buildConstant(pallet, constant);
+  return codec.dec(encodedValue);
+};
+
+const fetchBalances$3 = async ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (!miniMetadata?.data) {
+    log.warn("MiniMetadata is required for fetching balances");
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE$3) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$3}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$3}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$3}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const addresses = lodash.uniq(balanceDefs.map(def => def.address));
+  try {
+    const res = await Promise.all(addresses.map(address => fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "CurrenciesApi", "accounts", [address])));
+    const fetchedBalances = addresses.flatMap((address, index) => {
+      return res[index].map(([onChainId, balance]) => ({
+        address,
+        onChainId,
+        free: balance.free.toString(),
+        reserved: balance.reserved.toString(),
+        frozen: balance.frozen.toString()
+      })).filter(b => b.onChainId !== undefined);
+    });
+    const balancesByKey = lodash.keyBy(fetchedBalances, b => `${b.address}:${b.onChainId}`);
+    const success = addressesByToken.reduce((acc, [token, addresses]) => {
+      if (token.type === MODULE_TYPE$3) for (const address of addresses) {
+        const rawBalance = balancesByKey[`${address}:${token.onChainId}`];
+
+        // the endpoint only returns entries for which the address has a non-zero balance
+        // => generate an zero balance object if not found
+        const balance = {
+          address,
+          networkId,
+          tokenId: token.id,
+          source: MODULE_TYPE$3,
+          status: "cache",
+          values: [{
+            type: "free",
+            label: "free",
+            amount: rawBalance?.free.toString() ?? "0"
+          }, {
+            type: "reserved",
+            label: "reserved",
+            amount: rawBalance?.reserved.toString() ?? "0"
+          }, {
+            type: "locked",
+            label: "frozen",
+            amount: rawBalance?.frozen.toString() ?? "0"
+          }]
+        };
+        acc.push(balance);
+      }
+      return acc;
+    }, []);
+    return {
+      success,
+      errors: []
+    };
+  } catch (err) {
+    log.warn("Failed to fetch balances for substrate-hydration", err);
+    const errors = balanceDefs.map(def => ({
+      tokenId: def.token.id,
+      address: def.address,
+      error: new Error(`Failed to fetch balance for ${def.address} on ${networkId}`)
+    }));
+    return {
+      success: [],
+      errors
+    };
+  }
+};
+
+const fetchTokens$3 = async ({
+  networkId,
+  tokens,
+  connector,
+  miniMetadata
+}) => {
+  const anyMiniMetadata = miniMetadata;
+  if (!anyMiniMetadata?.data) return [];
+  const {
+    builder
+  } = scale.parseMetadataRpc(anyMiniMetadata.data);
+  const assetsCodec = builder.buildStorage("AssetRegistry", "Assets");
+  const allAssetStorageKeys = await connector.send(networkId, "state_getKeys", [scale.getStorageKeyPrefix("AssetRegistry", "Assets")]);
+  const assetStorageResults = await connector.send(networkId, "state_queryStorageAt", [allAssetStorageKeys]);
+  const assetStorageEntries = assetStorageResults[0].changes;
+  const configTokenByAssetId = lodash.keyBy(tokens, t => t.onChainId);
+  return assetStorageEntries.map(([key, value]) => {
+    // parse results
+    const [onChainId] = assetsCodec.keys.dec(key);
+    const asset = assetsCodec.value.dec(value);
+    return {
+      onChainId,
+      assetType: asset.asset_type.type,
+      isSufficient: asset.is_sufficient,
+      name: asset.name?.asText(),
+      symbol: asset.symbol?.asText(),
+      decimals: asset.decimals,
+      existentialDeposit: asset.existential_deposit.toString()
+    };
+  })
+  // exclude unsupported asset types
+  .filter(({
+    assetType
+  }) => ["Erc20", "Token"].includes(assetType))
+  // convert asset to a SubHydrationToken
+  .map(asset => ({
+    id: chaindataProvider.subHydrationTokenId(networkId, asset.onChainId),
+    type: MODULE_TYPE$3,
+    platform: "polkadot",
+    networkId,
+    onChainId: asset.onChainId,
+    assetType: asset.assetType,
+    // Erc20 or Token,
+    isSufficient: asset.isSufficient,
+    name: asset.name,
+    symbol: asset.symbol,
+    decimals: asset.decimals ?? 0,
+    existentialDeposit: asset.existentialDeposit,
+    isDefault: true
+  }))
+  // keep all tokens listed in the config + all tokens marked as sufficient
+  .filter(token => {
+    const configToken = configTokenByAssetId[token.onChainId];
+    return configToken || token.isSufficient;
+  })
+  // apply config overrides
+  .map(token => {
+    const configToken = configTokenByAssetId[token.onChainId];
+    return configToken ? lodash.assign({}, token, configToken) : token;
+  })
+  // validate results
+  .filter(t => {
+    const parsed = chaindataProvider.SubHydrationTokenSchema.safeParse(t);
+    if (!parsed.success) log.warn(`Ignoring invalid token ${MODULE_TYPE$3}`, t);
+    return parsed.success;
+  });
+};
+
+const getMiniMetadata$3 = ({
+  networkId,
+  specVersion,
+  metadataRpc
+}) => {
+  const source = MODULE_TYPE$3;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) log.warn("specVersion mismatch", {
+    networkId,
+    specVersion,
+    systemVersion
+  });
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: getData$1(metadataRpc),
+    extra: null
+  };
+};
+const getData$1 = metadataRpc => {
+  const {
+    metadata,
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+
+  // ensure the network has all the required bits
+  if (!hasStorageItem(unifiedMetadata, "AssetRegistry", "Assets") || !hasStorageItem(unifiedMetadata, "Tokens", "Accounts") || !hasRuntimeApi(unifiedMetadata, "CurrenciesApi", "accounts")) return null;
+  scale.compactMetadata(metadata, [{
+    pallet: "AssetRegistry",
+    items: ["Assets"]
+  },
+  // token specs
+  {
+    pallet: "Tokens",
+    items: ["Accounts"]
+  } // balances for tokens
+  ], [{
+    runtimeApi: "CurrenciesApi",
+    methods: ["accounts"]
+  }]);
+  return scale.encodeMetadata(metadata);
+};
+
+const getTransferCallData$3 = ({
+  from,
+  to,
+  value,
+  token,
+  metadataRpc
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$3)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$3}.`);
+
+  // there is only one transfer method, no existential deposit handling.
+  // => leave this to the frontend and dry runs
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const {
+    codec,
+    location
+  } = builder.buildCall("Currencies", "transfer");
+  const args = {
+    dest: to,
+    currency_id: token.onChainId,
+    amount: BigInt(value)
+  };
+  const callData = polkadotApi.Binary.fromBytes(utils.mergeUint8([new Uint8Array(location), codec.enc(args)]));
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$3 = 6_000;
+const subscribeBalances$3 = ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$3({
+          networkId,
+          addressesByToken,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$3,
+          networkId,
+          miniMetadata,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const SubHydrationBalanceModule = {
+  type: MODULE_TYPE$3,
+  platform: PLATFORM$3,
+  getMiniMetadata: getMiniMetadata$3,
+  fetchTokens: fetchTokens$3,
+  fetchBalances: fetchBalances$3,
+  subscribeBalances: subscribeBalances$3,
+  getTransferCallData: getTransferCallData$3
+};
+
+const MODULE_TYPE$2 = chaindataProvider.SubNativeTokenSchema.shape.type.value;
+const PLATFORM$2 = chaindataProvider.SubNativeTokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  ...TokenConfigBaseSchema.shape
+});
+
+// Do not use this type outside of this module
+
+// Do not use this type outside of this module
+
+// Do not use this type outside of this module
+
+/**
+ * Pass some these into an `RpcStateQueryHelper` in order to easily batch multiple state queries into the one rpc call.
+ */
+
+const fetchQueriesPack = async (connector, networkId, queries) => {
+  const allStateKeys = queries.flatMap(({
+    stateKeys
+  }) => stateKeys).filter(util.isNotNil);
+
+  // doing a query with only null keys would throw an error => return early
+  if (!allStateKeys.length) return queries.map(({
+    stateKeys,
+    decodeResult
+  }) => decodeResult(stateKeys.map(() => null)));
+  const response = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
+  const results = queries.reduce((acc, {
+    stateKeys,
+    decodeResult
+  }) => {
+    const changes = stateKeys.map(stateKey => {
+      if (!stateKey) return null;
+      const change = response[0].changes.find(([key]) => key === stateKey);
+      if (!change) return null;
+      return change[1];
+    });
+    acc.push(decodeResult(changes));
+    return acc;
+  }, []);
+  return results;
+};
+
+/**
+ * Used by a variety of balance modules to help batch multiple state queries into the one rpc call.
+ */
+// export class RpcStateQueriesHelper<T> {
+//   #connector: ChainConnector
+//   #queries: Array<RpcStateQueries<T>>
+
+//   constructor(connector: ChainConnector, queries: Array<RpcStateQueries<T>>) {
+//     this.#connector = connector
+//     this.#queries = queries
+//   }
+
+//   async subscribe(
+//     networkId: DotNetworkId,
+//     callback: SubscriptionCallback<T[]>,
+//     timeout: number | false = false,
+//     subscribeMethod = "state_subscribeStorage",
+//     responseMethod = "state_storage",
+//     unsubscribeMethod = "state_unsubscribeStorage",
+//   ): Promise<UnsubscribeFn> {
+//     const params = [this.#queries.flatMap(({ stateKeys }) => stateKeys)]
+
+//     const unsub = this.#connector.subscribe(
+//       networkId,
+//       subscribeMethod,
+//       responseMethod,
+//       params,
+//       (error, result) => {
+//         error
+//           ? callback(error)
+//           : callback(null, this.#distributeChangesToQueryDecoders.call(this, chainId, result))
+//       },
+//       timeout,
+//     )
+
+//     const subscriptions = queries.map(([chainId, queries]) => {
+//       const params = [queries.map(({ stateKey }) => stateKey)]
+
+//       const unsub = this.#connector.subscribe(
+//         networkId,
+//         subscribeMethod,
+//         responseMethod,
+//         params,
+//         (error, result) => {
+//           error
+//             ? callback(error)
+//             : callback(null, this.#distributeChangesToQueryDecoders.call(this, chainId, result))
+//         },
+//         timeout,
+//       )
+
+//       return () => unsub.then((unsubscribe) => unsubscribe(unsubscribeMethod))
+//     })
+
+//     return () => subscriptions.forEach((unsubscribe) => unsubscribe())
+//   }
+
+//   async fetch(method = "state_queryStorageAt"): Promise<T[]> {
+//     const queriesByChain = groupBy(this.#queries, "chainId")
+
+//     const resultsByChain = await Promise.all(
+//       Object.entries(queriesByChain).map(async ([chainId, queries]) => {
+//         const params = [queries.map(({ stateKey }) => stateKey)]
+
+//         const result = (await this.#connector.send(chainId, method, params))[0]
+//         return this.#distributeChangesToQueryDecoders.call(this, chainId, result)
+//       }),
+//     )
+
+//     return resultsByChain.flatMap((result) => result)
+//   }
+
+//   #distributeChangesToQueryDecoders(chainId: DotNetworkId, result: unknown): T[] {
+//     if (typeof result !== "object" || result === null) return []
+//     if (!hasOwnProperty(result, "changes") || typeof result.changes !== "object") return []
+//     if (!Array.isArray(result.changes)) return []
+
+//     return result.changes.flatMap(([reference, change]: [unknown, unknown]): [T] | [] => {
+//       if (typeof reference !== "string") {
+//         log.warn(`Received non-string reference in RPC result: ${reference}`)
+//         return []
+//       }
+
+//       if (typeof change !== "string" && change !== null) {
+//         log.warn(`Received non-string and non-null change in RPC result: ${reference} | ${change}`)
+//         return []
+//       }
+
+//       const query = this.#queries.find(
+//         ({ chainId: cId, stateKey }) => cId === chainId && stateKey === reference,
+//       )
+//       if (!query) {
+//         log.warn(
+//           `Failed to find query:\n${reference} in\n${this.#queries.map(({ stateKey }) => stateKey)}`,
+//         )
+//         return []
+//       }
+
+//       return [query.decodeResult(change)]
+//     })
+//   }
+// }
+
+const SUBTENSOR_ROOT_NETUID = 0;
+const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = 1000000n;
+const TAO_DECIMALS = 9n;
+const SCALE_FACTOR = 10n ** TAO_DECIMALS; // Equivalent to 10e9 for precision
+const ONE_ALPHA_TOKEN = SCALE_FACTOR;
+const calculateAlphaPrice = ({
+  dynamicInfo
+}) => {
+  if (!dynamicInfo) return 0n;
+  const {
+    alpha_in,
+    tao_in
+  } = dynamicInfo;
+
+  // Scale taoIn before division to preserve precision
+  const result = tao_in * SCALE_FACTOR / alpha_in;
+  return result; // Scaled price as bigint
+};
+const calculateTaoAmountFromAlpha = ({
+  alphaPrice,
+  alphaStaked
+}) => {
+  if (!alphaStaked || !alphaPrice) return 0n;
+  const expectedAlpha = alphaStaked * alphaPrice;
+  return expectedAlpha / SCALE_FACTOR;
+};
+const calculateTaoFromDynamicInfo = ({
+  dynamicInfo,
+  alphaStaked
+}) => {
+  const alphaPrice = calculateAlphaPrice({
+    dynamicInfo
+  });
+  return calculateTaoAmountFromAlpha({
+    alphaPrice,
+    alphaStaked
+  });
+};
+
+// per address, lists of values to add to the native balance
+
+const getSubtensorStakingBalances$ = (connector, networkId, balanceDefs, miniMetadata) => {
+  const addresses = balanceDefs.map(def => def.address);
+  const token = balanceDefs[0].token;
+  if (!addresses.length || !token || !miniMetadata.extra.hasSubtensorPallet || !miniMetadata.data) return rxjs.of({});
+
+  // we are only doing runtime calls, there is no way to subscribe to changes, except polling
+  // => start immediately, then repeat every 30 seconds
+  return rxjs.timer(0, 30000).pipe(rxjs.switchMap(() => rxjs.from(fetchStakeInfoByAddress(connector, networkId, miniMetadata, addresses)).pipe(rxjs.switchMap(stakeInfoByAddress => fetchStakingBalanceValuesByAddress(connector, networkId, miniMetadata, stakeInfoByAddress)))));
+};
+const fetchStakingBalanceValuesByAddress = async (connector, networkId, miniMetadata, stakeInfoByAddress) => {
+  const uniqueNetuids = lodash.uniq(lodash.values(stakeInfoByAddress).flatMap(infos => infos.map(info => info.netuid))).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID);
+  const dynamicInfoByNetuid = await fetchDynamicInfoByNetuid(connector, networkId, miniMetadata, uniqueNetuids);
+  return lodash.fromPairs(lodash.toPairs(stakeInfoByAddress).map(([address, stakeInfos]) => {
+    const stakesBalances = stakeInfos.filter(({
+      stake
+    }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK).map(({
+      hotkey,
+      netuid,
+      stake
+    }) => ({
+      hotkey,
+      netuid: Number(netuid),
+      stake: BigInt(stake),
+      dynamicInfo: dynamicInfoByNetuid[Number(netuid)]
+    })).map(({
+      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 ?? []));
+      const subnetIdentity = subnet_identity ? lodash.fromPairs(lodash.toPairs(subnet_identity).map(([key, binary]) => [key, binary.asText()])) : 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;
+      const balanceValue = {
+        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
+            }
+          }
+        }
+      };
+      return balanceValue;
+    });
+    return [address, stakesBalances];
+  }));
+};
+const fetchStakeInfoByAddress = async (connector, networkId, miniMetadata, addresses) => {
+  const pairs = await Promise.all(addresses.map(async address => [address, await viem.withRetry(() => fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "StakeInfoRuntimeApi", "get_stake_info_for_coldkey", [address]), {
+    delay: 500,
+    retryCount: 3
+  })]));
+  return lodash.fromPairs(pairs);
+};
+
+// assume dynamic info doesnt change over the course of a browser session
+const dynamicInfoCache = new Map();
+const getCacheKey = (networkId, netuid) => `${networkId}:${netuid}`;
+const fetchDynamicInfoByNetuid = async (connector, networkId, miniMetadata, uniqueNetuids) => {
+  const fetchInfo = async netuid => {
+    if (netuid === SUBTENSOR_ROOT_NETUID) return null;
+    const cacheKey = getCacheKey(networkId, netuid);
+    if (!dynamicInfoCache.has(cacheKey)) {
+      await viem.withRetry(async () => {
+        const result = await fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "SubnetInfoRuntimeApi", "get_dynamic_info", [netuid]);
+        dynamicInfoCache.set(cacheKey, result); // Cache successful response
+
+        return result;
+      }, {
+        delay: 500,
+        retryCount: 3
+      });
+    }
+    return dynamicInfoCache.get(cacheKey) ?? null;
+  };
+  const results = await Promise.all(uniqueNetuids.map(async netuid => [netuid, await fetchInfo(netuid)]));
+  return lodash.fromPairs(results);
+};
+
+const getOtherType = input => `other-${input}`;
+
+/**
+ * For converting the value of `lock?.id?.toUtf8?.()` which is retrieved from
+ * the Balances.Locks storage key into a useful classification for our UI
+ */
+const getLockedType = input => {
+  if (typeof input !== "string") return getOtherType("unknown");
+  if (input.includes("vesting")) return "vesting";
+  if (input.includes("calamvst")) return "vesting"; // vesting on manta network
+  if (input.includes("ormlvest")) return "vesting"; // vesting ORML tokens
+  if (input.includes("pyconvot")) return "democracy";
+  if (input.includes("democrac")) return "democracy";
+  if (input.includes("democracy")) return "democracy";
+  if (input.includes("phrelect")) return "democracy"; // specific to council
+  if (input.includes("staking")) return "staking";
+  if (input.includes("stkngdel")) return "staking"; // staking delegator
+  if (input.includes("stkngcol")) return "staking"; // staking collator
+  if (input.includes("kiltpstk")) return "staking"; // Kilt specific staking
+  if (input.includes("dapstake")) return "dapp-staking"; // Astar specific
+  if (input.includes("appstake")) return "dapp-staking"; // Quartz (unique) specific
+  if (input.includes("dappstaking")) return "dapp-staking";
+
+  // Joystream specifics https://github.com/Joystream/pioneer/blob/dev/packages/ui/src/accounts/model/lockTypes.ts
+  if (input.includes("voting")) return "democracy";
+  if (input.includes("candidac")) return "democracy"; // Council Candidate
+  if (input.includes("councilo")) return "democracy"; // Councilor
+  if (input.includes("proposal")) return "democracy";
+  if (input.includes("boundsta")) return "staking"; // Bound Staking Account
+  if (input.includes("invitemb")) return getOtherType(input); // Invite member
+  if (input.includes("bounty")) return getOtherType(input);
+  if (input.startsWith("wg-")) return getOtherType(input);
+
+  // ignore technical or undocumented lock types
+  if (input.includes("pdexlock")) return getOtherType(input);
+  if (input.includes("phala/sp")) return getOtherType(input);
+  if (input.includes("aca/earn")) return getOtherType(input);
+  if (input.includes("stk_stks")) return getOtherType(input);
+
+  // eslint-disable-next-line no-console
+  console.warn(`unknown locked type: ${input}`);
+  return getOtherType(input);
+};
+
+const buildBaseQueries = (networkId, balanceDefs, miniMetadata) => {
+  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
+    account: ["System", "Account"],
+    stakingLedger: ["Staking", "Ledger"],
+    reserves: ["Balances", "Reserves"],
+    // unused ??
+    holds: ["Balances", "Holds"],
+    locks: ["Balances", "Locks"],
+    freezes: ["Balances", "Freezes"],
+    poolMembers: ["NominationPools", "PoolMembers"]
+  });
+  if (!networkStorageCoders) throw new Error(`No network storage coders found for networkId: ${networkId}`);
+  return balanceDefs.map(({
+    token,
+    address
+  }) => {
+    const accountStateKey = networkStorageCoders.account ? networkStorageCoders.account.keys.enc(address) : null;
+    const locksStateKey = networkStorageCoders.locks ? networkStorageCoders.locks.keys.enc(address) : null;
+    const freezesStateKey = networkStorageCoders.freezes ? networkStorageCoders.freezes.keys.enc(address) : null;
+    const holdsStateKey = networkStorageCoders.holds ? networkStorageCoders.holds.keys.enc(address) : null;
+    const stakingLedgerStateKey = networkStorageCoders.stakingLedger ? networkStorageCoders.stakingLedger.keys.enc(address) : null;
+    const poolMemberStateKey = networkStorageCoders.poolMembers ? networkStorageCoders.poolMembers.keys.enc(address) : null;
+    const stateKeys = [accountStateKey, locksStateKey, freezesStateKey, holdsStateKey, stakingLedgerStateKey, poolMemberStateKey];
+    return {
+      stateKeys,
+      decodeResult: changes => {
+        const balance = {
+          source: "substrate-native",
+          status: "live",
+          address,
+          networkId,
+          tokenId: token.id,
+          values: [],
+          useLegacyTransferableCalculation: miniMetadata.extra.useLegacyTransferableCalculation
+        };
+        let nomPoolMemberInfo = null;
+        const [accountChange, lockChange, freezesChange, holdsChange, stakingLedgerChange, nomPoolMemberChange] = changes;
+        if (networkStorageCoders.account) {
+          // for account balance we decode even empty values
+          const baseValues = decodeBaseResult(networkStorageCoders.account, accountChange, networkId);
+          balance.values.push(...baseValues);
+        }
+        if (networkStorageCoders.locks && lockChange) {
+          const lockValues = decodeLocksResult(networkStorageCoders.locks, lockChange, networkId);
+          balance.values.push(...lockValues);
+        }
+        if (networkStorageCoders.freezes && freezesChange) {
+          const freezesValues = decodeFreezesResult(networkStorageCoders.freezes, freezesChange, networkId);
+          balance.values.push(...freezesValues);
+        }
+        if (networkStorageCoders.holds && holdsChange) {
+          const holdsValues = decodeHoldsResult(networkStorageCoders.holds, holdsChange, networkId);
+          balance.values.push(...holdsValues);
+        }
+        if (networkStorageCoders.stakingLedger && stakingLedgerChange) {
+          const stakingLedgerValues = decodeStakingLedgerResult(networkStorageCoders.stakingLedger, stakingLedgerChange, networkId);
+          balance.values.push(...stakingLedgerValues);
+        }
+        if (networkStorageCoders.poolMembers && nomPoolMemberChange) {
+          const nomPoolMemberValue = decodePoolMemberResult(networkStorageCoders.poolMembers, nomPoolMemberChange, networkId);
+          if (nomPoolMemberValue) nomPoolMemberInfo = nomPoolMemberValue;
+        }
+        return {
+          balance,
+          nomPoolMemberInfo
+        };
+      }
+    };
+  }).filter(util.isNotNil);
+};
+
+// AccountInfo is the state_storage data format for nativeToken balances
+// Theory: new chains will be at least on metadata v14, and so we won't need to hardcode their AccountInfo type.
+// But for chains we want to support which aren't on metadata v14, hardcode them here:
+// If the chain upgrades to metadata v14, this override will be ignored :)
+// const RegularAccountInfoFallback = Struct({
+//   nonce: u32,
+//   consumers: u32,
+//   providers: u32,
+//   sufficients: u32,
+//   data: Struct({ free: u128, reserved: u128, miscFrozen: u128, feeFrozen: u128 }),
+// })
+// const NoSufficientsAccountInfoFallback = Struct({
+//   nonce: u32,
+//   consumers: u32,
+//   providers: u32,
+//   data: Struct({ free: u128, reserved: u128, miscFrozen: u128, feeFrozen: u128 }),
+// })
+// const AccountInfoOverrides: Record<
+//   string,
+//   typeof RegularAccountInfoFallback | typeof NoSufficientsAccountInfoFallback | undefined
+// > = {
+//   // crown-sterlin is not yet on metadata v14
+//   "crown-sterling": NoSufficientsAccountInfoFallback,
+
+//   // crust is not yet on metadata v14
+//   "crust": NoSufficientsAccountInfoFallback,
+
+//   // kulupu is not yet on metadata v14
+//   "kulupu": RegularAccountInfoFallback,
+
+//   // nftmart is not yet on metadata v14
+//   "nftmart": RegularAccountInfoFallback,
+// }
+
+const decodeBaseResult = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode base native balance on chain ${networkId}`);
+  const free = (decoded?.data?.free ?? 0n).toString();
+  const reserved = (decoded?.data?.reserved ?? 0n).toString();
+  const miscLock = ((decoded?.data?.miscFrozen ?? 0n) + (
+  // new chains don't split their `frozen` amount into `feeFrozen` and `miscFrozen`.
+  // for these chains, we'll use the `frozen` amount as `miscFrozen`.
+  decoded?.data?.frozen ?? 0n)).toString();
+  const feesLock = (decoded?.data?.feeFrozen ?? 0n).toString();
+
+  // even if these values are 0, we still need to add them to the balanceJson.values array
+  // so that the balance pool can handle newly zeroed balances
+  // const existingValues = Object.fromEntries(
+  //   balanceJson.values.map((v) => [getValueId(v), v]),
+  // )
+  const newValues = [{
+    type: "free",
+    label: "free",
+    amount: free.toString()
+  }, {
+    type: "reserved",
+    label: "reserved",
+    amount: reserved.toString()
+  }, {
+    type: "locked",
+    label: "misc",
+    amount: miscLock.toString()
+  }, {
+    type: "locked",
+    label: "fees",
+    amount: feesLock.toString()
+  }];
+  return newValues;
+};
+const decodeLocksResult = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode lock on chain ${networkId}`);
+  const locksQueryLocks = decoded?.map?.(lock => ({
+    type: "locked",
+    source: "substrate-native-locks",
+    label: getLockedType(lock?.id?.asText?.()),
+    meta: {
+      id: lock?.id?.asText?.()
+    },
+    amount: (lock?.amount ?? 0n).toString()
+  })) ?? [];
+  return locksQueryLocks;
+
+  // // locked values should be replaced entirely, not merged or appended
+  // const nonLockValues = balanceJson.values.filter(
+  //   (v) => v.source !== "substrate-native-locks",
+  // )
+  // balanceJson.values = nonLockValues.concat(locksQueryLocks)
+
+  // // fix any double-counting between Balances.Locks (for staking locks) and Staking.Ledger (for unbonding locks)
+  // balanceJson.values = updateStakingLocksUsingUnbondingLocks(balanceJson.values)
+};
+const decodeFreezesResult = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode freeze on chain ${networkId}`);
+  const freezesValues = decoded?.map?.(lock => ({
+    type: "locked",
+    source: "substrate-native-freezes",
+    label: getLockedType(lock?.id?.type?.toLowerCase?.()),
+    amount: lock?.amount?.toString?.() ?? "0"
+  })) ?? [];
+  return freezesValues;
+
+  // // freezes values should be replaced entirely, not merged or appended
+  // const nonFreezesValues = balanceJson.values.filter(
+  //   (v) => v.source !== "substrate-native-freezes",
+  // )
+  // balanceJson.values = nonFreezesValues.concat(freezesQueryLocks)
+
+  // return balanceJson
+};
+const decodeHoldsResult = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode holds on chain ${networkId}`);
+
+  // at this time we re only interested in DelegatedStaking holds, to determine if nom pool staked amount is included in reserved or not
+  const holdsValues = decoded?.filter(hold => hold.id?.type).map(hold => ({
+    type: "locked",
+    source: "substrate-native-holds",
+    label: hold.id.type,
+    // anount needs to be 0 or a row could appear in the UI, this entry is just for information
+    amount: "0",
+    meta: {
+      amount: (hold?.amount ?? 0n).toString()
+    }
+  })) ?? [];
+  return holdsValues;
+
+  // // values should be replaced entirely, not merged or appended
+  // const nonHoldsValues = balanceJson.values.filter(
+  //   (v) => v.source !== "substrate-native-holds",
+  // )
+  // balanceJson.values = nonHoldsValues.concat(holdsQueryLocks)
+
+  // return balanceJson
+};
+const decodeStakingLedgerResult = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode unbonding query on chain ${networkId}`);
+  const totalUnlocking = decoded?.unlocking?.reduce?.((acc, unlocking) => acc + unlocking.value, 0n) ?? 0n;
+  const stakingLedgerResults = totalUnlocking <= 0n ? [] : [{
+    type: "locked",
+    source: "substrate-native-unbonding",
+    label: "Unbonding",
+    amount: totalUnlocking.toString()
+  }];
+  return stakingLedgerResults;
+
+  // if (totalUnlocking <= 0n) unbondingQueryLocks = []
+  // else {
+  //   unbondingQueryLocks = [
+  //     {
+  //       type: "locked",
+  //       source: "substrate-native-unbonding",
+  //       label: "Unbonding",
+  //       amount: totalUnlocking.toString(),
+  //     },
+  //   ]
+  // }
+
+  // // unbonding values should be replaced entirely, not merged or appended
+  // const nonUnbondingValues = balanceJson.values.filter(
+  //   (v) => v.source !== "substrate-native-unbonding",
+  // )
+  // balanceJson.values = nonUnbondingValues.concat(unbondingQueryLocks)
+
+  // // fix any double-counting between Balances.Locks (for staking locks) and Staking.Ledger (for unbonding locks)
+  // balanceJson.values = updateStakingLocksUsingUnbondingLocks(balanceJson.values)
+
+  // return balanceJson
+};
+const decodePoolMemberResult = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode poolMembers on chain ${networkId}`);
+  if (!decoded) return null;
+  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 {
+    poolId,
+    points,
+    unbondingEras
+  };
+};
+
+// const getBaseQuery = (
+//   networkId: string,
+//   address: string,
+//   coder: ScaleStorageCoder,
+// ): RpcStateQuery<Array<AmountWithLabel<string>>> | null => {
+//   // For chains which are using metadata < v14
+//   const getFallbackStateKey = () => {
+//     const addressBytes = decodeAnyAddress(address) // TODO replace with modern api, this is slow
+//     const addressHash = blake2Concat(addressBytes).replace(/^0x/, "")
+//     const moduleHash = "26aa394eea5630e07c48ae0c9558cef7" // util_crypto.xxhashAsHex("System", 128);
+//     const storageHash = "b99d880ec681799c0cf30e8886371da9" // util_crypto.xxhashAsHex("Account", 128);
+//     const moduleStorageHash = `${moduleHash}${storageHash}` // System.Account is the state_storage key prefix for nativeToken balances
+//     return `0x${moduleStorageHash}${addressHash}`
+//   }
+
+//   // const scaleCoder = chainStorageCoders.get(chainId)?.base
+//   // NOTE: Only use fallback key when `scaleCoder` is not defined
+//   // i.e. when chain doesn't have metadata v14/v15
+//   const stateKey = coder
+//     ? encodeStateKey(coder, `Invalid address in ${networkId} base query ${address}`, address)
+//     : getFallbackStateKey()
+//   if (!stateKey) return null
+
+//   const decodeResult = (change: string | null) => {
+//     // BEGIN: Handle chains which use metadata < v14
+//     let oldChainBalance = null
+//     if (!coder) {
+//       const scaleAccountInfo = AccountInfoOverrides[networkId]
+//       if (scaleAccountInfo === undefined) {
+//         // chain metadata version is < 15 and we also don't have an override hardcoded in
+//         // the best way to handle this case: log a warning and return an empty balance
+//         log.debug(
+//           `Native token on chain ${networkId} has no balance type for decoding. Defaulting to a balance of 0 (zero).`,
+//         )
+//         return []
+//       }
+
+//       try {
+//         // eslint-disable-next-line no-var
+//         oldChainBalance = change === null ? null : scaleAccountInfo.dec(change)
+//       } catch (error) {
+//         log.warn(
+//           `Failed to create pre-metadataV14 balance type for native on chain ${networkId}: ${error?.toString()}`,
+//         )
+//         return []
+//       }
+//     }
+//     // END: Handle chains which use metadata < v14
+
+//     /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+//     type DecodedType = {
+//       data?: {
+//         flags?: bigint
+//         free?: bigint
+//         frozen?: bigint
+//         reserved?: bigint
+
+//         // deprecated fields (they only show up on old chains)
+//         feeFrozen?: bigint
+//         miscFrozen?: bigint
+//       }
+//     }
+//     const decoded =
+//       decodeScale<DecodedType>(
+//         coder,
+//         change,
+//         `Failed to decode base native balance on chain ${networkId}`,
+//       ) ?? oldChainBalance
+
+//     const free = (decoded?.data?.free ?? 0n).toString()
+//     const reserved = (decoded?.data?.reserved ?? 0n).toString()
+//     const miscLock = (
+//       (decoded?.data?.miscFrozen ?? 0n) +
+//       // new chains don't split their `frozen` amount into `feeFrozen` and `miscFrozen`.
+//       // for these chains, we'll use the `frozen` amount as `miscFrozen`.
+//       ((decoded?.data as DecodedType["data"])?.frozen ?? 0n)
+//     ).toString()
+//     const feesLock = (decoded?.data?.feeFrozen ?? 0n).toString()
+
+//     // even if these values are 0, we still need to add them to the balanceJson.values array
+//     // so that the balance pool can handle newly zeroed balances
+//     // const existingValues = Object.fromEntries(
+//     //   balanceJson.values.map((v) => [getValueId(v), v]),
+//     // )
+//     const newValues: AmountWithLabel<string>[] = [
+//       { type: "free", label: "free", amount: free.toString() },
+//       { type: "reserved", label: "reserved", amount: reserved.toString() },
+//       { type: "locked", label: "misc", amount: miscLock.toString() },
+//       { type: "locked", label: "fees", amount: feesLock.toString() },
+//     ]
+
+//     return newValues
+
+//     // const newValuesObj = Object.fromEntries(newValues.map((v) => [getValueId(v), v]))
+
+//     // balanceJson.values = Object.values({ ...existingValues, ...newValuesObj })
+
+//     // return balanceJson
+//   }
+
+//   return { chainId: networkId, stateKey, decodeResult }
+// }
+
+/**
+ * Each nominationPool in the nominationPools pallet has access to some accountIds which have no
+ * associated private key. Instead, they are derived from this function.
+ */
+const nompoolAccountId = (palletId, poolId, index) => {
+  const utf8Encoder = new TextEncoder();
+  const encModPrefix = utf8Encoder.encode("modl");
+  const encPalletId = utf8Encoder.encode(palletId);
+  const encIndex = new Uint8Array([index]);
+  const encPoolId = scaleTs.u32.enc(typeof poolId === "string" ? parseInt(poolId, 10) : poolId);
+  const length = encModPrefix.length + encPalletId.length + encIndex.length + encPoolId.length;
+  const remainingBytes = 32 - length;
+  const encEmptyH256 = new Uint8Array(remainingBytes);
+  const bytes = utils.mergeUint8([encModPrefix, encPalletId, encIndex, encPoolId, encEmptyH256]);
+  return polkadotApi.AccountId().dec(bytes);
+};
+/** The stash account for the nomination pool */
+const nompoolStashAccountId = (palletId, poolId) => nompoolAccountId(palletId, poolId, 0);
+
+const buildNomPoolQueries = (networkId, partialBalances, miniMetadata) => {
+  const networkStorageCoders = getNomPoolCoders(networkId, miniMetadata);
+  if (!networkStorageCoders) throw new Error(`No network storage coders found for networkId: ${networkId}`);
+  return partialBalances.map(({
+    balance,
+    nomPoolMemberInfo
+  }) => {
+    const stateKeys = getNomPoolStateKeys(networkStorageCoders, nomPoolMemberInfo, miniMetadata.extra);
+    return {
+      stateKeys,
+      decodeResult: changes => {
+        if (!nomPoolMemberInfo || !stateKeys.length || changes.includes(null)) return balance;
+        const accountPoints = nomPoolMemberInfo?.points ?? "0";
+        const {
+          poolPoints = "0"
+        } = decodePoolPoints(networkStorageCoders.bondedPools, changes[0], networkId);
+        const {
+          poolTotalActiveStake = "0"
+        } = decodePoolStake(networkStorageCoders.ledger, changes[1], networkId);
+        const {
+          metadata = "0"
+        } = decodePoolMeta(networkStorageCoders.metadata, changes[2], networkId);
+        const amount = accountPoints === "0" || poolPoints === "0" || poolTotalActiveStake === "0" ? 0n : BigInt(poolTotalActiveStake) * BigInt(accountPoints) / BigInt(poolPoints);
+        const unbondingAmount = nomPoolMemberInfo.unbondingEras.reduce((total, {
+          amount
+        }) => total + BigInt(amount ?? "0"), 0n);
+        return {
+          ...balance,
+          values: [...(balance.values ?? []), {
+            source: "nompools-staking",
+            type: "nompool",
+            label: "nompools-staking",
+            amount: amount.toString(),
+            meta: {
+              type: "nompool",
+              poolId: nomPoolMemberInfo.poolId,
+              description: metadata
+            }
+          }, {
+            source: "nompools-staking",
+            type: "nompool",
+            label: "nompools-unbonding",
+            amount: unbondingAmount.toString(),
+            meta: {
+              poolId: nomPoolMemberInfo.poolId,
+              description: metadata ?? `Pool ${nomPoolMemberInfo.poolId}`,
+              unbonding: true
+            }
+          }]
+        };
+      }
+    };
+  });
+};
+const getNomPoolCoders = (networkId, miniMetadata) => {
+  return buildNetworkStorageCoders(networkId, miniMetadata, {
+    poolMembers: ["NominationPools", "PoolMembers"],
+    bondedPools: ["NominationPools", "BondedPools"],
+    ledger: ["Staking", "Ledger"],
+    metadata: ["NominationPools", "Metadata"]
+  });
+};
+const decodePoolPoints = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode bondedPools on chain ${networkId}`);
+  return {
+    poolPoints: decoded?.points.toString()
+  };
+};
+const decodePoolStake = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode ledger on chain ${networkId}`);
+  return {
+    poolTotalActiveStake: decoded?.active.toString()
+  };
+};
+const decodePoolMeta = (coder, value, networkId) => {
+  /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+  const decoded = scale.decodeScale(coder, value, `Failed to decode metadata on chain ${networkId}`);
+  const metadata = decoded?.asText();
+  return {
+    metadata
+  };
+};
+const getNomPoolStateKeys = (coders, nomPoolMemberInfo, extra) => {
+  if (!nomPoolMemberInfo || !extra.nominationPoolsPalletId || !coders?.bondedPools || !coders.ledger || !coders.metadata) return [];
+  const poolId = nomPoolMemberInfo.poolId;
+  const stashAddress = nompoolStashAccountId(extra.nominationPoolsPalletId, poolId);
+  const poolPointsStateKey = coders.bondedPools.keys.enc(poolId);
+  const poolStakeStateKey = coders.ledger.keys.enc(stashAddress);
+  const poolMetaStateKey = coders.metadata.keys.enc(poolId);
+  return [poolPointsStateKey, poolStakeStateKey, poolMetaStateKey];
+};
+
+const fetchBalances$2 = async ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (!miniMetadata?.data) {
+    log.warn("MiniMetadata is required for fetching balances");
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE$2) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$2}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$2}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$2}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const queries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
+  const partialBalances = await fetchQueriesPack(connector, networkId, queries);
+
+  // now for each balance that includes nomPoolStaking, we need to fetch the metadata for the pool
+  const nomPoolQueries = buildNomPoolQueries(networkId, partialBalances, miniMetadata);
+  const balances = await fetchQueriesPack(connector, networkId, nomPoolQueries);
+
+  // TODO ⚠️ dedupe locks
+
+  const subtensorBalances$ = getSubtensorStakingBalances$(connector, networkId, balanceDefs, miniMetadata);
+  const subtensorBalancesByAddress = await rxjs.firstValueFrom(subtensorBalances$);
+  for (const [address, subtensorBalances] of Object.entries(subtensorBalancesByAddress)) {
+    const balance = balances.find(b => b.address === address);
+    if (balance?.values) balance.values.push(...subtensorBalances);
+  }
+  return {
+    success: balances,
+    errors: []
+  };
+};
+
+const fetchTokens$2 = async ({
+  networkId,
+  tokens,
+  connector,
+  miniMetadata
+}) => {
+  if (miniMetadata.extra.disable) return [];
+  const {
+    tokenSymbol: symbol,
+    tokenDecimals: decimals
+  } = await getChainProperties(connector, networkId);
+  if (!miniMetadata.extra.existentialDeposit) log.warn(`Substrate native module: existentialDeposit is undefined for ${networkId}, using 0`);
+  const tokenConfig = tokens[0];
+  const nativeToken = {
+    id: chaindataProvider.subNativeTokenId(networkId),
+    type: "substrate-native",
+    platform: "polkadot",
+    networkId,
+    isDefault: true,
+    symbol: symbol,
+    name: symbol,
+    decimals: decimals,
+    existentialDeposit: miniMetadata.extra.existentialDeposit ?? "0"
+  };
+  return [lodash.assign(nativeToken, tokenConfig)];
+};
+const DotNetworkPropertiesSimple = z__default.default.object({
+  tokenDecimals: z__default.default.number().optional().default(0),
+  tokenSymbol: z__default.default.string().optional().default("Unit")
+});
+const DotNetworkPropertiesArray = z__default.default.object({
+  tokenDecimals: z__default.default.array(z__default.default.number()).nonempty(),
+  tokenSymbol: z__default.default.array(z__default.default.string()).nonempty()
+});
+const DotNetworkPropertiesSchema = z__default.default.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 (connector, networkId) => {
+  const properties = await connector.send(networkId, "system_properties", [], true);
+  return DotNetworkPropertiesSchema.parse(properties);
+};
+
+const getMiniMetadata$2 = ({
+  networkId,
+  specVersion,
+  metadataRpc,
+  config
+}) => {
+  const source = MODULE_TYPE$2;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) log.warn("specVersion mismatch", {
+    networkId,
+    specVersion,
+    systemVersion
+  });
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    metadata,
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  if (config?.disable) return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: null,
+    extra: {
+      disable: true
+    }
+  };
+  const existentialDeposit = tryGetConstantValue(metadataRpc, "Balances", "ExistentialDeposit")?.toString();
+  const nominationPoolsPalletId = tryGetConstantValue(metadataRpc, "NominationPools", "PalletId")?.asText();
+  const hasSubtensorPallet = !!tryGetConstantValue(metadataRpc, "SubtensorModule", "KeySwapCost");
+  const hasFreezesItem = Boolean(unifiedMetadata.pallets.find(({
+    name
+  }) => name === "Balances")?.storage?.items.find(({
+    name
+  }) => name === "Freezes"));
+  const useLegacyTransferableCalculation = !hasFreezesItem;
+  scale.compactMetadata(metadata, [{
+    pallet: "System",
+    constants: ["Version", "SS58Prefix"],
+    items: ["Account"]
+  }, {
+    pallet: "Balances",
+    items: ["Reserves", "Holds", "Locks", "Freezes"]
+  }, {
+    pallet: "NominationPools",
+    items: ["PoolMembers", "BondedPools", "Metadata"]
+  }, {
+    pallet: "Staking",
+    items: ["Ledger"]
+  },
+  // 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"]
+  }], [{
+    runtimeApi: "StakeInfoRuntimeApi",
+    methods: ["get_stake_info_for_coldkey"]
+  }, {
+    runtimeApi: "SubnetInfoRuntimeApi",
+    methods: ["get_dynamic_info"]
+  }]);
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: scale.encodeMetadata(metadata),
+    extra: {
+      useLegacyTransferableCalculation,
+      existentialDeposit,
+      nominationPoolsPalletId,
+      hasSubtensorPallet
+    }
+  };
+};
+
+const getTransferCallData$2 = ({
+  from,
+  to,
+  value,
+  token,
+  type,
+  metadataRpc
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$2)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$2}.`);
+  const {
+    unifiedMetadata,
+    lookupFn,
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const method = getTransferMethod$1(type, unifiedMetadata, lookupFn);
+  const {
+    codec,
+    location
+  } = builder.buildCall("Balances", method);
+  const args = getEncodedArgs(method, to, value, codec);
+  const callData = polkadotApi.Binary.fromBytes(utils.mergeUint8([new Uint8Array(location), args]));
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+const getTransferMethod$1 = (type, unifiedMetadata, lookupFn) => {
+  switch (type) {
+    case "keep-alive":
+      return "transfer_keep_alive";
+    case "all":
+      return "transfer_all";
+    case "allow-death":
+      {
+        const callType = unifiedMetadata.pallets.find(pallet => pallet.name === "Balances")?.calls?.type;
+        if (callType) {
+          const palletCalls = lookupFn(callType);
+          if (palletCalls.type === "enum" && palletCalls.value["transfer_allow_death"]) return "transfer_allow_death";
+        }
+
+        // legacy fallback
+        return "transfer";
+      }
+  }
+};
+const getEncodedArgs = (method, to, value, argsCodec) => {
+  try {
+    switch (method) {
+      case "transfer_allow_death":
+      case "transfer_keep_alive":
+      case "transfer":
+        return getTransferEncodedArgs(to, value, argsCodec);
+      case "transfer_all":
+        return getTransferAllEncodedArgs(to, argsCodec);
+    }
+  } catch {
+    throw new Error(`Failed to encode arguments for method ${method}, ${to}, ${value}`);
+  }
+};
+const getEncodedValue = (codec, possibleValue) => {
+  for (const getArgs of possibleValue) {
+    try {
+      return codec.enc(getArgs());
+    } catch {
+      // wrong inputs, ignore and try the next one
+    }
+  }
+  throw new Error("Failed to encode");
+};
+
+// same inputs for both KeepAlive and allowDeath
+const getTransferEncodedArgs = (to, value, codec) => {
+  return getEncodedValue(codec, [() => ({
+    dest: polkadotApi.Enum("Id", to),
+    value: BigInt(value)
+  })]);
+};
+const getTransferAllEncodedArgs = (to, codec) => {
+  return getEncodedValue(codec, [() => ({
+    dest: polkadotApi.Enum("Id", to),
+    keep_alive: false
+  })]);
+};
+
+const SUBSCRIPTION_INTERVAL$2 = 6_000;
+const subscribeBalances$2 = ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$2({
+          networkId,
+          addressesByToken,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$2,
+          networkId,
+          miniMetadata,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const SubNativeBalanceModule = {
+  type: MODULE_TYPE$2,
+  platform: PLATFORM$2,
+  getMiniMetadata: getMiniMetadata$2,
+  fetchTokens: fetchTokens$2,
+  fetchBalances: fetchBalances$2,
+  subscribeBalances: subscribeBalances$2,
+  getTransferCallData: getTransferCallData$2
+};
+
+const MODULE_TYPE$1 = chaindataProvider.SubPsp22TokenSchema.shape.type.value;
+const PLATFORM$1 = chaindataProvider.SubPsp22TokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  contractAddress: chaindataProvider.SubPsp22TokenSchema.shape.contractAddress,
+  ...TokenConfigBaseSchema.shape
+});
+
+const fetchBalances$1 = async ({
+  networkId,
+  addressesByToken,
+  connector
+}) => {
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (!balanceDefs.length) return {
+    success: [],
+    errors: []
+  };
+  const registry = new types.TypeRegistry();
+  const Psp22Abi = new apiContract.Abi(psp22Abi);
+  const contractCall = makeContractCaller({
+    chainConnector: connector,
+    chainId: networkId,
+    registry
+  });
+  const results = await Promise.allSettled(balanceDefs.map(async ({
+    token,
+    address
+  }) => {
+    const result = await contractCall(address, token.contractAddress, Psp22Abi.findMessage("PSP22::balance_of").toU8a([address]));
+    if (!result.result.isOk) throw new Error("Failed to fetch balance");
+    const value = registry.createType("Balance", result.result.asOk.data).toString();
+    const balance = {
+      source: "substrate-psp22",
+      status: "live",
+      address,
+      networkId: token.networkId,
+      tokenId: token.id,
+      value
+    };
+    return balance;
+  }));
+  return results.reduce((acc, result) => {
+    if (result.status === "fulfilled") acc.success.push(result.value);else {
+      const error = result.reason;
+      acc.errors.push({
+        tokenId: error.tokenId,
+        address: error.address,
+        error
+      });
+    }
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+
+const fetchTokens$1 = async ({
+  networkId,
+  tokens,
+  connector
+}) => {
+  if (!tokens.length) return [];
+  const registry = new types.TypeRegistry();
+  const Psp22Abi = new apiContract.Abi(psp22Abi);
+
+  // TODO: Use `decodeOutput` from `./util/decodeOutput`
+  const contractCall = makeContractCaller({
+    chainConnector: connector,
+    chainId: networkId,
+    registry
+  });
+  const tokenList = {};
+  for (const tokenConfig of tokens ?? []) {
+    try {
+      let symbol = tokenConfig?.symbol ?? "Unit";
+      let decimals = tokenConfig?.decimals ?? 0;
+      const contractAddress = tokenConfig?.contractAddress ?? undefined;
+      if (contractAddress === undefined) continue;
+      await (async () => {
+        const [symbolResult, decimalsResult] = await Promise.all([contractCall(contractAddress, contractAddress, Psp22Abi.findMessage("PSP22Metadata::token_symbol").toU8a([])), contractCall(contractAddress, contractAddress, Psp22Abi.findMessage("PSP22Metadata::token_decimals").toU8a([]))]);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const symbolData = symbolResult.toJSON()?.result?.ok?.data;
+        symbol = typeof symbolData === "string" && symbolData.startsWith("0x") ? util$1.u8aToString(registry.createType("Option<Vec<u8>>",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        symbolResult.toJSON()?.result?.ok?.data)?.value)?.replace(/\p{C}/gu, "") : symbol;
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const decimalsData = decimalsResult.toJSON()?.result?.ok?.data;
+        decimals = typeof decimalsData === "string" && decimalsData.startsWith("0x") ? util$1.hexToNumber(decimalsData) : decimals;
+      })();
+      const id = chaindataProvider.subPsp22TokenId(networkId, contractAddress);
+      const token = {
+        id,
+        type: "substrate-psp22",
+        platform: "polkadot",
+        isDefault: tokenConfig.isDefault ?? true,
+        symbol,
+        decimals,
+        name: tokenConfig?.name || symbol,
+        logo: tokenConfig?.logo,
+        contractAddress,
+        networkId
+      };
+      if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
+      if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
+      tokenList[token.id] = token;
+    } catch (error) {
+      log.error(`Failed to build substrate-psp22 token ${tokenConfig.contractAddress} (${tokenConfig.symbol}) on ${networkId}`, error?.message ?? error);
+      continue;
+    }
+  }
+  return lodash.values(tokenList).filter(t => {
+    const parsed = chaindataProvider.SubPsp22TokenSchema.safeParse(t);
+    if (!parsed.success) log.warn(`Ignoring invalid token ${MODULE_TYPE$1}`, t);
+    return parsed.success;
+  });
+};
+
+const getMiniMetadata$1 = ({
+  networkId,
+  specVersion,
+  metadataRpc
+}) => {
+  const source = MODULE_TYPE$1;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) log.warn("specVersion mismatch", {
+    networkId,
+    specVersion,
+    systemVersion
+  });
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: null,
+    extra: null
+  };
+};
+
+const getTransferCallData$1 = async ({
+  from,
+  to,
+  value,
+  token,
+  metadataRpc,
+  connector
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE$1)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$1}.`);
+  const networkId = chaindataProvider.parseTokenId(token.id).networkId;
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  const {
+    codec,
+    location
+  } = builder.buildCall("Contracts", "call");
+  const Psp22Abi = new apiContract.Abi(psp22Abi);
+  const registry = new types.TypeRegistry();
+  const contractCall = makeContractCaller({
+    chainConnector: connector,
+    chainId: networkId,
+    registry
+  });
+
+  // TODO use papi contract api
+  const data = Psp22Abi.findMessage("PSP22::transfer").toU8a([to, value, undefined]);
+  const hexData = registry.createType("Vec<u8>", data).toHex();
+  const dryRunResult = await contractCall(from, token.contractAddress, data);
+  const args = codec.enc({
+    dest: polkadotApi.Enum("Id", token.contractAddress),
+    value: 0,
+    gas_limit: {
+      ref_time: dryRunResult.gasRequired.refTime.toBigInt(),
+      proof_size: dryRunResult.gasRequired.proofSize.toBigInt()
+    },
+    storage_deposit_limit: dryRunResult.storageDeposit.isCharge ? dryRunResult.storageDeposit.asCharge.toBigInt() : null,
+    data: polkadotApi.Binary.fromHex(hexData)
+  });
+  const callData = polkadotApi.Binary.fromBytes(utils.mergeUint8([new Uint8Array(location), args]));
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$1 = 6_000;
+const subscribeBalances$1 = ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$1({
+          networkId,
+          addressesByToken,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$1);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$1,
+          networkId,
+          miniMetadata,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const SubPsp22BalanceModule = {
+  type: MODULE_TYPE$1,
+  platform: PLATFORM$1,
+  getMiniMetadata: getMiniMetadata$1,
+  fetchTokens: fetchTokens$1,
+  fetchBalances: fetchBalances$1,
+  subscribeBalances: subscribeBalances$1,
+  getTransferCallData: getTransferCallData$1
+};
+
+const MODULE_TYPE = chaindataProvider.SubTokensTokenSchema.shape.type.value;
+const PLATFORM = chaindataProvider.SubTokensTokenSchema.shape.platform.value;
+
+// to be used by chaindata too
+z__default.default.strictObject({
+  onChainId: chaindataProvider.SubTokensTokenSchema.shape.onChainId,
+  ...TokenConfigBaseSchema.shape,
+  // force these 3 fields because in this module we wont pull anything from chain
+  symbol: z__default.default.string().nonempty(),
+  decimals: z__default.default.number(),
+  existentialDeposit: z__default.default.string().nonempty()
+});
+
+// Do not use this type outside of this module
+
+// Do not use this type outside of this module
+
+const fetchBalances = async ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  const balanceDefs = getBalanceDefs(addressesByToken);
+  if (!miniMetadata?.data) {
+    log.warn("MiniMetadata is required for fetching balances");
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const queries = buildQueries(networkId, balanceDefs, miniMetadata);
+  const balances = await new RpcStateQueryHelper(connector, queries).fetch();
+  return balanceDefs.reduce((acc, def) => {
+    const balance = balances.find(b => b?.address === def.address && b?.tokenId === def.token.id);
+    if (balance) acc.success.push(balance);
+    //if no entry consider empty balance
+    else acc.success.push({
+      address: def.address,
+      networkId,
+      tokenId: def.token.id,
+      source: MODULE_TYPE,
+      status: "live",
+      values: [{
+        type: "free",
+        label: "free",
+        amount: "0"
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: "0"
+      }]
+    });
+    return acc;
+  }, {
+    success: [],
+    errors: []
+  });
+};
+const buildQueries = (networkId, balanceDefs, miniMetadata) => {
+  const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
+    storage: [miniMetadata.extra.palletId, "Accounts"]
+  });
+  return balanceDefs.map(({
+    token,
+    address
+  }) => {
+    const scaleCoder = networkStorageCoders?.storage;
+    const getStateKey = onChainId => {
+      try {
+        return scaleCoder.keys.enc(address, scale.papiParse(onChainId));
+      } catch {
+        return null;
+      }
+    };
+    const stateKey = getStateKey(token.onChainId);
+    if (!stateKey) {
+      log.warn(`Invalid assetId / address in ${networkId} storage query ${token.onChainId} / ${address}`);
+      return null;
+    }
+    const decodeResult = change => {
+      /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+      const decoded = scale.decodeScale(scaleCoder, change, `Failed to decode substrate-tokens balance on chain ${networkId}`) ?? {
+        free: 0n,
+        reserved: 0n,
+        frozen: 0n
+      };
+      const free = (decoded?.free ?? 0n).toString();
+      const reserved = (decoded?.reserved ?? 0n).toString();
+      const frozen = (decoded?.frozen ?? 0n).toString();
+      const balanceValues = [{
+        type: "free",
+        label: "free",
+        amount: free.toString()
+      }, {
+        type: "reserved",
+        label: "reserved",
+        amount: reserved.toString()
+      }, {
+        type: "locked",
+        label: "frozen",
+        amount: frozen.toString()
+      }];
+      return {
+        source: "substrate-tokens",
+        status: "live",
+        address,
+        networkId,
+        tokenId: token.id,
+        values: balanceValues
+      };
+    };
+    return {
+      chainId: networkId,
+      stateKey,
+      decodeResult
+    };
+  }).filter(util.isNotNil);
+};
+
+const fetchTokens = async ({
+  networkId,
+  tokens,
+  miniMetadata
+}) => {
+  if (!miniMetadata?.data) return [];
+
+  // in this module we do not fetch any token information from the chain
+  // this is because there are basically as many pallet implementations as there are networks (Expect Chaos, they said)
+  // we rely on the config to provide all the info we need
+  return tokens.map(tokenConfig => lodash.assign({
+    id: chaindataProvider.subTokensTokenId(networkId, tokenConfig.onChainId),
+    type: MODULE_TYPE,
+    platform: PLATFORM,
+    networkId,
+    onChainId: tokenConfig.onChainId,
+    symbol: tokenConfig.symbol ?? "Unit",
+    decimals: tokenConfig.decimals ?? 0,
+    name: tokenConfig.name ?? tokenConfig.symbol ?? "Unit",
+    existentialDeposit: tokenConfig.existentialDeposit ?? "0",
+    isDefault: true
+  }, tokenConfig));
+};
+
+const getMiniMetadata = ({
+  networkId,
+  specVersion,
+  metadataRpc,
+  config
+}) => {
+  const source = MODULE_TYPE;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) log.warn("specVersion mismatch", {
+    networkId,
+    specVersion,
+    systemVersion
+  });
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  const extra = {
+    palletId: config?.palletId ?? "Tokens"
+  };
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: chaindataProvider.MINIMETADATA_VERSION,
+    data: getData(metadataRpc, extra.palletId),
+    extra
+  };
+};
+const getData = (metadataRpc, pallet) => {
+  const {
+    metadata,
+    unifiedMetadata
+  } = scale.parseMetadataRpc(metadataRpc);
+
+  // ensure the network has all the required bits
+  if (!hasStorageItems(unifiedMetadata, pallet, ["Accounts"])) return null;
+  scale.compactMetadata(metadata, [{
+    pallet,
+    items: ["Accounts"]
+  }]);
+  return scale.encodeMetadata(metadata);
+};
+
+const getTransferCallData = ({
+  from,
+  to,
+  value,
+  token,
+  type,
+  metadataRpc,
+  config
+}) => {
+  if (!chaindataProvider.isTokenOfType(token, MODULE_TYPE)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE}.`);
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+
+  // each chain has its own way of encoding the transfer call data
+  // let's try our luck until one works!
+  const options = getCallDataOptions(to, token, value, type, config);
+  const callData = getCallDataFromOptions(builder, options);
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+const getTransferMethod = type => {
+  switch (type) {
+    case "keep-alive":
+      return "transfer_keep_alive";
+    case "all":
+      return "transfer_all";
+    case "allow-death":
+      return "transfer";
+  }
+};
+const getCallDataFromOptions = (builder, options) => {
+  for (const {
+    pallet,
+    method,
+    getArgs
+  } of options) {
+    try {
+      return buildCallData(builder, pallet, method, getArgs());
+    } catch {
+      // wrong inputs, ignore and try the next one
+    }
+  }
+  throw new Error("Failed to encode call data");
+};
+const buildCallData = (builder, pallet, method, args) => {
+  const {
+    location,
+    codec
+  } = builder.buildCall(pallet, method);
+  return polkadotApi.Binary.fromBytes(utils.mergeUint8([new Uint8Array(location), codec.enc(args)]));
+};
+const getCallDataOptions = (to, token, value, type, config) => {
+  const onChainId = scale.papiParse(token.onChainId);
+  const method = getTransferMethod(type);
+  return [{
+    pallet: "Currencies",
+    method: "transfer",
+    getArgs: () => ({
+      dest: polkadotApi.Enum("Id", to),
+      currency_id: onChainId,
+      amount: BigInt(value)
+    })
+  }, {
+    pallet: "Currencies",
+    method: "transfer",
+    getArgs: () => ({
+      dest: to,
+      currency_id: onChainId,
+      amount: BigInt(value)
+    })
+  }, {
+    pallet: "Tokens",
+    method,
+    getArgs: () => method === "transfer_all" ? {
+      dest: polkadotApi.Enum("Id", to),
+      currency_id: onChainId,
+      keepAlive: false
+    } : {
+      dest: polkadotApi.Enum("Id", to),
+      currency_id: onChainId,
+      amount: BigInt(value)
+    }
+  }, {
+    pallet: "Tokens",
+    method,
+    getArgs: () => method === "transfer_all" ? {
+      dest: to,
+      currency_id: onChainId,
+      keepAlive: false
+    } : {
+      dest: to,
+      currency_id: onChainId,
+      amount: BigInt(value)
+    }
+  }].concat(...(config?.palletId ? [{
+    pallet: config.palletId,
+    method,
+    getArgs: () => method === "transfer_all" ? {
+      dest: polkadotApi.Enum("Id", to),
+      currency_id: onChainId,
+      keepAlive: false
+    } : {
+      dest: polkadotApi.Enum("Id", to),
+      currency_id: onChainId,
+      amount: BigInt(value)
+    }
+  }, {
+    pallet: config.palletId,
+    method,
+    getArgs: () => method === "transfer_all" ? {
+      dest: to,
+      currency_id: onChainId,
+      keepAlive: false
+    } : {
+      dest: to,
+      currency_id: onChainId,
+      amount: BigInt(value)
+    }
+  }] : []));
+};
+
+const SUBSCRIPTION_INTERVAL = 6_000;
+const subscribeBalances = ({
+  networkId,
+  addressesByToken,
+  connector,
+  miniMetadata
+}) => {
+  return new rxjs.Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances({
+          networkId,
+          addressesByToken,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE,
+          networkId,
+          miniMetadata,
+          addressesByToken,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+};
+
+const SubTokensBalanceModule = {
+  type: MODULE_TYPE,
+  platform: PLATFORM,
+  getMiniMetadata,
+  fetchTokens,
+  fetchBalances,
+  subscribeBalances,
+  getTransferCallData
+};
+
+const NEW_BALANCE_MODULES = [SubNativeBalanceModule, SubAssetsBalanceModule, SubHydrationBalanceModule, SubForeignAssetsBalanceModule, SubPsp22BalanceModule, SubTokensBalanceModule, EvmErc20BalanceModule, EvmUniswapV2BalanceModule, EvmNativeBalanceModule];
+
+Object.defineProperty(exports, "MINIMETADATA_VERSION", {
+  enumerable: true,
+  get: function () { return chaindataProvider.MINIMETADATA_VERSION; }
+});
+Object.defineProperty(exports, "erc20Abi", {
+  enumerable: true,
+  get: function () { return viem.erc20Abi; }
+});
 exports.Balance = Balance;
 exports.BalanceFormatter = BalanceFormatter;
 exports.BalanceValueGetter = BalanceValueGetter;
@@ -6844,12 +10414,13 @@ exports.EvmNativeTokenConfigSchema = EvmNativeTokenConfigSchema;
 exports.EvmUniswapV2Module = EvmUniswapV2Module;
 exports.EvmUniswapV2TokenConfigSchema = EvmUniswapV2TokenConfigSchema;
 exports.FiatSumBalancesFormatter = FiatSumBalancesFormatter;
-exports.ONE_ALPHA_TOKEN = ONE_ALPHA_TOKEN;
+exports.NEW_BALANCE_MODULES = NEW_BALANCE_MODULES;
+exports.ONE_ALPHA_TOKEN = ONE_ALPHA_TOKEN$1;
 exports.PlanckSumBalancesFormatter = PlanckSumBalancesFormatter;
 exports.RpcStateQueryHelper = RpcStateQueryHelper;
-exports.SCALE_FACTOR = SCALE_FACTOR;
-exports.SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = SUBTENSOR_MIN_STAKE_AMOUNT_PLANK;
-exports.SUBTENSOR_ROOT_NETUID = SUBTENSOR_ROOT_NETUID;
+exports.SCALE_FACTOR = SCALE_FACTOR$1;
+exports.SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = SUBTENSOR_MIN_STAKE_AMOUNT_PLANK$1;
+exports.SUBTENSOR_ROOT_NETUID = SUBTENSOR_ROOT_NETUID$1;
 exports.SubAssetsModule = SubAssetsModule;
 exports.SubAssetsTokenConfigSchema = SubAssetsTokenConfigSchema;
 exports.SubForeignAssetsModule = SubForeignAssetsModule;
@@ -6866,9 +10437,9 @@ exports.abiMulticall = abiMulticall;
 exports.balances = balances;
 exports.buildNetworkStorageCoders = buildNetworkStorageCoders;
 exports.buildStorageCoders = buildStorageCoders;
-exports.calculateAlphaPrice = calculateAlphaPrice;
-exports.calculateTaoAmountFromAlpha = calculateTaoAmountFromAlpha;
-exports.calculateTaoFromDynamicInfo = calculateTaoFromDynamicInfo;
+exports.calculateAlphaPrice = calculateAlphaPrice$1;
+exports.calculateTaoAmountFromAlpha = calculateTaoAmountFromAlpha$1;
+exports.calculateTaoFromDynamicInfo = calculateTaoFromDynamicInfo$1;
 exports.compress = compress;
 exports.configureStore = configureStore;
 exports.db = db;
@@ -6877,7 +10448,6 @@ exports.decompress = decompress;
 exports.defaultBalanceModules = defaultBalanceModules;
 exports.deriveMiniMetadataId = deriveMiniMetadataId;
 exports.detectTransferMethod = detectTransferMethod;
-exports.erc20Abi = erc20Abi;
 exports.erc20BalancesAggregatorAbi = erc20BalancesAggregatorAbi;
 exports.excludeFromFeePayableLocks = excludeFromFeePayableLocks;
 exports.excludeFromTransferableAmount = excludeFromTransferableAmount;