@talismn/balances 0.0.0-pr2043-20250615092436 → 0.0.0-pr2043-20250617092446

package/dist/talismn-balances.esm.js

@@ -1,8 +1,5 @@
-import PromisePool$1, { PromisePool } from '@supercharge/promise-pool';
-import { fetchMiniMetadatas, fetchInitMiniMetadatas, availableTokenLogoFilenames, githubTokenLogoUrl, EvmErc20TokenSchema } from '@talismn/chaindata-provider';
-import { fetchBestMetadata, getScaleApi } from '@talismn/sapi';
+import { fetchInitMiniMetadatas, evmErc20TokenId as evmErc20TokenId$1, EvmErc20TokenSchema, evmNativeTokenId, evmUniswapV2TokenId, githubTokenLogoUrl, subAssetTokenId, subForeignAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId } from '@talismn/chaindata-provider';
 import { Dexie, liveQuery } from 'dexie';
-import isEqual from 'lodash/isEqual';
 import { from, Observable, scan, share, map, switchAll, combineLatest, mergeMap, toArray, interval, startWith, exhaustMap, pipe, filter, shareReplay, combineLatestWith, distinctUntilChanged, firstValueFrom, BehaviorSubject, debounceTime, takeUntil, switchMap, withLatestFrom, concatMap } from 'rxjs';
 import anylogger from 'anylogger';
 import { newTokenRates } from '@talismn/token-rates';
@@ -12,6 +9,7 @@ import { u8aToHex, assert, stringCamelCase, u8aConcatStrict, u8aConcat, arrayChu
 import { xxhashAsU8a, blake2AsU8a } from '@polkadot/util-crypto';
 import pako from 'pako';
 import { parseAbi, isHex, hexToBigInt } from 'viem';
+import isEqual from 'lodash/isEqual';
 import { defineMethod } from '@substrate/txwrapper-core';
 import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, getMetadataVersion, compactMetadata, encodeMetadata, decodeScale, papiParse, encodeStateKey } from '@talismn/scale';
 import camelCase from 'lodash/camelCase';
@@ -19,11 +17,12 @@ import { Metadata, TypeRegistry } from '@polkadot/types';
 import groupBy from 'lodash/groupBy';
 import { mergeUint8, toHex } from '@polkadot-api/utils';
 import { Binary, AccountId } from 'polkadot-api';
+import PromisePool from '@supercharge/promise-pool';
 import { ChainConnectionError } from '@talismn/chain-connector';
 import { u32, u128, Struct } from 'scale-ts';
+import { getScaleApi } from '@talismn/sapi';
 import upperFirst from 'lodash/upperFirst';
 import { Abi } from '@polkadot/api-contract';
