@talismn/balances 0.0.0-pr2043-20250619170346 → 0.0.0-pr2043-20250620074243

package/dist/talismn-balances.esm.js

@@ -1,11 +1,11 @@
 import { Dexie } from 'dexie';
 import anylogger from 'anylogger';
-import { evmErc20TokenId, EvmErc20TokenSchema, networkIdFromTokenId, evmNativeTokenId, evmUniswapV2TokenId, getGithubTokenLogoUrl, parseSubAssetTokenId, subAssetTokenId, parseSubForeignAssetTokenId, subForeignAssetTokenId, parseTokenId, subNativeTokenId, subPsp22TokenId, parseSubTokensTokenId, subTokensTokenId } from '@talismn/chaindata-provider';
+import { evmErc20TokenId, TokenBaseSchema, EvmErc20TokenSchema, networkIdFromTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, getGithubTokenLogoUrl, DotNetworkBalancesConfigSchema, SubAssetsTokenSchema, parseSubAssetTokenId, subAssetTokenId, SubForeignAssetsTokenSchema, parseSubForeignAssetTokenId, subForeignAssetTokenId, parseTokenId, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, parseSubTokensTokenId, subTokensTokenId } from '@talismn/chaindata-provider';
 import { newTokenRates } from '@talismn/token-rates';
-import { isBigInt, BigMath, planckToTokens, isArrayOf, isTruthy, isEthereumAddress, hasOwnProperty, isAbortError, decodeAnyAddress, isNotNil, blake2Concat, Deferred } from '@talismn/util';
+import { isBigInt, BigMath, planckToTokens, isArrayOf, isTruthy, isEthereumAddress, hasOwnProperty, isAbortError, isNotNil, decodeAnyAddress, blake2Concat, Deferred } from '@talismn/util';
 import BigNumber from 'bignumber.js';
-import { u8aToHex, assert, stringCamelCase, u8aConcatStrict, u8aConcat, arrayChunk, u8aToString, hexToNumber, hexToU8a } from '@polkadot/util';
-import { xxhashAsU8a, blake2AsU8a } from '@polkadot/util-crypto';
+import { u8aToHex, assert, stringCamelCase, u8aConcatStrict, arrayChunk, u8aToString, hexToNumber, hexToU8a } from '@polkadot/util';
+import { xxhashAsU8a } from '@polkadot/util-crypto';
 import pako from 'pako';
 import { parseAbi, isHex, hexToBigInt } from 'viem';
 import { fromPairs, toPairs, keys, groupBy as groupBy$1 } from 'lodash';
@@ -14,17 +14,16 @@ import { defineMethod } from '@substrate/txwrapper-core';
 import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, compactMetadata, encodeMetadata, decodeScale, papiParse, getMetadataVersion, encodeStateKey } from '@talismn/scale';
 import camelCase from 'lodash/camelCase';
 import PQueue from 'p-queue';
+import z from 'zod/v4';
 import { fetchBestMetadata, getScaleApi } from '@talismn/sapi';
 import { Metadata, TypeRegistry } from '@polkadot/types';
 import groupBy from 'lodash/groupBy';
 import { mergeUint8, toHex } from '@polkadot-api/utils';
 import { Binary, AccountId } from 'polkadot-api';
-import PromisePool from '@supercharge/promise-pool';
 import { ChainConnectionError } from '@talismn/chain-connector';
 import { Observable, scan, share, map, switchAll, combineLatest, from, mergeMap, toArray, interval, startWith, exhaustMap, BehaviorSubject, debounceTime, takeUntil, distinctUntilChanged, switchMap, withLatestFrom, concatMap } from 'rxjs';
-import { u32, u128, Struct } from 'scale-ts';
+import { u32, Struct, u128 } from 'scale-ts';
 import upperFirst from 'lodash/upperFirst';
-import z from 'zod/v4';
 import { Abi } from '@polkadot/api-contract';
 
 // Record<string, unknown> | undefined
@@ -113,7 +112,7 @@ class EvmTokenFetcher {
 
 var pkg = {
 	name: "@talismn/balances",
-	version: "0.0.0-pr2043-20250619170346"};
+	version: "0.0.0-pr2043-20250620074243"};
 
 var log = anylogger(pkg.name);
 
@@ -1017,6 +1016,10 @@ class TalismanBalancesDatabase extends Dexie {
 }
 const db = new TalismanBalancesDatabase();
 
+const TokenConfigBaseSchema = TokenBaseSchema.partial().omit({
+  id: true
+});
+
 const erc20Abi = [{
   constant: true,
   inputs: [],
@@ -1248,6 +1251,20 @@ 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";
+// {
+//   tokens?: Array<
+//     {
+//       symbol?: string
+//       decimals?: number
+//       name?: string
+//       contractAddress?: `0x${string}`
+//     } & BalancesConfigTokenParams
+//   >
+// }
+
+const EvmErc20TokenConfigSchema = TokenConfigBaseSchema.extend({
+  contractAddress: EvmErc20TokenSchema.shape.contractAddress
+});
 const EvmErc20Module = hydrate => {
   const {
     chainConnectors,
@@ -1293,11 +1310,11 @@ const EvmErc20Module = hydrate => {
      * 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) {
+    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig, tokens) {
       //const { isTestnet } = chainMeta
 
       const chainTokens = {};
-      for (const tokenConfig of moduleConfig?.tokens ?? []) {
+      for (const tokenConfig of tokens ?? []) {
         const {
           contractAddress,
           symbol: contractSymbol,
@@ -1581,6 +1598,7 @@ function groupAddressesByTokenByEvmNetwork$1(addressesByToken, tokens) {
 const abiMulticall = parseAbi(["struct Call { address target; bytes callData; }", "struct Call3 { address target; bool allowFailure; bytes callData; }", "struct Call3Value { address target; bool allowFailure; uint256 value; bytes callData; }", "struct Result { bool success; bytes returnData; }", "function aggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes[] memory returnData)", "function aggregate3(Call3[] calldata calls) public payable returns (Result[] memory returnData)", "function aggregate3Value(Call3Value[] calldata calls) public payable returns (Result[] memory returnData)", "function blockAndAggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)", "function getBasefee() view returns (uint256 basefee)", "function getBlockHash(uint256 blockNumber) view returns (bytes32 blockHash)", "function getBlockNumber() view returns (uint256 blockNumber)", "function getChainId() view returns (uint256 chainid)", "function getCurrentBlockCoinbase() view returns (address coinbase)", "function getCurrentBlockDifficulty() view returns (uint256 difficulty)", "function getCurrentBlockGasLimit() view returns (uint256 gaslimit)", "function getCurrentBlockTimestamp() view returns (uint256 timestamp)", "function getEthBalance(address addr) view returns (uint256 balance)", "function getLastBlockHash() view returns (bytes32 blockHash)", "function tryAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (Result[] memory returnData)", "function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData)"]);
 
 const moduleType$6 = "evm-native";
+const EvmNativeTokenConfigSchema = TokenConfigBaseSchema;
 const EvmNativeModule = hydrate => {
   const {
     chainConnectors,
@@ -1608,29 +1626,34 @@ const EvmNativeModule = hydrate => {
      * 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(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(networkId);
-      const nativeToken = {
-        platform: "ethereum",
-        id,
-        type: "evm-native",
-        isDefault: true,
-        symbol,
-        decimals,
-        name,
-        logo: moduleConfig?.logo,
-        networkId
-      };
-      if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol;
-      if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId;
-      if (moduleConfig?.mirrorOf) nativeToken.mirrorOf = moduleConfig?.mirrorOf;
-      if (moduleConfig?.noDiscovery) nativeToken.noDiscovery = moduleConfig?.noDiscovery;
-      return {
-        [nativeToken.id]: nativeToken
-      };
+    async fetchEvmChainTokens() {
+      //  networkId, chainMeta, moduleConfig, tokens
+      // TODO ? seems unneeded, this info is set on the EthNetworkConfig["nativeCurrency"] field
+      return {};
+
+      // const symbol = moduleConfig?.symbol ?? "ETH"
+      // const decimals = typeof moduleConfig?.decimals === "number" ? moduleConfig.decimals : 18
+      // const name = moduleConfig?.name ?? symbol
+
+      // const id = evmNativeTokenId(networkId)
+      // const nativeToken: EvmNativeToken = {
+      //   platform: "ethereum",
+      //   id,
+      //   type: "evm-native",
+      //   isDefault: true,
+      //   symbol,
+      //   decimals,
+      //   name,
+      //   logo: moduleConfig?.logo,
+      //   networkId,
+      // }
+
+      // if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol
+      // if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId
+      // if (moduleConfig?.mirrorOf) nativeToken.mirrorOf = moduleConfig?.mirrorOf
+      // if (moduleConfig?.noDiscovery) nativeToken.noDiscovery = moduleConfig?.noDiscovery
+
+      // return { [nativeToken.id]: nativeToken }
     },
     async subscribeBalances({
       addressesByToken,
@@ -2372,6 +2395,36 @@ const uniswapV2PairAbi = [{
 }];
 
 const moduleType$5 = "evm-uniswapv2";
+const EvmUniswapV2TokenConfigSchema = TokenConfigBaseSchema.extend({
+  contractAddress: EvmUniswapV2TokenSchema.shape.contractAddress,
+  // the ones below are unused and prone to error, feels better to always fetch these from chain
+  symbol0: EvmUniswapV2TokenSchema.shape.symbol0.optional(),
+  symbol1: EvmUniswapV2TokenSchema.shape.symbol1.optional(),
+  decimals0: EvmUniswapV2TokenSchema.shape.decimals0.optional(),
+  decimals1: EvmUniswapV2TokenSchema.shape.decimals1.optional(),
+  tokenAddress0: EvmUniswapV2TokenSchema.shape.tokenAddress0.optional(),
+  tokenAddress1: EvmUniswapV2TokenSchema.shape.tokenAddress1.optional(),
+  coingeckoId0: EvmUniswapV2TokenSchema.shape.coingeckoId0.optional(),
+  coingeckoId1: EvmUniswapV2TokenSchema.shape.coingeckoId1.optional()
+});
+
+//  {
+//   pools?: Array<
+//     {
+//       contractAddress?: `0x${string}`
+//       decimals?: number
+//       symbol0?: string
+//       symbol1?: string
+//       decimals0?: number
+//       decimals1?: number
+//       tokenAddress0?: `0x${string}`
+//       tokenAddress1?: `0x${string}`
+//       coingeckoId0?: string
+//       coingeckoId1?: string
+//     } & BalancesConfigTokenParams
+//   >
+// }
+
 const EvmUniswapV2Module = hydrate => {
   const {
     chainConnectors,
@@ -2387,9 +2440,9 @@ const EvmUniswapV2Module = hydrate => {
         extra: null
       };
     },
-    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig) {
+    async fetchEvmChainTokens(chainId, _chainMeta, moduleConfig, pools) {
       const tokens = {};
-      for (const tokenConfig of moduleConfig?.pools ?? []) {
+      for (const tokenConfig of pools ?? []) {
         const {
           contractAddress,
           decimals,
@@ -2679,7 +2732,9 @@ const getSpecVersion = async (chainConnector, networkId) => {
 const CACHE$1 = new Map();
 const getMetadataRpc = async (chainConnector, networkId) => {
   if (CACHE$1.has(networkId)) return CACHE$1.get(networkId);
-  const pResult = fetchBestMetadata((...args) => chainConnector.send(networkId, ...args), true // allow fallback to 14 as modules dont use any v15 or v16 specifics yet
+  const pResult = fetchBestMetadata((method, params, isCacheable) => chainConnector.send(networkId, method, params, isCacheable, {
+    expectErrors: true
+  }), true // allow fallback to 14 as modules dont use any v15 or v16 specifics yet
   );
   CACHE$1.set(networkId, pResult);
   try {
@@ -2703,6 +2758,8 @@ const POOL = new PQueue({
 });
 const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion, signal) => {
   if (CACHE.has(networkId)) return CACHE.get(networkId);
+  if (!signal) log.warn("[miniMetadata] getMiniMetadatas called without signal, this may hang the updates", new Error("No signal provided") // this will show the stack trace
+  );
   const pResult = POOL.add(() => fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion), {
     signal
   });
@@ -2718,9 +2775,10 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
     CACHE.delete(networkId);
   }
 };
+const DotBalanceModuleTypeSchema = z.keyof(DotNetworkBalancesConfigSchema);
 const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
   const start = performance.now();
-  log.debug("[miniMetadata] fetching minimetadatas for %s", chainId);
+  log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
   try {
     const metadataRpc = await getMetadataRpc(chainConnector, chainId);
     signal?.throwIfAborted();
@@ -2731,10 +2789,14 @@ const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, sp
     const modules = defaultBalanceModules.map(mod => mod({
       chainConnectors,
       chaindataProvider
-    })).filter(mod => mod.type.startsWith("substrate-"));
+    })).filter(mod => DotBalanceModuleTypeSchema.safeParse(mod.type).success);
     return Promise.all(modules.map(async mod => {
       const source = mod.type;
-      const chainMeta = await mod.fetchSubstrateChainMeta(chainId, {}, metadataRpc);
+      const chain = await chaindataProvider.chainById(chainId);
+      const balancesConfig = chain?.balancesConfig?.[mod.type];
+      const chainMeta = await mod.fetchSubstrateChainMeta(chainId, balancesConfig,
+      // TODO fix typings
+      metadataRpc);
       return {
         id: deriveMiniMetadataId({
           source,
@@ -3060,10 +3122,23 @@ const decompress = data => {
 };
 
 const moduleType$4 = "substrate-assets";
+const SubAssetsTokenConfigSchema = TokenConfigBaseSchema.extend({
+  assetId: SubAssetsTokenSchema.shape.assetId,
+  existentialDeposit: SubAssetsTokenSchema.shape.existentialDeposit
+});
 const UNSUPPORTED_CHAIN_META$3 = {
   miniMetadata: null,
   extra: null
 };
+
+//  {
+//   tokens?: Array<
+//     {
+//       assetId: number | string
+//     } & BalancesConfigTokenParams
+//   >
+// }
+
 const SubAssetsModule = hydrate => {
   const {
     chainConnectors,
@@ -3087,8 +3162,8 @@ const SubAssetsModule = hydrate => {
         extra: null
       };
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
-      if ((moduleConfig?.tokens ?? []).length < 1) return {};
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig, tokens) {
+      if (!tokens?.length) return {};
       const {
         miniMetadata
       } = chainMeta;
@@ -3097,8 +3172,8 @@ const SubAssetsModule = hydrate => {
       const scaleBuilder = getDynamicBuilder(getLookupFn(metadata));
       const assetCoder = scaleBuilder.buildStorage("Assets", "Asset");
       const metadataCoder = scaleBuilder.buildStorage("Assets", "Metadata");
-      const tokens = {};
-      for (const tokenConfig of moduleConfig?.tokens ?? []) {
+      const tokenList = {};
+      for (const tokenConfig of tokens ?? []) {
         try {
           const assetId = String(tokenConfig.assetId);
           const assetStateKey = tryEncode(assetCoder, BigInt(assetId)) ?? tryEncode(assetCoder, assetId);
@@ -3130,13 +3205,13 @@ const SubAssetsModule = hydrate => {
           }
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokens[token.id] = token;
+          tokenList[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-assets token ${tokenConfig.assetId} (${tokenConfig.symbol}) on ${chainId}`, error);
           continue;
         }
       }
-      return tokens;
+      return tokenList;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
@@ -3166,10 +3241,10 @@ const SubAssetsModule = hydrate => {
         }
       }));
       return () => {
-        controller.abort();
         pUnsubs.then(unsubs => {
           unsubs.forEach(unsubscribe => unsubscribe());
         });
+        controller.abort();
       };
     },
     async fetchBalances(addressesByToken) {
@@ -3353,6 +3428,19 @@ const UNSUPPORTED_CHAIN_META$2 = {
   miniMetadata: null,
   extra: null
 };
+const SubForeignAssetsTokenConfigSchema = TokenConfigBaseSchema.extend({
+  onChainId: SubForeignAssetsTokenSchema.shape.onChainId,
+  existentialDeposit: SubForeignAssetsTokenSchema.shape.existentialDeposit
+});
+
+//  {
+//   tokens?: Array<
+//     {
+//       onChainId: string
+//     } & BalancesConfigTokenParams
+//   >
+// }
+
 const SubForeignAssetsModule = hydrate => {
   const {
     chainConnectors,
@@ -3377,8 +3465,8 @@ const SubForeignAssetsModule = hydrate => {
         extra: null
       };
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
-      if ((moduleConfig?.tokens ?? []).length < 1) return {};
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig, tokens) {
+      if (!tokens?.length) return {};
       const {
         miniMetadata
       } = chainMeta;
@@ -3388,8 +3476,8 @@ const SubForeignAssetsModule = hydrate => {
       const scaleBuilder = getDynamicBuilder(getLookupFn(unifiedMetadata));
       const assetCoder = scaleBuilder.buildStorage("ForeignAssets", "Asset");
       const metadataCoder = scaleBuilder.buildStorage("ForeignAssets", "Metadata");
-      const tokens = {};
-      for (const tokenConfig of moduleConfig?.tokens ?? []) {
+      const tokenList = {};
+      for (const tokenConfig of tokens ?? []) {
         try {
           const onChainId = (() => {
             try {
@@ -3424,13 +3512,13 @@ const SubForeignAssetsModule = hydrate => {
           };
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokens[token.id] = token;
+          tokenList[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-foreignassets token ${tokenConfig.onChainId} (${tokenConfig.symbol}) on ${chainId}`, error?.message ?? error);
           continue;
         }
       }
-      return tokens;
+      return tokenList;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
@@ -3459,10 +3547,10 @@ const SubForeignAssetsModule = hydrate => {
         }
       }));
       return () => {
-        controller.abort();
         pUnsubs.then(unsubs => {
           unsubs.forEach(unsubscribe => unsubscribe());
         });
+        controller.abort();
       };
     },
     async fetchBalances(addressesByToken) {
@@ -3649,263 +3737,6 @@ const asObservable = handler => (...args) => new Observable(subscriber => {
   return unsubscribe;
 });
 
-/**
- * Crowdloan contributions are stored in the `childstate` key returned by this function.
- */
-const crowdloanFundContributionsChildKey = fundIndex => u8aToHex(u8aConcat(":child_storage:default:", blake2AsU8a(u8aConcat("crowdloan", u32.enc(fundIndex)))));
-
-// TODO make this method chain-specific
-async function subscribeCrowdloans(chaindataProvider, chainConnector, addressesByToken, callback, signal) {
-  const allChains = await chaindataProvider.chainsById();
-  const tokens = await chaindataProvider.tokensById();
-
-  // there should be only one network here when subscribing to balances, we've split it up by network at the top level
-  const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
-  const miniMetadatas = new Map();
-  for (const networkId of networkIds) miniMetadatas.set(networkId, await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native"));
-  const crowdloanTokenIds = Object.entries(tokens).filter(([, token]) => {
-    // ignore non-native tokens
-    if (token.type !== "substrate-native") return;
-    // ignore tokens on chains with no crowdloans pallet
-    const miniMetadata = miniMetadatas.get(token.networkId);
-    return typeof miniMetadata?.extra?.crowdloanPalletId === "string";
-  }).map(([tokenId]) => tokenId);
-
-  // crowdloan contributions can only be done by the native token on chains with the crowdloan pallet
-  const addressesByCrowdloanToken = Object.fromEntries(Object.entries(addressesByToken)
-  // remove ethereum addresses
-  .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
-  // remove tokens which aren't crowdloan tokens
-  .filter(([tokenId]) => crowdloanTokenIds.includes(tokenId)));
-  const uniqueChainIds = getUniqueChainIds(addressesByCrowdloanToken, tokens);
-  const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
-  const chainStorageCoders = buildStorageCoders({
-    chainIds: uniqueChainIds,
-    chains,
-    miniMetadatas,
-    coders: {
-      parachains: ["Paras", "Parachains"],
-      funds: ["Crowdloan", "Funds"]
-    }
-  });
-  const tokenSubscriptions = [];
-  for (const [tokenId, addresses] of Object.entries(addressesByCrowdloanToken)) {
-    const token = tokens[tokenId];
-    if (!token) {
-      log.warn(`Token ${tokenId} not found`);
-      continue;
-    }
-    if (token.type !== "substrate-native") {
-      log.debug(`This module doesn't handle tokens of type ${token.type}`);
-      continue;
-    }
-    const chainId = token.networkId;
-    if (!chainId) {
-      log.warn(`Token ${tokenId} has no chain`);
-      continue;
-    }
-    const chain = chains[chainId];
-    if (!chain) {
-      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
-      continue;
-    }
-    const subscribeParaIds = callback => {
-      const scaleCoder = chainStorageCoders.get(chainId)?.parachains;
-      const queries = [0].flatMap(() => {
-        const stateKey = encodeStateKey(scaleCoder);
-        if (!stateKey) return [];
-        const decodeResult = change => {
-          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-          const decoded = decodeScale(scaleCoder, change, `Failed to decode parachains on chain ${chainId}`);
-          const paraIds = decoded ?? [];
-          return paraIds;
-        };
-        return {
-          chainId,
-          stateKey,
-          decodeResult
-        };
-      });
-      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-      return () => subscription.then(unsubscribe => unsubscribe());
-    };
-    const subscribeParaFundIndexes = (paraIds, callback) => {
-      const scaleCoder = chainStorageCoders.get(chainId)?.funds;
-      const queries = paraIds.flatMap(paraId => {
-        const stateKey = encodeStateKey(scaleCoder, `Invalid paraId in ${chainId} funds query ${paraId}`, paraId);
-        if (!stateKey) return [];
-        const decodeResult = change => {
-          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-          const decoded = decodeScale(scaleCoder, change, `Failed to decode paras on chain ${chainId}`);
-          const firstPeriod = decoded?.first_period?.toString?.() ?? "";
-          const lastPeriod = decoded?.last_period?.toString?.() ?? "";
-          const fundPeriod = `${firstPeriod}-${lastPeriod}`;
-          const fundIndex = decoded?.fund_index ?? decoded?.trie_index;
-          return {
-            paraId,
-            fundPeriod,
-            fundIndex
-          };
-        };
-        return {
-          chainId,
-          stateKey,
-          decodeResult
-        };
-      });
-      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-      return () => subscription.then(unsubscribe => unsubscribe());
-    };
-    const subscribeFundContributions = (funds, addresses, callback) => {
-      // TODO: Watch system_events in order to subscribe to changes, then redo the contributions query when changes are detected:
-      // https://github.com/polkadot-js/api/blob/8fe02a14345b57e6abb8f7f2c2b624cf70c51b23/packages/api-derive/src/crowdloan/ownContributions.ts#L32-L47
-      //
-      // For now we just re-fetch all contributions on a timer and then only send them to the subscription callback when they have changed
-
-      const queries = funds.map(({
-        paraId,
-        fundIndex
-      }) => ({
-        paraId,
-        fundIndex,
-        addresses,
-        childKey: crowdloanFundContributionsChildKey(fundIndex),
-        storageKeys: addresses.map(address => u8aToHex(decodeAnyAddress(address)))
-      }));
-
-      // track whether our caller is still subscribed
-      let subscriptionActive = true;
-      let previousContributions = null;
-      const fetchContributions = async () => {
-        try {
-          const results = await Promise.all(queries.map(async ({
-            paraId,
-            fundIndex,
-            addresses,
-            childKey,
-            storageKeys
-          }) => ({
-            paraId,
-            fundIndex,
-            addresses,
-            result: await chainConnector.send(chainId, "childstate_getStorageEntries", [childKey, storageKeys])
-          })));
-          const contributions = results.flatMap(queryResult => {
-            const {
-              paraId,
-              fundIndex,
-              addresses,
-              result
-            } = queryResult;
-            return (Array.isArray(result) ? result : []).flatMap((encoded, index) => {
-              const amount = (() => {
-                try {
-                  return typeof encoded === "string" ? u128.dec(encoded) ?? 0n : 0n;
-                } catch {
-                  return 0n;
-                }
-              })().toString();
-              return {
-                paraId,
-                fundIndex,
-                address: addresses[index],
-                amount
-              };
-            });
-          });
-
-          // ignore these results if our caller has tried to close this subscription
-          if (!subscriptionActive) return;
-
-          // ignore these results if they're the same as what we previously fetched
-          if (isEqual(previousContributions, contributions)) return;
-          previousContributions = contributions;
-          callback(null, contributions);
-        } catch (error) {
-          callback(error);
-        }
-      };
-
-      // set up polling for contributions
-      const crowdloanContributionsPollInterval = 60_000; // 60_000ms === 1 minute
-      const pollContributions = async () => {
-        if (!subscriptionActive) return;
-        try {
-          await fetchContributions();
-        } catch (error) {
-          // log any errors, but don't cancel the poll for contributions when one fetch fails
-          log.error(error);
-        }
-        if (!subscriptionActive) return;
-        setTimeout(pollContributions, crowdloanContributionsPollInterval);
-      };
-
-      // start polling
-      pollContributions();
-      return () => {
-        // stop polling
-        subscriptionActive = false;
-      };
-    };
-    const paraIds$ = asObservable(subscribeParaIds)().pipe(scan((_, next) => Array.from(new Set(next.flatMap(paraIds => paraIds))), []), share());
-    const fundIndexesByParaId$ = paraIds$.pipe(map(paraIds => asObservable(subscribeParaFundIndexes)(paraIds)), switchAll(), scan((state, next) => {
-      for (const fund of next) {
-        const {
-          paraId,
-          fundIndex
-        } = fund;
-        if (typeof fundIndex === "number") {
-          state.set(paraId, (state.get(paraId) ?? new Set()).add(fundIndex));
-        }
-      }
-      return state;
-    }, new Map()));
-    const contributionsByAddress$ = fundIndexesByParaId$.pipe(map(fundIndexesByParaId => Array.from(fundIndexesByParaId).flatMap(([paraId, fundIndexes]) => Array.from(fundIndexes).map(fundIndex => ({
-      paraId,
-      fundIndex
-    })))), map(funds => asObservable(subscribeFundContributions)(funds, addresses)), switchAll(), scan((state, next) => {
-      for (const contribution of next) {
-        const {
-          address
-        } = contribution;
-        state.set(address, (state.get(address) ?? new Set()).add(contribution));
-      }
-      return state;
-    }, new Map()));
-    const subscription = contributionsByAddress$.subscribe({
-      next: contributionsByAddress => {
-        const balances = Array.from(contributionsByAddress).map(([address, contributions]) => {
-          return {
-            source: "substrate-native",
-            status: "live",
-            address,
-            networkId: chainId,
-            tokenId,
-            values: Array.from(contributions).map(({
-              amount,
-              paraId
-            }) => ({
-              type: "crowdloan",
-              label: "crowdloan",
-              source: "crowdloan",
-              amount: amount,
-              meta: {
-                paraId
-              }
-            }))
-          };
-        });
-        if (balances.length > 0) callback(null, balances);
-      },
-      error: error => callback(error)
-    });
-    tokenSubscriptions.push(() => subscription.unsubscribe());
-  }
-  return () => tokenSubscriptions.forEach(unsub => unsub());
-}
-
 /**
  * Each nominationPool in the nominationPools pallet has access to some accountIds which have no
  * associated private key. Instead, they are derived from this function.
@@ -3937,6 +3768,7 @@ async function subscribeNompoolStaking(chaindataProvider, chainConnector, addres
     const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native");
     miniMetadatas.set(networkId, miniMetadata);
   }
+  signal?.throwIfAborted();
   const nomPoolTokenIds = Object.entries(tokens).filter(([, token]) => {
     // ignore non-native tokens
     if (token.type !== "substrate-native") return false;
@@ -4254,9 +4086,10 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
   const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
   const miniMetadatas = new Map();
   for (const networkId of networkIds) {
-    const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native");
+    const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native", signal);
     miniMetadatas.set(networkId, miniMetadata);
   }
+  signal?.throwIfAborted();
   const subtensorTokenIds = Object.entries(tokens).filter(([, token]) => {
     // ignore non-native tokens
     if (token.type !== "substrate-native") return false;
@@ -4462,7 +4295,9 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
     });
 
     // use the abortController to tear the subscription down when we don't need it anymore
-    abortController.signal.onabort = () => subscription.unsubscribe();
+    abortController.signal.addEventListener("abort", () => {
+      subscription.unsubscribe();
+    });
   }
   return () => abortController.abort();
 }
@@ -4548,6 +4383,10 @@ const getLockTitle = (lock, {
 
 const moduleType$2 = "substrate-native";
 
+//  {
+//   disable?: boolean
+// } & BalancesConfigTokenParams
+
 /**
  * Function to merge two 'sub sources' of the same balance together, or
  * two instances of the same balance with different values.
@@ -5025,6 +4864,7 @@ const UNSUPPORTED_CHAIN_META$1 = {
   miniMetadata: null,
   extra: null
 };
+const SubNativeTokenConfigSchema = TokenConfigBaseSchema;
 const SubNativeModule = hydrate => {
   const {
     chainConnectors,
@@ -5040,7 +4880,7 @@ const SubNativeModule = hydrate => {
   // subscribeBalances was split by network to prevent all subs to wait for all minimetadatas to be ready.
   // however the multichain logic in there is so deep in the function below that i had to keep it as-is, and call it by per-network chunks
   // TODO refactor this be actually network specific
-  const subscribeChainBalances = async (chainId, opts, callback) => {
+  const subscribeChainBalances = (chainId, opts, callback, signal) => {
     const {
       addressesByToken,
       initialBalances
@@ -5139,13 +4979,19 @@ const SubNativeModule = hydrate => {
       return from(queryCache.getQueries(newAddressesByToken)).pipe(switchMap(baseQueries => {
         return new Observable(subscriber => {
           if (!chainConnectors.substrate) return;
-          const unsubSubtensorStaking = subscribeSubtensorStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("subtensor-staking"));
-          const unsubNompoolStaking = subscribeNompoolStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("nompools-staking"));
-          const unsubCrowdloans = subscribeCrowdloans(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("crowdloan"));
+          const unsubSubtensorStaking = subscribeSubtensorStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("subtensor-staking"), signal);
+          const unsubNompoolStaking = subscribeNompoolStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("nompools-staking"), signal);
+          // const unsubCrowdloans = subscribeCrowdloans(
+          //   chaindataProvider,
+          //   chainConnectors.substrate,
+          //   newAddressesByToken,
+          //   handleUpdateForSource("crowdloan"),
+          //   signal,
+          // )
           const unsubBase = subscribeBase(baseQueries, chainConnectors.substrate, handleUpdateForSource("base"));
           subscriber.add(async () => (await unsubSubtensorStaking)());
           subscriber.add(async () => (await unsubNompoolStaking)());
-          subscriber.add(async () => (await unsubCrowdloans)());
+          // subscriber.add(async () => (await unsubCrowdloans)())
           subscriber.add(async () => (await unsubBase)());
         });
       }));
@@ -5177,8 +5023,13 @@ 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.withConcurrency(POLLING_WINDOW_SIZE).for(nonCurrentTokens).process(async nonCurrentTokenId => await poll({
+    const pool = new PQueue({
+      concurrency: POLLING_WINDOW_SIZE
+    });
+    nonCurrentTokens.forEach(nonCurrentTokenId => pool.add(() => poll({
       [nonCurrentTokenId]: addressesByToken[nonCurrentTokenId]
+    }), {
+      signal
     }));
 
     // now poll every 30s on chains which are not subscriptionTokens
@@ -5191,7 +5042,9 @@ const SubNativeModule = hydrate => {
     Object.keys(addressesByToken).filter(tokenId => !subscribedTokenIds.includes(tokenId))), exhaustMap(tokenIds => from(arrayChunk(tokenIds, POLLING_WINDOW_SIZE)).pipe(concatMap(async tokenChunk => {
       // tokenChunk is a chunk of tokenIds with size POLLING_WINDOW_SIZE
       const pollingTokenAddresses = Object.fromEntries(tokenChunk.map(tokenId => [tokenId, addressesByToken[tokenId]]));
-      await poll(pollingTokenAddresses);
+      await pool.add(() => poll(pollingTokenAddresses), {
+        signal
+      });
       return true;
     })))).subscribe();
     return () => {
@@ -5236,7 +5089,7 @@ const SubNativeModule = hydrate => {
       };
       const existentialDeposit = getConstantValue("Balances", "ExistentialDeposit")?.toString();
       const nominationPoolsPalletId = getConstantValue("NominationPools", "PalletId")?.asText();
-      const crowdloanPalletId = getConstantValue("Crowdloan", "PalletId")?.asText();
+      const crowdloanPalletId = getConstantValue("Crowdloan", "PalletId")?.asText(); // TODO yeet
       const hasSubtensorPallet = getConstantValue("SubtensorModule", "KeySwapCost") !== undefined;
 
       //
@@ -5259,10 +5112,13 @@ const SubNativeModule = hydrate => {
       }, {
         pallet: "Crowdloan",
         items: ["Funds"]
-      }, {
+      },
+      // TODO yeet
+      {
         pallet: "Paras",
         items: ["Parachains"]
       },
+      // TODO yeet
       // 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
       {
@@ -5305,22 +5161,24 @@ const SubNativeModule = hydrate => {
       const {
         existentialDeposit
       } = chainMeta.extra ?? {};
+      if (existentialDeposit === undefined) log.warn("Substrate native module: existentialDeposit is undefined for %s, using 0", chainId);
       const id = subNativeTokenId(chainId);
       const nativeToken = {
         id,
         type: "substrate-native",
         platform: "polkadot",
-        isDefault: moduleConfig?.isDefault ?? true,
+        isDefault: true,
         symbol: symbol,
-        name: moduleConfig?.name ?? symbol,
+        name: symbol,
         decimals: decimals,
-        logo: moduleConfig?.logo,
         existentialDeposit: existentialDeposit ?? "0",
         networkId: chainId
       };
-      if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol;
-      if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId;
-      if (moduleConfig?.mirrorOf) nativeToken.mirrorOf = moduleConfig?.mirrorOf;
+
+      // if (moduleConfig?.symbol) nativeToken.symbol = moduleConfig?.symbol
+      // if (moduleConfig?.coingeckoId) nativeToken.coingeckoId = moduleConfig?.coingeckoId
+      // if (moduleConfig?.mirrorOf) nativeToken.mirrorOf = moduleConfig?.mirrorOf
+
       return {
         [nativeToken.id]: nativeToken
       };
@@ -5352,11 +5210,11 @@ const SubNativeModule = hydrate => {
         return subscribeChainBalances(networkId, {
           addressesByToken: addressesByTokenByNetwork[networkId] ?? {},
           initialBalances: initialBalancesByNetwork[networkId] ?? []
-        }, safeCallback);
+        }, safeCallback, controller.signal);
       }));
       return () => {
-        controller.abort();
         unsubsribeFns.then(fns => fns.forEach(unsubscribe => unsubscribe()));
+        controller.abort();
       };
     },
     fetchBalances,
@@ -6574,6 +6432,22 @@ var psp22Abi = {
 };
 
 const moduleType$1 = "substrate-psp22";
+const SubPsp22TokenConfigSchema = TokenConfigBaseSchema.extend({
+  contractAddress: SubPsp22TokenSchema.shape.contractAddress,
+  existentialDeposit: SubPsp22TokenSchema.shape.existentialDeposit.optional()
+});
+
+// {
+//   tokens?: Array<
+//     {
+//       symbol?: string
+//       decimals?: number
+//       ed?: string
+//       contractAddress: string
+//     } & BalancesConfigTokenParams
+//   >
+// }
+
 const SubPsp22Module = hydrate => {
   const {
     chainConnectors,
@@ -6590,7 +6464,8 @@ const SubPsp22Module = hydrate => {
         extra: null
       };
     },
-    async fetchSubstrateChainTokens(chainId, _chainMeta, moduleConfig) {
+    async fetchSubstrateChainTokens(chainId, _chainMeta, moduleConfig, tokens) {
+      if (!tokens?.length) return {};
       // const { isTestnet } = chainMeta
 
       const registry = new TypeRegistry();
@@ -6602,12 +6477,12 @@ const SubPsp22Module = hydrate => {
         chainId,
         registry
       });
-      const tokens = {};
-      for (const tokenConfig of moduleConfig?.tokens ?? []) {
+      const tokenList = {};
+      for (const tokenConfig of tokens ?? []) {
         try {
           let symbol = tokenConfig?.symbol ?? "Unit";
           let decimals = tokenConfig?.decimals ?? 0;
-          const existentialDeposit = tokenConfig?.ed ?? "0";
+          const existentialDeposit = tokenConfig?.existentialDeposit ?? "0";
           const contractAddress = tokenConfig?.contractAddress ?? undefined;
           if (contractAddress === undefined) continue;
           await (async () => {
@@ -6640,13 +6515,13 @@ const SubPsp22Module = hydrate => {
           };
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokens[token.id] = token;
+          tokenList[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-psp22 token ${tokenConfig.contractAddress} (${tokenConfig.symbol}) on ${chainId}`, error?.message ?? error);
           continue;
         }
       }
-      return tokens;
+      return tokenList;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
@@ -6821,11 +6696,28 @@ const fetchBalances = async (chainConnector, tokens, addressesByToken) => {
 };
 
 const moduleType = "substrate-tokens";
+const SubTokensTokenConfigSchema = TokenConfigBaseSchema.extend({
+  onChainId: SubTokensTokenSchema.shape.onChainId,
+  existentialDeposit: SubTokensTokenSchema.shape.existentialDeposit
+});
 const defaultPalletId = "Tokens";
 const UNSUPPORTED_CHAIN_META = {
   miniMetadata: null,
   extra: {}
 };
+
+//  {
+//   palletId?: string // TODO unlikely it will ever be used - remove this ?
+//   tokens?: Array<
+//     {
+//       symbol?: string
+//       decimals?: number
+//       ed?: string
+//       onChainId?: string | number
+//     } & BalancesConfigTokenParams
+//   >
+// }
+
 const SubTokensModule = hydrate => {
   const {
     chainConnectors,
@@ -6851,13 +6743,14 @@ const SubTokensModule = hydrate => {
         }
       };
     },
-    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig) {
-      const tokens = {};
-      for (const tokenConfig of moduleConfig?.tokens ?? []) {
+    async fetchSubstrateChainTokens(chainId, chainMeta, moduleConfig, tokens) {
+      const tokenList = {};
+      for (const tokenConfig of tokens ?? []) {
         try {
+          // TODO fetch metadata from chain, like we do for assets
           const symbol = tokenConfig?.symbol ?? "Unit";
           const decimals = tokenConfig?.decimals ?? 0;
-          const existentialDeposit = tokenConfig?.ed ?? "0";
+          const existentialDeposit = tokenConfig?.existentialDeposit ?? "0";
           const onChainId = tokenConfig?.onChainId ?? undefined;
           if (onChainId === undefined) continue;
           const id = subTokensTokenId(chainId, onChainId);
@@ -6876,13 +6769,13 @@ const SubTokensModule = hydrate => {
           };
           if (tokenConfig?.coingeckoId) token.coingeckoId = tokenConfig?.coingeckoId;
           if (tokenConfig?.mirrorOf) token.mirrorOf = tokenConfig?.mirrorOf;
-          tokens[token.id] = token;
+          tokenList[token.id] = token;
         } catch (error) {
           log.error(`Failed to build substrate-tokens token ${tokenConfig.onChainId} (${tokenConfig.symbol}) on ${chainId}`, error?.message ?? error);
           continue;
         }
       }
-      return tokens;
+      return tokenList;
     },
     // TODO: Don't create empty subscriptions
     async subscribeBalances({
@@ -6912,10 +6805,10 @@ const SubTokensModule = hydrate => {
         }
       }));
       return () => {
-        controller.abort();
         pUnsubs.then(unsubs => {
           unsubs.forEach(unsubscribe => unsubscribe());
         });
+        controller.abort();
       };
     },
     async fetchBalances(addressesByToken) {
@@ -7124,4 +7017,4 @@ async function buildQueries(chainConnector, chaindataProvider, addressesByToken,
 
 const defaultBalanceModules = [EvmErc20Module, EvmNativeModule, EvmUniswapV2Module, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule];
 
-export { Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20Module, EvmNativeModule, EvmTokenFetcher, EvmUniswapV2Module, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsModule, SubForeignAssetsModule, SubNativeModule, SubPsp22Module, SubTokensModule, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildNetworkStorageCoders, buildStorageCoders, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20Abi, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getUniqueChainIds, getValueId, includeInTotalExtraAmount, makeContractCaller, uniswapV2PairAbi };
+export { Balance, BalanceFormatter, BalanceValueGetter, Balances, Change24hCurrencyFormatter, DefaultBalanceModule, EvmErc20Module, EvmErc20TokenConfigSchema, EvmNativeModule, EvmNativeTokenConfigSchema, EvmTokenFetcher, EvmUniswapV2Module, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, RpcStateQueryHelper, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsModule, SubAssetsTokenConfigSchema, SubForeignAssetsModule, SubForeignAssetsTokenConfigSchema, SubNativeModule, SubNativeTokenConfigSchema, SubPsp22Module, SubPsp22TokenConfigSchema, SubTokensModule, SubTokensTokenConfigSchema, SumBalancesFormatter, TalismanBalancesDatabase, abiMulticall, balances, buildNetworkStorageCoders, buildStorageCoders, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, compress, configureStore, db, decodeOutput, decompress, defaultBalanceModules, deriveMiniMetadataId, detectTransferMethod, erc20Abi, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getUniqueChainIds, getValueId, includeInTotalExtraAmount, makeContractCaller, uniswapV2PairAbi };