-import { compressToEncodedURIComponent } from 'lz-string';
 
 // TODO: Document default balances module purpose/usage
 const DefaultBalanceModule = type => ({
@@ -58,8 +57,12 @@ const DefaultBalanceModule = type => ({
 // internal
 //
 
+// TODO yeet ?
+// there is no need to construct a lit of tokens, it's done by∏ chaindata
+
 /**
  * Fetches tokens for EVM networks.
+ * @deprecated
  */
 class EvmTokenFetcher {
   #chaindataProvider;
@@ -68,36 +71,46 @@ class EvmTokenFetcher {
     this.#chaindataProvider = chaindataProvider;
     this.#balanceModules = balanceModules;
   }
-  async update(evmNetworkIds) {
-    await this.updateEvmNetworks(evmNetworkIds);
-  }
-  async updateEvmNetworks(evmNetworkIds) {
-    const evmNetworks = new Map((await this.#chaindataProvider.evmNetworks()).map(evmNetwork => [evmNetwork.id, evmNetwork]));
-    const allEvmTokens = {};
-    const evmNetworkConcurrency = 10;
-    await PromisePool.withConcurrency(evmNetworkConcurrency).for(evmNetworkIds).process(async evmNetworkId => {
-      const evmNetwork = evmNetworks.get(evmNetworkId);
-      if (!evmNetwork) return;
-      for (const mod of this.#balanceModules.filter(m => m.type.startsWith("evm-"))) {
-        const balancesConfig = (evmNetwork.balancesConfig ?? []).find(({
-          moduleType
-        }) => moduleType === mod.type);
-        const moduleConfig = balancesConfig?.moduleConfig ?? {};
-
-        // chainMeta arg only needs the isTestnet property, let's save a db roundtrip for now
-        const isTestnet = evmNetwork.isTestnet ?? false;
-        const tokens = await mod.fetchEvmChainTokens(evmNetworkId, {
-          isTestnet
-        }, moduleConfig);
-        for (const [tokenId, token] of Object.entries(tokens)) allEvmTokens[tokenId] = token;
-      }
-    });
-    await this.#chaindataProvider.updateEvmNetworkTokens(Object.values(allEvmTokens));
+  async update(_evmNetworkIds) {
+    // chaindataProvider's tokens should be in sync already
+    // await this.updateEvmNetworks(evmNetworkIds)
   }
+
+  // private async updateEvmNetworks(evmNetworkIds: EvmNetworkId[]) {
+  //   // feels unnecessary, chaindataProvider's tokens should be in sync already
+  //   //   const evmNetworks = new Map(
+  //   //     (await this.#chaindataProvider.evmNetworks()).map((evmNetwork) => [
+  //   //       evmNetwork.id,
+  //   //       evmNetwork,
+  //   //     ]),
+  //   //   )
+  //   //   const allEvmTokens: TokenList = {}
+  //   //   const evmNetworkConcurrency = 10
+  //   //   await PromisePool.withConcurrency(evmNetworkConcurrency)
+  //   //     .for(evmNetworkIds)
+  //   //     .process(async (evmNetworkId) => {
+  //   //       const evmNetwork = evmNetworks.get(evmNetworkId)
+  //   //       if (!evmNetwork) return
+  //   //       for (const mod of this.#balanceModules.filter((m) => m.type.startsWith("evm-"))) {
+  //   //         // const balancesConfig = (evmNetwork.balancesConfig ?? []).find(
+  //   //         //   ({ moduleType }) => moduleType === mod.type,
+  //   //         // )
+  //   //         // const moduleConfig = balancesConfig?.moduleConfig ?? {}
+  //   //         // chainMeta arg only needs the isTestnet property, let's save a db roundtrip for now
+  //   //         const isTestnet = evmNetwork.isTestnet ?? false
+  //   //         const tokens = await mod.fetchEvmChainTokens(evmNetworkId, { isTestnet }, moduleConfig)
+  //   //         for (const [tokenId, token] of Object.entries(tokens)) allEvmTokens[tokenId] = token
+  //   //       }
+  //   //     })
+  //   //   await this.#chaindataProvider.updateEvmNetworkTokens(Object.values(allEvmTokens))
+  // }
 }
 
 var packageJson = {
-	name: "@talismn/balances"};
+	name: "@talismn/balances",
+	version: "0.0.0-pr2043-20250617092446"};
+
+const libVersion = packageJson.version;
 
 var log = anylogger(packageJson.name);
 
@@ -309,15 +322,20 @@ class Balances {
     return new SumBalancesFormatter(this);
   }
 }
-const isBalanceEvm = balance => "evmNetworkId" in balance;
+
+// type BalanceJsonEvm = BalanceJson & { evmNetworkId: string }
+
+// const isBalanceEvm = (balance: BalanceJson): balance is BalanceJsonEvm => "evmNetworkId" in balance
+
 const getBalanceId = balance => {
   const {
     source,
     address,
-    tokenId
+    tokenId,
+    networkId
   } = balance;
-  const locationId = isBalanceEvm(balance) ? balance.evmNetworkId : balance.chainId;
-  return [source, address, locationId, tokenId].filter(isTruthy).join("::");
+  //const locationId = isBalanceEvm(balance) ? balance.evmNetworkId : balance.chainId
+  return [source, address, networkId, tokenId].filter(isTruthy).join("::");
 };
 
 /**
@@ -379,17 +397,33 @@ class Balance {
   get address() {
     return this.#storage.address;
   }
-  get chainId() {
-    return isBalanceEvm(this.#storage) ? undefined : this.#storage.chainId;
-  }
-  get chain() {
-    return this.#db?.chains && this.chainId && this.#db?.chains[this.chainId] || null;
-  }
-  get evmNetworkId() {
-    return isBalanceEvm(this.#storage) ? this.#storage.evmNetworkId : undefined;
+
+  // /** @deprecated */
+  // get chainId() {
+  //   return isBalanceEvm(this.#storage) ? undefined : this.#storage.chainId
+  // }
+  // /** @deprecated */
+  // get chain() {
+  //   return (this.#db?.networks && this.networkId && this.#db?.networks[this.networkId]) || null
+  // }
+
+  // /** @deprecated */
+  // get evmNetworkId() {
+  //   return isBalanceEvm(this.#storage) ? this.#storage.evmNetworkId : undefined
+  // }
+  // /** @deprecated */
+  // get evmNetwork() {
+  //   return (
+  //     (this.#db?.networks && this.networkId && this.#db?.networks[this.networkId]) ||
+  //     null
+  //   )
+  // }
+
+  get networkId() {
+    return this.#storage.networkId;
   }
-  get evmNetwork() {
-    return this.#db?.evmNetworks && this.evmNetworkId && this.#db?.evmNetworks[this.evmNetworkId] || null;
+  get network() {
+    return this.#db?.networks && this.networkId && this.#db?.networks[this.networkId] || null;
   }
   get tokenId() {
     return this.#storage.tokenId;
@@ -408,9 +442,11 @@ class Balance {
     //
     // This means that those rates are always available for calculating the uniswapv2 rates,
     // regardless of whether or not the underlying erc20s are actually in chaindata and enabled.
-    if (this.isSource("evm-uniswapv2") && this.token?.type === "evm-uniswapv2" && this.evmNetworkId) {
-      const tokenId0 = evmErc20TokenId$1(this.evmNetworkId, this.token.tokenAddress0);
-      const tokenId1 = evmErc20TokenId$1(this.evmNetworkId, this.token.tokenAddress1);
+    if (this.isSource("evm-uniswapv2") && this.token?.type === "evm-uniswapv2" // &&
+    //this.evmNetworkId
+    ) {
+      const tokenId0 = evmErc20TokenId(this.networkId, this.token.tokenAddress0);
+      const tokenId1 = evmErc20TokenId(this.networkId, this.token.tokenAddress1);
       const decimals = this.token.decimals;
       const decimals0 = this.token.decimals0;
       const decimals1 = this.token.decimals1;
@@ -845,7 +881,7 @@ const filterMirrorTokens = (balance, i, balances) => {
 
 // TODO: Move this into a common module which can then be imported both here and into EvmErc20Module
 // We can't import this directly from EvmErc20Module because then we'd have a circular dependency
-const evmErc20TokenId$1 = (chainId, tokenContractAddress) => `${chainId}-evm-erc20-${tokenContractAddress}`.toLowerCase();
+const evmErc20TokenId = (chainId, tokenContractAddress) => `${chainId}-evm-erc20-${tokenContractAddress}`.toLowerCase();
 
 /**
  * `BalanceTypes` is an automatically determined sub-selection of `PluginBalanceTypes`.
@@ -867,8 +903,21 @@ const evmErc20TokenId$1 = (chainId, tokenContractAddress) => `${chainId}-evm-erc
 
 /** A collection of `BalanceJson` objects */
 
+// type IBalanceBaseEvm = {
+//   /** WIP, use `chainId` or `evmNetworkId` for now */
+//   multiChainId: EvmChainId
+
+// }
+
+// type IBalanceBaseSubstrate = {
+//   multiChainId: SubChainId
+
+// }
+
 /** `IBalance` is a common interface which all balance types must implement. */
 
+// & (IBalanceBaseEvm | IBalanceBaseSubstrate)
+
 /** An unlabelled amount of a balance */
 
 /** A labelled amount of a balance */
@@ -901,10 +950,9 @@ const getValueId = amount => {
 const deriveMiniMetadataId = ({
   source,
   chainId,
-  specName,
   specVersion,
-  balancesConfig
-}) => u8aToHex(xxhashAsU8a(new TextEncoder().encode(`${source}${chainId}${specName}${specVersion}${balancesConfig}`), 64), undefined, false);
+  libVersion
+}) => u8aToHex(xxhashAsU8a(new TextEncoder().encode(`${source}${chainId}${specVersion}${libVersion}`), 64), undefined, false);
 
 // for DB version 3, Wallet version 1.21.0
 const upgradeRemoveSymbolFromNativeTokenId = async tx => {
@@ -1050,8 +1098,7 @@ class MiniMetadataUpdater {
     const wantedIdsByChain = new Map(chains.flatMap(({
       id: chainId,
       specName,
-      specVersion,
-      balancesConfig
+      specVersion
     }) => {
       if (specName === null) return [];
       if (specVersion === null) return [];
@@ -1059,12 +1106,9 @@ class MiniMetadataUpdater {
         type: source
       }) => deriveMiniMetadataId({
         source,
-        chainId: chainId,
-        specName: specName,
-        specVersion: specVersion,
-        balancesConfig: JSON.stringify((balancesConfig ?? []).find(({
-          moduleType
-        }) => moduleType === source)?.moduleConfig ?? {})
+        chainId,
+        specVersion,
+        libVersion
       }))]];
     }));
     const statusesByChain = new Map(Array.from(wantedIdsByChain.entries()).map(([chainId, wantedIds]) => [chainId, wantedIds.every(wantedId => ids.includes(wantedId)) ? "good" : "none"]));
@@ -1074,17 +1118,18 @@ class MiniMetadataUpdater {
     };
   }
   async hydrateFromChaindata() {
+    // TODO review this. feels unnecessary to fetch them all
+
     const now = Date.now();
     if (now - this.#lastHydratedMiniMetadatasAt < minimumHydrationInterval) return false;
     const dbHasMiniMetadatas = (await db.miniMetadatas.count()) > 0;
     try {
       try {
-        // TODO: Move `fetchMiniMetadatas` into this package,
-        // so that we don't have a circular import between `@talismn/balances` and `@talismn/chaindata-provider`.
-        var miniMetadatas = await fetchMiniMetadatas(); // eslint-disable-line no-var
+        var miniMetadatas = await this.#chaindataProvider.miniMetadatas(); // eslint-disable-line no-var
         if (miniMetadatas.length <= 0) throw new Error("Ignoring empty chaindata miniMetadatas response");
       } catch (error) {
         if (dbHasMiniMetadatas) throw error;
+        log.warn("Failed to fetch miniMetadatas from chaindata", error);
         // On first start-up (db is empty), if we fail to fetch miniMetadatas then we should
         // initialize the DB with the list of miniMetadatas inside our init/mini-metadatas.json file.
         // This data will represent a relatively recent copy of what's in chaindata,
@@ -1100,127 +1145,156 @@ class MiniMetadataUpdater {
     }
   }
   async hydrateCustomChains() {
-    const now = Date.now();
-    if (now - this.#lastHydratedCustomChainsAt < minimumHydrationInterval) return false;
-    const chains = await this.#chaindataProvider.chains();
-    const customChains = chains.filter(chain => "isCustom" in chain && chain.isCustom);
-    const updatedCustomChains = [];
-    const concurrency = 4;
-    (await PromisePool.withConcurrency(concurrency).for(customChains).process(async customChain => {
-      const send = (method, params) => this.#chainConnectors.substrate?.send(customChain.id, method, params);
-      const [genesisHash, runtimeVersion, chainName, chainType] = await Promise.all([send("chain_getBlockHash", [0]), send("state_getRuntimeVersion", []), send("system_chain", []), send("system_chainType", [])]);
-
-      // deconstruct rpc data
-      const {
-        specName,
-        implName
-      } = runtimeVersion;
-      const specVersion = String(runtimeVersion.specVersion);
-      const changed = customChain.genesisHash !== genesisHash || customChain.chainName !== chainName || !isEqual(customChain.chainType, chainType) || customChain.implName !== implName || customChain.specName !== specName || customChain.specVersion !== specVersion;
-      if (!changed) return;
-      customChain.genesisHash = genesisHash;
-      customChain.chainName = chainName;
-      customChain.chainType = chainType;
-      customChain.implName = implName;
-      customChain.specName = specName;
-      customChain.specVersion = specVersion;
-      updatedCustomChains.push(customChain);
-    })).errors.forEach(error => log.error("Error hydrating custom chains", error));
-    if (updatedCustomChains.length > 0) {
-      await this.#chaindataProvider.transaction("rw", ["chains"], async () => {
-        for (const updatedCustomChain of updatedCustomChains) {
-          await this.#chaindataProvider.removeCustomChain(updatedCustomChain.id);
-          await this.#chaindataProvider.addCustomChain(updatedCustomChain);
-        }
-      });
-    }
-    if (updatedCustomChains.length > 0) this.#lastHydratedCustomChainsAt = now;
-    return true;
+    // TODO
+    // const now = Date.now()
+    // if (now - this.#lastHydratedCustomChainsAt < minimumHydrationInterval) return false
+    // const chains = await this.#chaindataProvider.chains()
+    // const customChains = chains.filter(
+    //   (chain): chain is CustomChain => "isCustom" in chain && chain.isCustom,
+    // )
+    // const updatedCustomChains: Array<CustomChain> = []
+    // const concurrency = 4
+    // ;(
+    //   await PromisePool.withConcurrency(concurrency)
+    //     .for(customChains)
+    //     .process(async (customChain) => {
+    //       const send = (method: string, params: unknown[]) =>
+    //         this.#chainConnectors.substrate?.send(customChain.id, method, params)
+    //       const [genesisHash, runtimeVersion, chainName, chainType] = await Promise.all([
+    //         send("chain_getBlockHash", [0]),
+    //         send("state_getRuntimeVersion", []),
+    //         send("system_chain", []),
+    //         send("system_chainType", []),
+    //       ])
+    //       // deconstruct rpc data
+    //       const { specName, implName } = runtimeVersion
+    //       const specVersion = String(runtimeVersion.specVersion)
+    //       const changed =
+    //         customChain.genesisHash !== genesisHash ||
+    //         customChain.chainName !== chainName ||
+    //         !isEqual(customChain.chainType, chainType) ||
+    //         customChain.implName !== implName ||
+    //         customChain.specName !== specName ||
+    //         customChain.specVersion !== specVersion
+    //       if (!changed) return
+    //       customChain.genesisHash = genesisHash
+    //       customChain.chainName = chainName
+    //       customChain.chainType = chainType
+    //       customChain.implName = implName
+    //       customChain.specName = specName
+    //       customChain.specVersion = specVersion
+    //       updatedCustomChains.push(customChain)
+    //     })
+    // ).errors.forEach((error) => log.error("Error hydrating custom chains", error))
+    // if (updatedCustomChains.length > 0) {
+    //   await this.#chaindataProvider.transaction("rw", ["chains"], async () => {
+    //     for (const updatedCustomChain of updatedCustomChains) {
+    //       await this.#chaindataProvider.removeCustomChain(updatedCustomChain.id)
+    //       await this.#chaindataProvider.addCustomChain(updatedCustomChain)
+    //     }
+    //   })
+    // }
+    // if (updatedCustomChains.length > 0) this.#lastHydratedCustomChainsAt = now
+    // return true
   }
-  async updateSubstrateChains(chainIds) {
-    const chains = new Map((await this.#chaindataProvider.chains()).map(chain => [chain.id, chain]));
-    const filteredChains = chainIds.flatMap(chainId => chains.get(chainId) ?? []);
-    const ids = await db.miniMetadatas.orderBy("id").primaryKeys();
-    const {
-      wantedIdsByChain,
-      statusesByChain
-    } = await this.statuses(filteredChains);
-
-    // clean up store
-    const wantedIds = Array.from(wantedIdsByChain.values()).flatMap(ids => ids);
-    const unwantedIds = ids.filter(id => !wantedIds.includes(id));
-    if (unwantedIds.length > 0) {
-      const chainIds = Array.from(new Set((await db.miniMetadatas.bulkGet(unwantedIds)).map(m => m?.chainId)));
-      log.info(`Pruning ${unwantedIds.length} miniMetadatas on chains ${chainIds.join(", ")}`);
-      await db.miniMetadatas.bulkDelete(unwantedIds);
-    }
-    const needUpdates = Array.from(statusesByChain.entries()).filter(([, status]) => status !== "good").map(([chainId]) => chainId);
-    if (needUpdates.length > 0) log.info(`${needUpdates.length} miniMetadatas need updates (${needUpdates.join(", ")})`);
-    const availableTokenLogos = await availableTokenLogoFilenames().catch(error => {
-      log.error("Failed to fetch available token logos", error);
-      return [];
-    });
-    const concurrency = 12;
-    (await PromisePool.withConcurrency(concurrency).for(needUpdates).process(async chainId => {
-      log.info(`Updating metadata for chain ${chainId}`);
-      const chain = chains.get(chainId);
-      if (!chain) return;
-      const {
-        specName,
-        specVersion
-      } = chain;
-      if (specName === null) return;
-      if (specVersion === null) return;
-      const fetchMetadata = async () => {
-        try {
-          return await fetchBestMetadata((method, params, isCacheable) => {
-            if (!this.#chainConnectors.substrate) throw new Error("Substrate connector is not available");
-            return this.#chainConnectors.substrate.send(chainId, method, params, isCacheable);
-          }, true // allow v14 fallback
-          );
-        } catch (err) {
-          log.warn(`Failed to fetch metadata for chain ${chainId}`);
-          return undefined;
-        }
-      };
-      const [metadataRpc, systemProperties] = await Promise.all([fetchMetadata(), this.#chainConnectors.substrate?.send(chainId, "system_properties", [])]);
-      for (const mod of this.#balanceModules.filter(m => m.type.startsWith("substrate-"))) {
-        const balancesConfig = (chain.balancesConfig ?? []).find(({
-          moduleType
-        }) => moduleType === mod.type);
-        const moduleConfig = balancesConfig?.moduleConfig ?? {};
-        const chainMeta = await mod.fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc, systemProperties);
-        const tokens = await mod.fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig);
-
-        // update tokens in chaindata
-        await this.#chaindataProvider.updateChainTokens(chainId, mod.type, Object.values(tokens), availableTokenLogos);
-
-        // update miniMetadatas
-        const {
-          miniMetadata: data,
-          metadataVersion: version,
-          ...extra
-        } = chainMeta ?? {};
-        await db.miniMetadatas.put({
-          id: deriveMiniMetadataId({
-            source: mod.type,
-            chainId,
-            specName,
-            specVersion,
-            balancesConfig: JSON.stringify(moduleConfig)
-          }),
-          source: mod.type,
-          chainId,
-          specName,
-          specVersion,
-          balancesConfig: JSON.stringify(moduleConfig),
-          // TODO: Standardise return value from `fetchSubstrateChainMeta`
-          version,
-          data,
-          extra: JSON.stringify(extra)
-        });
-      }
-    })).errors.forEach(error => log.error("Error updating chain metadata", error));
+  async updateSubstrateChains(_chainIds) {
+    // const chains = new Map(
+    //   (await this.#chaindataProvider.chains()).map((chain) => [chain.id, chain]),
+    // )
+    // const filteredChains = chainIds.flatMap((chainId) => chains.get(chainId) ?? [])
+    // const ids = await balancesDb.miniMetadatas.orderBy("id").primaryKeys()
+    // const { wantedIdsByChain, statusesByChain } = await this.statuses(filteredChains)
+    // // clean up store
+    // const wantedIds = Array.from(wantedIdsByChain.values()).flatMap((ids) => ids)
+    // const unwantedIds = ids.filter((id) => !wantedIds.includes(id))
+    // if (unwantedIds.length > 0) {
+    //   const chainIds = Array.from(
+    //     new Set((await balancesDb.miniMetadatas.bulkGet(unwantedIds)).map((m) => m?.chainId)),
+    //   )
+    //   log.info(`Pruning ${unwantedIds.length} miniMetadatas on chains ${chainIds.join(", ")}`)
+    //   await balancesDb.miniMetadatas.bulkDelete(unwantedIds)
+    // }
+    // const needUpdates = Array.from(statusesByChain.entries())
+    //   .filter(([, status]) => status !== "good")
+    //   .map(([chainId]) => chainId)
+    // if (needUpdates.length > 0)
+    //   log.info(`${needUpdates.length} miniMetadatas need updates (${needUpdates.join(", ")})`)
+    // const availableTokenLogos = await availableTokenLogoFilenames().catch((error) => {
+    //   log.error("Failed to fetch available token logos", error)
+    //   return []
+    // })
+    // const concurrency = 12
+    // ;(
+    //   await PromisePool.withConcurrency(concurrency)
+    //     .for(needUpdates)
+    //     .process(async (chainId) => {
+    //       log.info(`Updating metadata for chain ${chainId}`)
+    //       const chain = chains.get(chainId)
+    //       if (!chain) return
+    //       const { specName, specVersion } = chain
+    //       if (specName === null) return
+    //       if (specVersion === null) return
+    //       const fetchMetadata = async () => {
+    //         try {
+    //           return await fetchBestMetadata(
+    //             (method, params, isCacheable) => {
+    //               if (!this.#chainConnectors.substrate)
+    //                 throw new Error("Substrate connector is not available")
+    //               return this.#chainConnectors.substrate.send(chainId, method, params, isCacheable)
+    //             },
+    //             true, // allow v14 fallback
+    //           )
+    //         } catch (err) {
+    //           log.warn(`Failed to fetch metadata for chain ${chainId}`)
+    //           return undefined
+    //         }
+    //       }
+    //       const [metadataRpc, systemProperties] = await Promise.all([
+    //         fetchMetadata(),
+    //         this.#chainConnectors.substrate?.send(chainId, "system_properties", []),
+    //       ])
+    //       for (const mod of this.#balanceModules.filter((m) => m.type.startsWith("substrate-"))) {
+    //         const balancesConfig = (chain.balancesConfig ?? []).find(
+    //           ({ moduleType }) => moduleType === mod.type,
+    //         )
+    //         const moduleConfig = balancesConfig?.moduleConfig ?? {}
+    //         const chainMeta = await mod.fetchSubstrateChainMeta(
+    //           chainId,
+    //           moduleConfig,
+    //           metadataRpc,
+    //           systemProperties,
+    //         )
+    //         const tokens = await mod.fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig)
+    //         // update tokens in chaindata
+    //         await this.#chaindataProvider.updateChainTokens(
+    //           chainId,
+    //           mod.type,
+    //           Object.values(tokens),
+    //           availableTokenLogos,
+    //         )
+    //         // update miniMetadatas
+    //         const { miniMetadata: data, metadataVersion: version, ...extra } = chainMeta ?? {}
+    //         await balancesDb.miniMetadatas.put({
+    //           id: deriveMiniMetadataId({
+    //             source: mod.type,
+    //             chainId,
+    //             specName,
+    //             specVersion,
+    //             balancesConfig: JSON.stringify(moduleConfig),
+    //           }),
+    //           source: mod.type,
+    //           chainId,
+    //           specName,
+    //           specVersion,
+    //           balancesConfig: JSON.stringify(moduleConfig),
+    //           // TODO: Standardise return value from `fetchSubstrateChainMeta`
+    //           version,
+    //           data,
+    //           extra: JSON.stringify(extra),
+    //         })
+    //       }
+    //     })
+    // ).errors.forEach((error) => log.error("Error updating chain metadata", error))
   }
 }
 
@@ -1455,7 +1529,6 @@ const erc20Abi = [{
 const erc20BalancesAggregatorAbi = parseAbi(["struct AccountToken {address account; address token;}", "function balances(AccountToken[] memory accountTokens) public view returns (uint256[] memory)"]);
 
 const moduleType$7 = "evm-erc20";
-const evmErc20TokenId = (chainId, tokenContractAddress) => `${chainId}-evm-erc20-${tokenContractAddress}`.toLowerCase();
 const EvmErc20Module = hydrate => {
   const {
     chainConnectors,
@@ -1483,7 +1556,7 @@ const EvmErc20Module = hydrate => {
   };
   const getErc20Aggregators = async () => {
     const evmNetworks = await chaindataProvider.evmNetworks();
-    return Object.fromEntries(evmNetworks.filter(n => n.erc20aggregator).map(n => [n.id, n.erc20aggregator]));
+    return Object.fromEntries(evmNetworks.filter(n => n.contracts?.Erc20Aggregator).map(n => [n.id, n.contracts.Erc20Aggregator]));
   };
   return {
     ...DefaultBalanceModule(moduleType$7),
@@ -1491,20 +1564,19 @@ const EvmErc20Module = hydrate => {
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L280-L284).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the chainmeta for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainMeta(chainId) {
-      const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false;
-      return {
-        isTestnet
-      };
+    async fetchEvmChainMeta(_chainId) {
+      return undefined;
+      // const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false
+
+      // return { isTestnet }
     },
     /**
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L338-L343).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the list of tokens for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainTokens(chainId, chainMeta, moduleConfig) {
-      const {
-        isTestnet
-      } = chainMeta;
+    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig) {
+      //const { isTestnet } = chainMeta
+
       const chainTokens = {};
       for (const tokenConfig of moduleConfig?.tokens ?? []) {
         const {
@@ -1523,17 +1595,16 @@ const EvmErc20Module = hydrate => {
         const symbol = tokenConfig?.symbol ?? contractSymbol ?? "ETH";
         const decimals = typeof tokenConfig?.decimals === "number" ? tokenConfig.decimals : typeof contractDecimals === "number" ? contractDecimals : 18;
         if (!symbol || typeof decimals !== "number") continue;
-        const id = evmErc20TokenId(chainId, contractAddress);
+        const id = evmErc20TokenId$1(chainId, contractAddress);
         const token = {
           id,
           type: "evm-erc20",
           platform: "ethereum",
-          isTestnet,
           isDefault: tokenConfig.isDefault ?? true,
           symbol,
           decimals,
           name: contractName ?? symbol,
-          logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+          logo: tokenConfig?.logo,
           contractAddress,
           networkId: chainId
         };
@@ -1559,7 +1630,7 @@ const EvmErc20Module = hydrate => {
       const subscriptionInterval = 6_000; // 6_000ms == 6 seconds
       const initDelay = 1_500; // 1_500ms == 1.5 seconds
       const initialisingBalances = new Set();
-      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.evmNetworkId));
+      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.networkId));
       const tokens = await getModuleTokens();
 
       // for chains with a zero balance we only call fetchBalances once every 5 subscriptionIntervals
@@ -1696,20 +1767,18 @@ const fetchBalances$3 = async (evmChainConnector, tokenAddressesByNetwork, erc20
     results: [],
     errors: []
   };
-  await Promise.all(Object.entries(tokenAddressesByNetwork).map(async ([evmNetworkId, networkParams]) => {
-    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(evmNetworkId);
-    if (!publicClient) throw new EvmErc20NetworkError(`Could not get rpc provider for evm network ${evmNetworkId}`, evmNetworkId);
-    const balances = await getEvmTokenBalances(publicClient, networkParams, result.errors, erc20Aggregators[evmNetworkId]);
+  await Promise.all(Object.entries(tokenAddressesByNetwork).map(async ([networkId, networkParams]) => {
+    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(networkId);
+    if (!publicClient) throw new EvmErc20NetworkError(`Could not get rpc provider for evm network ${networkId}`, networkId);
+    const balances = await getEvmTokenBalances(publicClient, networkParams, result.errors, erc20Aggregators[networkId]);
 
     // consider only non null balances in the results
     result.results.push(...balances.filter(isTruthy).map((free, i) => ({
       source: "evm-erc20",
       status: "live",
       address: networkParams[i].address,
-      multiChainId: {
-        evmChainId: evmNetworkId
-      },
-      evmNetworkId,
+      // multiChainId: { evmChainId: evmNetworkId },
+      networkId,
       tokenId: networkParams[i].token.id,
       value: free
     })));
@@ -1794,9 +1863,12 @@ function groupAddressesByTokenByEvmNetwork$1(addressesByToken, tokens) {
 const abiMulticall = parseAbi(["struct Call { address target; bytes callData; }", "struct Call3 { address target; bool allowFailure; bytes callData; }", "struct Call3Value { address target; bool allowFailure; uint256 value; bytes callData; }", "struct Result { bool success; bytes returnData; }", "function aggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes[] memory returnData)", "function aggregate3(Call3[] calldata calls) public payable returns (Result[] memory returnData)", "function aggregate3Value(Call3Value[] calldata calls) public payable returns (Result[] memory returnData)", "function blockAndAggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)", "function getBasefee() view returns (uint256 basefee)", "function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)", "function getBlockNumber() view returns (uint256 blockNumber)", "function getChainId() view returns (uint256 chainid)", "function getCurrentBlockCoinbase() view returns (address coinbase)", "function getCurrentBlockDifficulty() view returns (uint256 difficulty)", "function getCurrentBlockGasLimit() view returns (uint256 gaslimit)", "function getCurrentBlockTimestamp() view returns (uint256 timestamp)", "function getEthBalance(address addr) view returns (uint256 balance)", "function getLastBlockHash() view returns (bytes32 blockHash)", "function tryAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (Result[] memory returnData)", "function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)"]);
 
 const moduleType$6 = "evm-native";
-const evmNativeTokenId = chainId => `${chainId}-evm-native`.toLowerCase().replace(/ /g, "-");
+
+// export const evmNativeTokenId = (chainId: EvmNetworkId) =>
+//   `${chainId}-evm-native`.toLowerCase().replace(/ /g, "-")
+
 const getEvmNetworkIdFromTokenId = tokenId => {
-  const evmNetworkId = tokenId.split("-")[0];
+  const evmNetworkId = tokenId.split(":")[0];
   if (!evmNetworkId) throw new Error(`Can't detect chainId for token ${tokenId}`);
   return evmNetworkId;
 };
@@ -1817,35 +1889,31 @@ const EvmNativeModule = hydrate => {
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L280-L284).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the chainmeta for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainMeta(chainId) {
-      const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false;
-      return {
-        isTestnet
-      };
+    async fetchEvmChainMeta(_chainId) {
+      // const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false
+
+      // return { isTestnet }
+      return undefined;
     },
     /**
      * This method is currently executed on [a squid](https://github.com/TalismanSociety/chaindata-squid/blob/0ee02818bf5caa7362e3f3664e55ef05ec8df078/src/steps/updateEvmNetworksFromGithub.ts#L338-L343).
      * In a future version of the balance libraries, we may build some kind of async scheduling system which will keep the list of tokens for each chain up to date without relying on a squid.
      */
-    async fetchEvmChainTokens(chainId, chainMeta, moduleConfig) {
-      const {
-        isTestnet
-      } = chainMeta;
+    async fetchEvmChainTokens(networkId, chainMeta, moduleConfig) {
       const symbol = moduleConfig?.symbol ?? "ETH";
       const decimals = typeof moduleConfig?.decimals === "number" ? moduleConfig.decimals : 18;
       const name = moduleConfig?.name ?? symbol;
-      const id = evmNativeTokenId(chainId);
+      const id = evmNativeTokenId(networkId);
       const nativeToken = {
         platform: "ethereum",
         id,
         type: "evm-native",
-        isTestnet,
         isDefault: true,
         symbol,
         decimals,
         name,
-        logo: moduleConfig?.logo || githubTokenLogoUrl(id),
-        networkId: chainId
+        logo: moduleConfig?.logo,
+        networkId
       };
       if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol;
       if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId;
@@ -1880,7 +1948,7 @@ const EvmNativeModule = hydrate => {
       // setup initialising balances for all active evm networks
       const activeEvmNetworkIds = Object.keys(ethAddressesByToken).map(getEvmNetworkIdFromTokenId);
       const initialisingBalances = new Set(activeEvmNetworkIds);
-      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.evmNetworkId));
+      const positiveBalanceNetworks = new Set(initialBalances?.map(b => b.networkId));
       const poll = async () => {
         if (!subscriptionActive) return;
         zeroBalanceSubscriptionIntervalCounter = (zeroBalanceSubscriptionIntervalCounter + 1) % 5;
@@ -1907,10 +1975,10 @@ const EvmNativeModule = hydrate => {
                   log.error(balance.message, balance.networkId);
                   initialisingBalances.delete(balance.networkId);
                 } else {
-                  if (balance.evmNetworkId) {
-                    initialisingBalances.delete(balance.evmNetworkId);
+                  if (balance.networkId) {
+                    initialisingBalances.delete(balance.networkId);
                     if (BigInt(balance.value) > 0n) {
-                      positiveBalanceNetworks.add(balance.evmNetworkId);
+                      positiveBalanceNetworks.add(balance.networkId);
                     }
                     resultBalances.push(balance);
                   }
@@ -1960,23 +2028,23 @@ const fetchBalances$2 = async (evmChainConnector, addressesByToken, tokens) => {
   if (!evmChainConnector) throw new Error(`This module requires an evm chain connector`);
   return Promise.all(Object.entries(addressesByToken).map(async ([tokenId, addresses]) => {
     const token = tokens[tokenId];
-    const evmNetworkId = token.networkId;
-    if (!evmNetworkId) throw new Error(`Token ${token.id} has no evm network`);
-    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(evmNetworkId);
-    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${evmNetworkId}`);
+    const networkId = token.networkId;
+    if (!networkId) throw new Error(`Token ${token.id} has no evm network`);
+    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(networkId);
+    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
 
     // fetch all balances
     const freeBalances = await getFreeBalances(publicClient, addresses);
     const balanceResults = addresses.map((address, i) => {
-      if (freeBalances[i] === "error") return new EvmNativeBalanceError("Could not fetch balance ", evmNetworkId);
+      if (freeBalances[i] === "error") return new EvmNativeBalanceError("Could not fetch balance ", networkId);
       return {
         source: "evm-native",
         status: "live",
         address: address,
         multiChainId: {
-          evmChainId: evmNetworkId
+          evmChainId: networkId
         },
-        evmNetworkId,
+        networkId,
         tokenId,
         value: freeBalances[i].toString()
       };
@@ -2598,7 +2666,6 @@ const uniswapV2PairAbi = [{
 }];
 
 const moduleType$5 = "evm-uniswapv2";
-const evmUniswapV2TokenId = (chainId, contractAddress) => `${chainId}-evm-uniswapv2-${contractAddress}`.toLowerCase();
 const EvmUniswapV2Module = hydrate => {
   const {
     chainConnectors,
@@ -2608,16 +2675,15 @@ const EvmUniswapV2Module = hydrate => {
   assert(chainConnector, "This module requires an evm chain connector");
   return {
     ...DefaultBalanceModule(moduleType$5),
-    async fetchEvmChainMeta(chainId) {
-      const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false;
-      return {
-        isTestnet
-      };
+    async fetchEvmChainMeta(_chainId) {
+      // const isTestnet = (await chaindataProvider.evmNetworkById(chainId))?.isTestnet || false
+
+      // return { isTestnet }
+      return undefined;
     },
-    async fetchEvmChainTokens(chainId, chainMeta, moduleConfig) {
-      const {
-        isTestnet
-      } = chainMeta;
+    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig) {
+      //const { isTestnet } = chainMeta
+
       const tokens = {};
       for (const tokenConfig of moduleConfig?.pools ?? []) {
         const {
@@ -2642,7 +2708,7 @@ const EvmUniswapV2Module = hydrate => {
           id,
           type: "evm-uniswapv2",
           platform: "ethereum",
-          isTestnet,
+          //    isTestnet,
           isDefault: tokenConfig.isDefault ?? false,
           symbol: `${symbol0 ?? "UNKNOWN"}/${symbol1 ?? "UNKNOWN"}`,
           name: name ?? `${symbol0 ?? "UNKNOWN"}/${symbol1 ?? "UNKNOWN"}`,
@@ -2676,9 +2742,9 @@ const EvmUniswapV2Module = hydrate => {
       const initDelay = 1_500; // 1_500ms == 1.5 seconds
 
       const initialBalancesByNetwork = initialBalances?.reduce((result, b) => {
-        if (!b.evmNetworkId) return result;
-        if (!result[b.evmNetworkId]) result[b.evmNetworkId] = {};
-        result[b.evmNetworkId][getBalanceId(b)] = b;
+        if (!b.networkId) return result;
+        if (!result[b.networkId]) result[b.networkId] = {};
+        result[b.networkId][getBalanceId(b)] = b;
         return result;
       }, {});
       const cache = new Map(Object.entries(initialBalancesByNetwork ?? {}));
@@ -2738,12 +2804,12 @@ const EvmUniswapV2Module = hydrate => {
 };
 const fetchBalances$1 = async (evmChainConnector, evmNetworks, tokens, addressesByToken) => {
   const addressesByTokenGroupedByEvmNetwork = groupAddressesByTokenByEvmNetwork(addressesByToken, tokens);
-  const balances = (await Promise.allSettled(Object.entries(addressesByTokenGroupedByEvmNetwork).map(async ([evmNetworkId, addressesByToken]) => {
+  const balances = (await Promise.allSettled(Object.entries(addressesByTokenGroupedByEvmNetwork).map(async ([networkId, addressesByToken]) => {
     if (!evmChainConnector) throw new Error(`This module requires an evm chain connector`);
-    const evmNetwork = evmNetworks[evmNetworkId];
-    if (!evmNetwork) throw new Error(`Evm network ${evmNetworkId} not found`);
-    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(evmNetworkId);
-    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${evmNetworkId}`);
+    const evmNetwork = evmNetworks[networkId];
+    if (!evmNetwork) throw new Error(`Evm network ${networkId} not found`);
+    const publicClient = await evmChainConnector.getPublicClientForEvmNetwork(networkId);
+    if (!publicClient) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
     const tokensAndAddresses = Object.entries(addressesByToken).reduce((tokensAndAddresses, [tokenId, addresses]) => {
       const token = tokens[tokenId];
       if (!token) {
@@ -2765,10 +2831,7 @@ const fetchBalances$1 = async (evmChainConnector, evmNetworks, tokens, addresses
         source: "evm-uniswapv2",
         status: "live",
         address: address,
-        multiChainId: {
-          evmChainId: evmNetwork.id
-        },
-        evmNetworkId,
+        networkId,
         tokenId: token.id,
         values: await getPoolBalance(publicClient, token.contractAddress, address)
       }));
@@ -2900,24 +2963,20 @@ async function balances(balanceModule, addressesByToken, callback) {
  */
 const findChainMeta = (miniMetadatas, moduleType, chain) => {
   if (!chain) return [undefined, undefined];
-  if (!chain.specName) return [undefined, undefined];
   if (!chain.specVersion) return [undefined, undefined];
 
   // TODO: This is spaghetti to import this here, it should be injected into each balance module or something.
   const metadataId = deriveMiniMetadataId({
     source: moduleType,
     chainId: chain.id,
-    specName: chain.specName,
     specVersion: chain.specVersion,
-    balancesConfig: JSON.stringify(chain.balancesConfig?.find(config => config.moduleType === moduleType)?.moduleConfig ?? {})
+    libVersion
   });
 
   // TODO: Fix this (needs to fetch miniMetadata without being async)
   const miniMetadata = miniMetadatas.get(metadataId);
   const chainMeta = miniMetadata ? {
-    miniMetadata: miniMetadata.data,
-    metadataVersion: miniMetadata.version,
-    ...JSON.parse(miniMetadata.extra)
+    miniMetadata: miniMetadata.data
   } : undefined;
   return [chainMeta, miniMetadata];
 };
@@ -3145,7 +3204,6 @@ const decompress = data => {
 };
 
 const moduleType$4 = "substrate-assets";
-const subAssetTokenId = (chainId, assetId, tokenSymbol) => `${chainId}-substrate-assets-${assetId}-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
 const SubAssetsModule = hydrate => {
   const {
     chainConnectors,
@@ -3179,12 +3237,9 @@ const SubAssetsModule = hydrate => {
     async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
       if ((moduleConfig?.tokens ?? []).length < 1) return {};
       const {
-        isTestnet,
-        miniMetadata,
-        metadataVersion
+        miniMetadata
       } = chainMeta;
-      if (miniMetadata === undefined || metadataVersion === undefined) return {};
-      if (metadataVersion < 14) return {};
+      if (!miniMetadata) return {};
       const metadata = unifyMetadata(decAnyMetadata(miniMetadata));
       const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
       const assetCoder = scaleBuilder.buildStorage("Assets", "Asset");
@@ -3201,17 +3256,16 @@ const SubAssetsModule = hydrate => {
           const symbol = assetsMetadata?.symbol?.asText?.() ?? "Unit";
           const decimals = assetsMetadata?.decimals ?? 0;
           const isFrozen = assetsMetadata?.is_frozen ?? false;
-          const id = subAssetTokenId(chainId, assetId, symbol);
+          const id = subAssetTokenId(chainId, assetId);
           const token = {
             id,
             type: "substrate-assets",
             platform: "polkadot",
-            isTestnet,
             isDefault: tokenConfig?.isDefault ?? true,
             symbol,
             name: tokenConfig?.name || symbol,
             decimals,
-            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+            logo: tokenConfig?.logo,
             existentialDeposit,
             assetId,
             isFrozen,
@@ -3219,7 +3273,7 @@ const SubAssetsModule = hydrate => {
           };
           if (tokenConfig?.symbol) {
             token.symbol = tokenConfig?.symbol;
-            token.id = subAssetTokenId(chainId, assetId, token.symbol);
+            token.id = subAssetTokenId(chainId, assetId);
           }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
@@ -3340,27 +3394,27 @@ async function buildQueries$3(chaindataProvider, addressesByToken) {
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return [];
     }
-    const chainId = token.networkId;
-    if (!chainId) {
+    const networkId = token.networkId;
+    if (!networkId) {
       log.warn(`Token ${tokenId} has no chain`);
       return [];
     }
-    const chain = chains[chainId];
+    const chain = chains[networkId];
     if (!chain) {
-      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      log.warn(`Chain ${networkId} for token ${tokenId} not found`);
       return [];
     }
     return addresses.flatMap(address => {
-      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
+      const scaleCoder = chainStorageCoders.get(networkId)?.storage;
       const stateKey = tryEncode(scaleCoder, BigInt(token.assetId), address) ?? tryEncode(scaleCoder, token.assetId, address);
       if (!stateKey) {
-        log.warn(`Invalid assetId / address in ${chainId} storage query ${token.assetId} / ${address}`);
+        log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
         return [];
       }
       const decodeResult = change => {
         /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
-        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${chainId}`) ?? {
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
           balance: 0n,
           status: {
             type: "Liquid"
@@ -3394,16 +3448,13 @@ async function buildQueries$3(chaindataProvider, addressesByToken) {
           source: "substrate-assets",
           status: "live",
           address,
-          multiChainId: {
-            subChainId: chainId
-          },
-          chainId,
+          networkId,
           tokenId: token.id,
           values: balanceValues
         };
       };
       return {
-        chainId,
+        chainId: networkId,
         stateKey,
         decodeResult
       };
@@ -3423,7 +3474,6 @@ const tryEncode = (scaleCoder, ...args) => {
 };
 
 const moduleType$3 = "substrate-foreignassets";
-const subForeignAssetTokenId = (chainId, tokenSymbol) => `${chainId}-substrate-foreignassets-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
 const SubForeignAssetsModule = hydrate => {
   const {
     chainConnectors,
@@ -3434,14 +3484,12 @@ const SubForeignAssetsModule = hydrate => {
   return {
     ...DefaultBalanceModule(moduleType$3),
     async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
-      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
-      if (metadataRpc === undefined) return {
-        isTestnet
-      };
-      if ((moduleConfig?.tokens ?? []).length < 1) return {
-        isTestnet
-      };
+      //   const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false
+      if (metadataRpc === undefined) return {};
+      // if ((moduleConfig?.tokens ?? []).length < 1) return { isTestnet }
+
       const metadataVersion = getMetadataVersion(metadataRpc);
+      if (metadataVersion < 14) return {};
       const metadata = decAnyMetadata(metadataRpc);
       compactMetadata(metadata, [{
         pallet: "ForeignAssets",
@@ -3449,20 +3497,18 @@ const SubForeignAssetsModule = hydrate => {
       }]);
       const miniMetadata = encodeMetadata(metadata);
       return {
-        isTestnet,
-        miniMetadata,
-        metadataVersion
+        miniMetadata
       };
     },
     async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
       if ((moduleConfig?.tokens ?? []).length < 1) return {};
       const {
-        isTestnet,
-        miniMetadata,
-        metadataVersion
+        miniMetadata
       } = chainMeta;
-      if (miniMetadata === undefined || metadataVersion === undefined) return {};
-      if (metadataVersion < 14) return {};
+      if (!miniMetadata) return {};
+      // if (miniMetadata === undefined || metadataVersion === undefined) return {}
+      // if (metadataVersion < 14) return {}
+
       const metadata = decAnyMetadata(miniMetadata);
       const unifiedMetadata = unifyMetadata(metadata);
       const scaleBuilder = getDynamicBuilder(getLookupFn(unifiedMetadata));
@@ -3486,26 +3532,22 @@ const SubForeignAssetsModule = hydrate => {
           const symbol = assetsMetadata?.symbol?.asText?.() ?? "Unit";
           const decimals = assetsMetadata?.decimals ?? 0;
           const isFrozen = assetsMetadata?.is_frozen ?? false;
-          const id = subForeignAssetTokenId(chainId, symbol);
+          const id = subForeignAssetTokenId(chainId, tokenConfig.onChainId);
           const token = {
             id,
             type: "substrate-foreignassets",
             platform: "polkadot",
-            isTestnet,
+            // isTestnet,
             isDefault: tokenConfig?.isDefault ?? true,
             symbol,
             decimals,
             name: tokenConfig?.name || symbol,
-            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+            logo: tokenConfig?.logo,
             existentialDeposit,
             onChainId: tokenConfig.onChainId,
             isFrozen,
             networkId: chainId
           };
-          if (tokenConfig?.symbol) {
-            token.symbol = tokenConfig?.symbol;
-            token.id = subForeignAssetTokenId(chainId, token.symbol);
-          }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
           tokens[token.id] = token;
@@ -3611,18 +3653,18 @@ async function buildQueries$2(chaindataProvider, addressesByToken) {
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return [];
     }
-    const chainId = token.networkId;
-    if (!chainId) {
+    const networkId = token.networkId;
+    if (!networkId) {
       log.warn(`Token ${tokenId} has no chain`);
       return [];
     }
-    const chain = chains[chainId];
+    const chain = chains[networkId];
     if (!chain) {
-      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      log.warn(`Chain ${networkId} for token ${tokenId} not found`);
       return [];
     }
     return addresses.flatMap(address => {
-      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
+      const scaleCoder = chainStorageCoders.get(networkId)?.storage;
       const onChainId = (() => {
         try {
           return papiParse(token.onChainId);
@@ -3630,12 +3672,12 @@ async function buildQueries$2(chaindataProvider, addressesByToken) {
           return token.onChainId;
         }
       })();
-      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${chainId} storage query ${address} / ${token.onChainId}`, onChainId, address);
+      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${networkId} storage query ${address} / ${token.onChainId}`, onChainId, address);
       if (!stateKey) return [];
       const decodeResult = change => {
         /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
-        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-foreignassets balance on chain ${chainId}`) ?? {
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-foreignassets balance on chain ${networkId}`) ?? {
           balance: 0n,
           status: {
             type: "Liquid"
@@ -3669,16 +3711,13 @@ async function buildQueries$2(chaindataProvider, addressesByToken) {
           source: "substrate-foreignassets",
           status: "live",
           address,
-          multiChainId: {
-            subChainId: chainId
-          },
-          chainId,
+          networkId,
           tokenId: token.id,
           values: balanceValues
         };
       };
       return {
-        chainId,
+        chainId: networkId,
         stateKey,
         decodeResult
       };
@@ -3935,10 +3974,7 @@ async function subscribeCrowdloans(chaindataProvider, chainConnector, addressesB
             source: "substrate-native",
             status: "live",
             address,
-            multiChainId: {
-              subChainId: chainId
-            },
-            chainId,
+            networkId: chainId,
             tokenId,
             values: Array.from(contributions).map(({
               amount,
@@ -4221,10 +4257,7 @@ async function subscribeNompoolStaking(chaindataProvider, chainConnector, addres
             source: "substrate-native",
             status: "live",
             address,
-            multiChainId: {
-              subChainId: chainId
-            },
-            chainId,
+            networkId: chainId,
             tokenId,
             values: [{
               source: "nompools-staking",
@@ -4468,10 +4501,7 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
         source: "substrate-native",
         status: "live",
         address,
-        multiChainId: {
-          subChainId: chainId
-        },
-        chainId,
+        networkId: chainId,
         tokenId,
         values: [{
           source: "subtensor-staking",
@@ -4580,8 +4610,12 @@ const getLockTitle = (lock, {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const paraId = lock.meta?.paraId;
     if (!paraId) return "Crowdloan";
-    const name = balance?.chain?.parathreads?.find(parathread => parathread?.paraId === paraId)?.name;
-    return `${name ? name : `Parachain ${paraId}`} Crowdloan`;
+
+    // balance?.network?.parathreads?.find(
+    //   (parathread) => parathread?.paraId === paraId,
+    // )?.name
+
+    return `${`Parachain ${paraId}`} Crowdloan`;
   }
   if (lock.label === "nompools-staking") return "Pooled Staking";
   if (lock.label === "nompools-unbonding") return "Pooled Staking";
@@ -4594,7 +4628,9 @@ const getLockTitle = (lock, {
 };
 
 const moduleType$2 = "substrate-native";
-const subNativeTokenId = chainId => `${chainId}-substrate-native`.toLowerCase().replace(/ /g, "-");
+
+// export const subNativeTokenId = (chainId: ChainId) =>
+//   `${chainId}-substrate-native`.toLowerCase().replace(/ /g, "-")
 
 /**
  * Function to merge two 'sub sources' of the same balance together, or
@@ -4693,10 +4729,7 @@ async function buildQueries$1(chains, tokens, chainStorageCoders, miniMetadatas,
         source: "substrate-native",
         status: "live",
         address,
-        multiChainId: {
-          subChainId: chainId
-        },
-        chainId,
+        networkId: chainId,
         tokenId,
         values: []
       };
@@ -5239,7 +5272,7 @@ const SubNativeModule = hydrate => {
         symbol: symbol ?? DEFAULT_SYMBOL,
         name: moduleConfig?.name ?? symbol ?? DEFAULT_SYMBOL,
         decimals: decimals ?? DEFAULT_DECIMALS,
-        logo: moduleConfig?.logo || githubTokenLogoUrl(id),
+        logo: moduleConfig?.logo,
         existentialDeposit: existentialDeposit ?? "0",
         networkId: chainId
       };
@@ -5388,7 +5421,7 @@ const SubNativeModule = hydrate => {
       const nonCurrentTokens = Object.keys(addressesByToken).filter(tokenId => !currentTokens.has(tokenId)).sort(sortChains);
 
       // break nonCurrentTokens into chunks of POLLING_WINDOW_SIZE
-      await PromisePool$1.withConcurrency(POLLING_WINDOW_SIZE).for(nonCurrentTokens).process(async nonCurrentTokenId => await poll({
+      await PromisePool.withConcurrency(POLLING_WINDOW_SIZE).for(nonCurrentTokens).process(async nonCurrentTokenId => await poll({
         [nonCurrentTokenId]: addressesByToken[nonCurrentTokenId]
       }));
 
@@ -6632,7 +6665,6 @@ var psp22Abi = {
 };
 
 const moduleType$1 = "substrate-psp22";
-const subPsp22TokenId = (chainId, tokenSymbol) => `${chainId}-substrate-psp22-${tokenSymbol}`.toLowerCase().replace(/ /g, "-");
 const SubPsp22Module = hydrate => {
   const {
     chainConnectors,
@@ -6642,16 +6674,14 @@ const SubPsp22Module = hydrate => {
   assert(chainConnector, "This module requires a substrate chain connector");
   return {
     ...DefaultBalanceModule(moduleType$1),
-    async fetchSubstrateChainMeta(chainId) {
-      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
-      return {
-        isTestnet
-      };
+    async fetchSubstrateChainMeta(_chainId) {
+      // const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false
+      // return { isTestnet }
+      return undefined;
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
-      const {
-        isTestnet
-      } = chainMeta;
+    async fetchSubstrateChainTokens(chainId, _chainMeta, moduleConfig) {
+      // const { isTestnet } = chainMeta
+
       const registry = new TypeRegistry();
       const Psp22Abi = new Abi(psp22Abi);
 
@@ -6682,25 +6712,21 @@ const SubPsp22Module = hydrate => {
             const decimalsData = decimalsResult.toJSON()?.result?.ok?.data;
             decimals = typeof decimalsData === "string" && decimalsData.startsWith("0x") ? hexToNumber(decimalsData) : decimals;
           })();
-          const id = subPsp22TokenId(chainId, symbol);
+          const id = subPsp22TokenId(chainId, contractAddress);
           const token = {
             id,
             type: "substrate-psp22",
             platform: "polkadot",
-            isTestnet,
+            // isTestnet,
             isDefault: tokenConfig.isDefault ?? true,
             symbol,
             decimals,
             name: tokenConfig?.name || symbol,
-            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+            logo: tokenConfig?.logo,
             existentialDeposit,
             contractAddress,
             networkId: chainId
           };
-          if (tokenConfig?.symbol) {
-            token.symbol = tokenConfig?.symbol;
-            token.id = subPsp22TokenId(chainId, token.symbol);
-          }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
           tokens[token.id] = token;
@@ -6861,10 +6887,7 @@ const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
       source: "substrate-psp22",
       status: "live",
       address,
-      multiChainId: {
-        subChainId: token.networkId
-      },
-      chainId: token.networkId,
+      networkId: token.networkId,
       tokenId,
       value: balance
     };
@@ -6888,7 +6911,6 @@ const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
 
 const moduleType = "substrate-tokens";
 const defaultPalletId = "Tokens";
-const subTokensTokenId = (chainId, onChainId) => `${chainId}-substrate-tokens-${compressToEncodedURIComponent(String(onChainId))}`;
 const SubTokensModule = hydrate => {
   const {
     chainConnectors,
@@ -6899,14 +6921,8 @@ const SubTokensModule = hydrate => {
   return {
     ...DefaultBalanceModule(moduleType),
     async fetchSubstrateChainMeta(chainId, moduleConfig, metadataRpc) {
-      const isTestnet = (await chaindataProvider.chainById(chainId))?.isTestnet || false;
-      if (metadataRpc === undefined) return {
-        isTestnet
-      };
-      if ((moduleConfig?.tokens ?? []).length < 1) return {
-        isTestnet
-      };
-      const metadataVersion = getMetadataVersion(metadataRpc);
+      if (metadataRpc === undefined) return {};
+      if ((moduleConfig?.tokens ?? []).length < 1) return {};
       const metadata = decAnyMetadata(metadataRpc);
       const palletId = moduleConfig?.palletId ?? defaultPalletId;
       compactMetadata(metadata, [{
@@ -6915,20 +6931,13 @@ const SubTokensModule = hydrate => {
       }]);
       const miniMetadata = encodeMetadata(metadata);
       return palletId === defaultPalletId ? {
-        isTestnet,
-        miniMetadata,
-        metadataVersion
+        miniMetadata
       } : {
-        isTestnet,
         palletId,
-        miniMetadata,
-        metadataVersion
+        miniMetadata
       };
     },
     async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
-      const {
-        isTestnet
-      } = chainMeta;
       const tokens = {};
       for (const tokenConfig of moduleConfig?.tokens ?? []) {
         try {
@@ -6942,20 +6951,15 @@ const SubTokensModule = hydrate => {
             id,
             type: "substrate-tokens",
             platform: "polkadot",
-            isTestnet,
             isDefault: tokenConfig.isDefault ?? true,
             symbol,
             decimals,
             name: tokenConfig?.name ?? symbol,
-            logo: tokenConfig?.logo || githubTokenLogoUrl(id),
+            logo: tokenConfig?.logo,
             existentialDeposit,
             onChainId,
             networkId: chainId
           };
-          if (tokenConfig?.symbol) {
-            token.symbol = tokenConfig?.symbol;
-            token.id = subTokensTokenId(chainId, token.onChainId);
-          }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
           tokens[token.id] = token;
@@ -7127,18 +7131,18 @@ async function buildQueries(chaindataProvider, addressesByToken) {
       log.debug(`This module doesn't handle tokens of type ${token.type}`);
       return [];
     }
-    const chainId = token.networkId;
-    if (!chainId) {
+    const networkId = token.networkId;
+    if (!networkId) {
       log.warn(`Token ${tokenId} has no chain`);
       return [];
     }
-    const chain = chains[chainId];
+    const chain = chains[networkId];
     if (!chain) {
-      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+      log.warn(`Chain ${networkId} for token ${tokenId} not found`);
       return [];
     }
     return addresses.flatMap(address => {
-      const scaleCoder = chainStorageCoders.get(chainId)?.storage;
+      const scaleCoder = chainStorageCoders.get(networkId)?.storage;
       const onChainId = (() => {
         try {
           return papiParse(token.onChainId);
@@ -7146,12 +7150,12 @@ async function buildQueries(chaindataProvider, addressesByToken) {
           return token.onChainId;
         }
       })();
-      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${chainId} storage query ${address} / ${token.onChainId}`, address, onChainId);
+      const stateKey = encodeStateKey(scaleCoder, `Invalid address / token onChainId in ${networkId} storage query ${address} / ${token.onChainId}`, address, onChainId);
       if (!stateKey) return [];
       const decodeResult = change => {
         /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
-        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-tokens balance on chain ${chainId}`) ?? {
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-tokens balance on chain ${networkId}`) ?? {
           free: 0n,
           reserved: 0n,
           frozen: 0n
@@ -7176,16 +7180,13 @@ async function buildQueries(chaindataProvider, addressesByToken) {
           source: "substrate-tokens",
           status: "live",
           address,
-          multiChainId: {
-            subChainId: chainId
-          },
-          chainId,
+          networkId,
           tokenId: token.id,
           values: balanceValues
         };
       };
       return {
-        chainId,
+        chainId: networkId,
         stateKey,
         decodeResult
       };
@@ -7198,7 +7199,7 @@ const defaultBalanceModules = [EvmErc20Module, EvmNativeModule, EvmUniswapV2Modu
 /** Pulls the latest chaindata from https://github.com/TalismanSociety/chaindata */
 const hydrateChaindataAndMiniMetadata = async (chaindataProvider, miniMetadataUpdater) => {
   // need chains to be provisioned first, or substrate balances won't fetch on first subscription
-  await chaindataProvider.hydrateChains();
+  await chaindataProvider.hydrate();
   await Promise.all([miniMetadataUpdater.hydrateFromChaindata(), miniMetadataUpdater.hydrateCustomChains()]);
   const chains = await chaindataProvider.chains();
   const {
@@ -7216,9 +7217,9 @@ const updateCustomMiniMetadata = async (chaindataProvider, miniMetadataUpdater)
 
 /** Fetches any missing Evm Tokens */
 const updateEvmTokens = async (chaindataProvider, evmTokenFetcher) => {
-  await chaindataProvider.hydrateEvmNetworks();
+  await chaindataProvider.hydrate();
   const evmNetworkIds = await chaindataProvider.evmNetworkIds();
   await evmTokenFetcher.update(evmNetworkIds);
 };
 
-export { Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20Module, EvmNativeModule, EvmTokenFetcher, EvmUniswapV2Module, FiatSumBalancesFormatter, MiniMetadataUpdater, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildStorageCoders, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20Abi, erc20BalancesAggregatorAbi, evmErc20TokenId, evmNativeTokenId, evmUniswapV2TokenId, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, findChainMeta, getBalanceId, getLockTitle, getUniqueChainIds, getValueId, hydrateChaindataAndMiniMetadata, includeInTotalExtraAmount, makeContractCaller, subAssetTokenId, subForeignAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId, uniswapV2PairAbi, updateCustomMiniMetadata, updateEvmTokens };
+export { Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20Module, EvmNativeModule, EvmTokenFetcher, EvmUniswapV2Module, FiatSumBalancesFormatter, MiniMetadataUpdater, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildStorageCoders, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20Abi, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, findChainMeta, getBalanceId, getLockTitle, getUniqueChainIds, getValueId, hydrateChaindataAndMiniMetadata, includeInTotalExtraAmount, makeContractCaller, uniswapV2PairAbi, updateCustomMiniMetadata, updateEvmTokens };