@talismn/balances 0.0.0-pr2075-20250710043243 → 0.0.0-pr2075-20250710071608

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

@@ -3,7 +3,7 @@
 var chaindataProvider = require('@talismn/chaindata-provider');
 var util = require('@talismn/util');
 var viem = require('viem');
-var lodash = require('lodash');
+var lodashEs = require('lodash-es');
 var z = require('zod/v4');
 var anylogger = require('anylogger');
 var rxjs = require('rxjs');
@@ -12,7 +12,7 @@ var tokenRates = require('@talismn/token-rates');
 var BigNumber = require('bignumber.js');
 var utils = require('@polkadot-api/utils');
 var polkadotApi = require('polkadot-api');
-var upperFirst = require('lodash/upperFirst');
+var upperFirst = require('lodash-es/upperFirst');
 var scaleTs = require('scale-ts');
 var apiContract = require('@polkadot/api-contract');
 var types = require('@polkadot/types');
@@ -821,7 +821,7 @@ const fetchTokens$8 = async ({
     };
     const cached2 = cache[tokenId] && TokenCacheSchema$1.safeParse(cache[tokenId]).data;
     if (cached2?.isValid === false) continue;
-    const token = lodash.assign(base, cached2?.isValid ? lodash.omit(cached2, ["isValid"]) : {}, tokenConfig);
+    const token = lodashEs.assign(base, cached2?.isValid ? lodashEs.omit(cached2, ["isValid"]) : {}, tokenConfig);
     const parsed = chaindataProvider.EvmErc20TokenSchema.safeParse(token);
     if (!parsed.success) {
       log.warn("Ignoring token with invalid EvmErc20TokenSchema", {
@@ -896,7 +896,7 @@ const subscribeBalances$8 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }).pipe(rxjs.distinctUntilChanged(lodashEs.isEqual));
 };
 
 const EvmErc20BalanceModule = {
@@ -1043,7 +1043,7 @@ const fetchTokens$7 = async ({
 }) => {
   // assume there is one and only one token in the array
   if (tokens.length !== 1) throw new Error("EVM Native module expects the nativeCurrency to be passed as a single token in the array");
-  const token = lodash.assign({
+  const token = lodashEs.assign({
     id: chaindataProvider.evmNativeTokenId(networkId),
     type: MODULE_TYPE$7,
     platform: PLATFORM$7,
@@ -1116,7 +1116,7 @@ const subscribeBalances$7 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }).pipe(rxjs.distinctUntilChanged(lodashEs.isEqual));
 };
 
 const EvmNativeBalanceModule = {
@@ -1286,19 +1286,6 @@ const getUniswapV2PairContractData = async (client, contractAddress) => {
   };
 };
 
-// const TokenCacheSchema = EvmUniswapV2TokenSchema.pick({
-//   id: true,
-//   symbol: true,
-//   decimals: true,
-//   name: true,
-//   tokenAddress0: true,
-//   tokenAddress1: true,
-//   decimals0: true,
-//   decimals1: true,
-//   symbol0: true,
-//   symbol1: true,
-// })
-
 const TokenCacheSchema = z__default.default.discriminatedUnion("isValid", [z__default.default.strictObject({
   id: chaindataProvider.EvmUniswapV2TokenSchema.shape.id,
   isValid: z__default.default.literal(true),
@@ -1382,7 +1369,7 @@ const fetchTokens$6 = async ({
     };
     const cached2 = cache[tokenId] && TokenCacheSchema.safeParse(cache[tokenId]).data;
     if (cached2?.isValid === false) continue;
-    const token = lodash.assign(base, cached2?.isValid ? lodash.omit(cached2, ["isValid"]) : {}, tokenConfig);
+    const token = lodashEs.assign(base, cached2?.isValid ? lodashEs.omit(cached2, ["isValid"]) : {}, tokenConfig);
     const parsed = chaindataProvider.EvmUniswapV2TokenSchema.safeParse(token);
     if (!parsed.success) {
       log.warn("Ignoring token with invalid schema", token);
@@ -1455,7 +1442,7 @@ const subscribeBalances$6 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }).pipe(rxjs.distinctUntilChanged(lodashEs.isEqual));
 };
 
 const EvmUniswapV2BalanceModule = {
@@ -1534,6 +1521,21 @@ const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName
   return call.value.dec(hex);
 };
 
+const hasStorageItem = (metadata, palletName, itemName) => {
+  const pallet = metadata.pallets.find(p => p.name === palletName);
+  if (!pallet || !pallet.storage) return false;
+  return pallet.storage.items.some(item => item.name === itemName);
+};
+const hasStorageItems = (metadata, palletName, itemNames) => {
+  const pallet = metadata.pallets.find(p => p.name === palletName);
+  if (!pallet || !pallet.storage) return false;
+  return itemNames.every(itemName => pallet.storage?.items.some(item => item.name === itemName));
+};
+const hasRuntimeApi = (metadata, apiName, method) => {
+  const api = metadata.apis.find(api => api.name === apiName);
+  if (!api || !api.methods) return false;
+  return api.methods.some(m => m.name === method);
+};
 const getConstantValue = (metadataRpc, pallet, constant) => {
   const {
     unifiedMetadata,
@@ -1548,7 +1550,6 @@ const getConstantValue = (metadataRpc, pallet, constant) => {
   if (!encodedValue) throw new Error(`Constant ${pallet}.${constant} not found`);
   return codec.dec(encodedValue);
 };
-
 const tryGetConstantValue = (metadataRpc, pallet, constant) => {
   const {
     unifiedMetadata,
@@ -1564,22 +1565,6 @@ const tryGetConstantValue = (metadataRpc, pallet, constant) => {
   return codec.dec(encodedValue);
 };
 
-const hasStorageItem = (metadata, palletName, itemName) => {
-  const pallet = metadata.pallets.find(p => p.name === palletName);
-  if (!pallet || !pallet.storage) return false;
-  return pallet.storage.items.some(item => item.name === itemName);
-};
-const hasStorageItems = (metadata, palletName, itemNames) => {
-  const pallet = metadata.pallets.find(p => p.name === palletName);
-  if (!pallet || !pallet.storage) return false;
-  return itemNames.every(itemName => pallet.storage?.items.some(item => item.name === itemName));
-};
-const hasRuntimeApi = (metadata, apiName, method) => {
-  const api = metadata.apis.find(api => api.name === apiName);
-  if (!api || !api.methods) return false;
-  return api.methods.some(m => m.name === method);
-};
-
 const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
   if (!miniMetadata.data) return null;
   const metadata = scale.unifyMetadata(scale.decAnyMetadata(miniMetadata.data));
@@ -1767,7 +1752,7 @@ const fetchTokens$5 = async ({
   const [assetStorageResults, metadataStorageResults] = await Promise.all([connector.send(networkId, "state_queryStorageAt", [allAssetStorageKeys]), connector.send(networkId, "state_queryStorageAt", [allMetadataStorageKeys])]);
   const assetStorageEntries = assetStorageResults[0].changes;
   const metadataStorageEntries = metadataStorageResults[0].changes;
-  const assetByAssetId = lodash.keyBy(assetStorageEntries.map(([key, value]) => {
+  const assetByAssetId = lodashEs.keyBy(assetStorageEntries.map(([key, value]) => {
     const [assetId] = assetCodec.keys.dec(key);
     const asset = assetCodec.value.dec(value);
     return {
@@ -1776,7 +1761,7 @@ const fetchTokens$5 = async ({
       isSufficient: asset.is_sufficient
     };
   }), a => a.assetId);
-  const metadataByAssetId = lodash.keyBy(metadataStorageEntries.map(([key, value]) => {
+  const metadataByAssetId = lodashEs.keyBy(metadataStorageEntries.map(([key, value]) => {
     const [assetId] = metadataCodec.keys.dec(key);
     const metadata = metadataCodec.value.dec(value);
     return {
@@ -1787,8 +1772,8 @@ const fetchTokens$5 = async ({
       symbol: metadata.symbol?.asText()
     };
   }), a => a.assetId);
-  const allTokens = lodash.keys(assetByAssetId).map(assetId => lodash.assign({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? undefined));
-  const configTokenByAssetId = lodash.keyBy(tokens, t => t.assetId);
+  const allTokens = lodashEs.keys(assetByAssetId).map(assetId => lodashEs.assign({}, assetByAssetId[assetId], metadataByAssetId[assetId] ?? undefined));
+  const configTokenByAssetId = lodashEs.keyBy(tokens, t => t.assetId);
   return allTokens.map(asset => ({
     id: chaindataProvider.subAssetTokenId(networkId, String(asset.assetId)),
     type: MODULE_TYPE$5,
@@ -1811,7 +1796,7 @@ const fetchTokens$5 = async ({
   // apply config overrides
   .map(token => {
     const configToken = configTokenByAssetId[token.assetId];
-    return configToken ? lodash.assign({}, token, configToken) : token;
+    return configToken ? lodashEs.assign({}, token, configToken) : token;
   })
   // validate results
   .filter(t => {
@@ -2919,7 +2904,7 @@ const fetchTokens$4 = async ({
   const [assetStorageResults, metadataStorageResults] = await Promise.all([connector.send(networkId, "state_queryStorageAt", [allAssetStorageKeys]), connector.send(networkId, "state_queryStorageAt", [allMetadataStorageKeys])]);
   const assetStorageEntries = assetStorageResults[0].changes;
   const metadataStorageEntries = metadataStorageResults[0].changes;
-  const assetByOnChainId = lodash.keyBy(assetStorageEntries.map(([key, value]) => {
+  const assetByOnChainId = lodashEs.keyBy(assetStorageEntries.map(([key, value]) => {
     const [decodedKey] = assetCodec.keys.dec(key);
     const onChainId = scale.papiStringify(decodedKey);
     const asset = assetCodec.value.dec(value);
@@ -2929,7 +2914,7 @@ const fetchTokens$4 = async ({
       isSufficient: asset.is_sufficient
     };
   }), a => a.onChainId);
-  const metadataByOnChainId = lodash.keyBy(metadataStorageEntries.map(([key, value]) => {
+  const metadataByOnChainId = lodashEs.keyBy(metadataStorageEntries.map(([key, value]) => {
     const [decodedKey] = metadataCodec.keys.dec(key);
     const onChainId = scale.papiStringify(decodedKey);
     const metadata = metadataCodec.value.dec(value);
@@ -2941,8 +2926,8 @@ const fetchTokens$4 = async ({
       symbol: metadata.symbol?.asText()
     };
   }), a => a.onChainId);
-  const allTokens = lodash.keys(assetByOnChainId).map(onChainId => lodash.assign({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? undefined));
-  const configTokenByOnChainId = lodash.keyBy(tokens, t => t.onChainId);
+  const allTokens = lodashEs.keys(assetByOnChainId).map(onChainId => lodashEs.assign({}, assetByOnChainId[onChainId], metadataByOnChainId[onChainId] ?? undefined));
+  const configTokenByOnChainId = lodashEs.keyBy(tokens, t => t.onChainId);
   return allTokens.map(asset => ({
     id: chaindataProvider.subForeignAssetTokenId(networkId, asset.onChainId),
     type: MODULE_TYPE$4,
@@ -2965,7 +2950,7 @@ const fetchTokens$4 = async ({
   // apply config overrides
   .map(token => {
     const configToken = configTokenByOnChainId[token.onChainId];
-    return configToken ? lodash.assign({}, token, configToken) : token;
+    return configToken ? lodashEs.assign({}, token, configToken) : token;
   })
   // validate results
   .filter(t => {
@@ -3187,7 +3172,7 @@ const fetchBalances$3 = async ({
       }))
     };
   }
-  const addresses = lodash.uniq(balanceDefs.map(def => def.address));
+  const addresses = lodashEs.uniq(balanceDefs.map(def => def.address));
   try {
     const res = await Promise.all(addresses.map(address => fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "CurrenciesApi", "accounts", [address])));
     const fetchedBalances = addresses.flatMap((address, index) => {
@@ -3199,7 +3184,7 @@ const fetchBalances$3 = async ({
         frozen: balance.frozen.toString()
       })).filter(b => b.onChainId !== undefined);
     });
-    const balancesByKey = lodash.keyBy(fetchedBalances, b => `${b.address}:${b.onChainId}`);
+    const balancesByKey = lodashEs.keyBy(fetchedBalances, b => `${b.address}:${b.onChainId}`);
     const success = tokensWithAddresses.reduce((acc, [token, addresses]) => {
       if (token.type === MODULE_TYPE$3) for (const address of addresses) {
         const rawBalance = balancesByKey[`${address}:${token.onChainId}`];
@@ -3263,7 +3248,7 @@ const fetchTokens$3 = async ({
   const allAssetStorageKeys = await connector.send(networkId, "state_getKeys", [scale.getStorageKeyPrefix("AssetRegistry", "Assets")]);
   const assetStorageResults = await connector.send(networkId, "state_queryStorageAt", [allAssetStorageKeys]);
   const assetStorageEntries = assetStorageResults[0].changes;
-  const configTokenByAssetId = lodash.keyBy(tokens, t => t.onChainId);
+  const configTokenByAssetId = lodashEs.keyBy(tokens, t => t.onChainId);
   return assetStorageEntries.map(([key, value]) => {
     // parse results
     const [onChainId] = assetsCodec.keys.dec(key);
@@ -3306,7 +3291,7 @@ const fetchTokens$3 = async ({
   // apply config overrides
   .map(token => {
     const configToken = configTokenByAssetId[token.onChainId];
-    return configToken ? lodash.assign({}, token, configToken) : token;
+    return configToken ? lodashEs.assign({}, token, configToken) : token;
   })
   // validate results
   .filter(t => {
@@ -3445,7 +3430,7 @@ const subscribeBalances$3 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }).pipe(rxjs.distinctUntilChanged(lodashEs.isEqual));
 };
 
 const SubHydrationBalanceModule = {
@@ -3512,9 +3497,9 @@ const getSubtensorStakingBalances$ = (connector, networkId, balanceDefs, miniMet
   return rxjs.timer(0, 30000).pipe(rxjs.switchMap(() => rxjs.from(fetchStakeInfoByAddress(connector, networkId, miniMetadata, addresses)).pipe(rxjs.switchMap(stakeInfoByAddress => fetchStakingBalanceValuesByAddress(connector, networkId, miniMetadata, stakeInfoByAddress)))));
 };
 const fetchStakingBalanceValuesByAddress = async (connector, networkId, miniMetadata, stakeInfoByAddress) => {
-  const uniqueNetuids = lodash.uniq(lodash.values(stakeInfoByAddress).flatMap(infos => infos.map(info => info.netuid))).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID);
+  const uniqueNetuids = lodashEs.uniq(lodashEs.values(stakeInfoByAddress).flatMap(infos => infos.map(info => info.netuid))).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID);
   const dynamicInfoByNetuid = await fetchDynamicInfoByNetuid(connector, networkId, miniMetadata, uniqueNetuids);
-  return lodash.fromPairs(lodash.toPairs(stakeInfoByAddress).map(([address, stakeInfos]) => {
+  return lodashEs.fromPairs(lodashEs.toPairs(stakeInfoByAddress).map(([address, stakeInfos]) => {
     const stakesBalances = stakeInfos.filter(({
       stake
     }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK).map(({
@@ -3539,7 +3524,7 @@ const fetchStakingBalanceValuesByAddress = async (connector, networkId, miniMeta
       } = dynamicInfo ?? {};
       const tokenSymbol = new TextDecoder().decode(Uint8Array.from(token_symbol ?? []));
       const subnetName = new TextDecoder().decode(Uint8Array.from(subnet_name ?? []));
-      const subnetIdentity = subnet_identity ? lodash.fromPairs(lodash.toPairs(subnet_identity).map(([key, binary]) => [key, binary.asText()])) : undefined;
+      const subnetIdentity = subnet_identity ? lodashEs.fromPairs(lodashEs.toPairs(subnet_identity).map(([key, binary]) => [key, binary.asText()])) : undefined;
 
       // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
       const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
@@ -3582,7 +3567,7 @@ const fetchStakeInfoByAddress = async (connector, networkId, miniMetadata, addre
     delay: 500,
     retryCount: 3
   })]));
-  return lodash.fromPairs(pairs);
+  return lodashEs.fromPairs(pairs);
 };
 
 // assume dynamic info doesnt change over the course of a browser session
@@ -3606,7 +3591,7 @@ const fetchDynamicInfoByNetuid = async (connector, networkId, miniMetadata, uniq
     return dynamicInfoCache.get(cacheKey) ?? null;
   };
   const results = await Promise.all(uniqueNetuids.map(async netuid => [netuid, await fetchInfo(netuid)]));
-  return lodash.fromPairs(results);
+  return lodashEs.fromPairs(results);
 };
 
 const getOtherType = input => `other-${input}`;
@@ -3757,41 +3742,6 @@ const buildBaseQueries = (networkId, balanceDefs, miniMetadata) => {
     };
   }).filter(util.isNotNil);
 };
-
-// AccountInfo is the state_storage data format for nativeToken balances
-// Theory: new chains will be at least on metadata v14, and so we won't need to hardcode their AccountInfo type.
-// But for chains we want to support which aren't on metadata v14, hardcode them here:
-// If the chain upgrades to metadata v14, this override will be ignored :)
-// const RegularAccountInfoFallback = Struct({
-//   nonce: u32,
-//   consumers: u32,
-//   providers: u32,
-//   sufficients: u32,
-//   data: Struct({ free: u128, reserved: u128, miscFrozen: u128, feeFrozen: u128 }),
-// })
-// const NoSufficientsAccountInfoFallback = Struct({
-//   nonce: u32,
-//   consumers: u32,
-//   providers: u32,
-//   data: Struct({ free: u128, reserved: u128, miscFrozen: u128, feeFrozen: u128 }),
-// })
-// const AccountInfoOverrides: Record<
-//   string,
-//   typeof RegularAccountInfoFallback | typeof NoSufficientsAccountInfoFallback | undefined
-// > = {
-//   // crown-sterlin is not yet on metadata v14
-//   "crown-sterling": NoSufficientsAccountInfoFallback,
-
-//   // crust is not yet on metadata v14
-//   "crust": NoSufficientsAccountInfoFallback,
-
-//   // kulupu is not yet on metadata v14
-//   "kulupu": RegularAccountInfoFallback,
-
-//   // nftmart is not yet on metadata v14
-//   "nftmart": RegularAccountInfoFallback,
-// }
-
 const decodeBaseResult = (coder, value, networkId) => {
   /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
 
@@ -3842,15 +3792,6 @@ const decodeLocksResult = (coder, value, networkId) => {
     amount: (lock?.amount ?? 0n).toString()
   })) ?? [];
   return locksQueryLocks;
-
-  // // locked values should be replaced entirely, not merged or appended
-  // const nonLockValues = balanceJson.values.filter(
-  //   (v) => v.source !== "substrate-native-locks",
-  // )
-  // balanceJson.values = nonLockValues.concat(locksQueryLocks)
-
-  // // fix any double-counting between Balances.Locks (for staking locks) and Staking.Ledger (for unbonding locks)
-  // balanceJson.values = updateStakingLocksUsingUnbondingLocks(balanceJson.values)
 };
 const decodeFreezesResult = (coder, value, networkId) => {
   /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
@@ -3863,14 +3804,6 @@ const decodeFreezesResult = (coder, value, networkId) => {
     amount: lock?.amount?.toString?.() ?? "0"
   })) ?? [];
   return freezesValues;
-
-  // // freezes values should be replaced entirely, not merged or appended
-  // const nonFreezesValues = balanceJson.values.filter(
-  //   (v) => v.source !== "substrate-native-freezes",
-  // )
-  // balanceJson.values = nonFreezesValues.concat(freezesQueryLocks)
-
-  // return balanceJson
 };
 const decodeHoldsResult = (coder, value, networkId) => {
   /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
@@ -3889,14 +3822,6 @@ const decodeHoldsResult = (coder, value, networkId) => {
     }
   })) ?? [];
   return holdsValues;
-
-  // // values should be replaced entirely, not merged or appended
-  // const nonHoldsValues = balanceJson.values.filter(
-  //   (v) => v.source !== "substrate-native-holds",
-  // )
-  // balanceJson.values = nonHoldsValues.concat(holdsQueryLocks)
-
-  // return balanceJson
 };
 const decodeStakingLedgerResult = (coder, value, networkId) => {
   /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
@@ -3911,29 +3836,6 @@ const decodeStakingLedgerResult = (coder, value, networkId) => {
     amount: totalUnlocking.toString()
   }];
   return stakingLedgerResults;
-
-  // if (totalUnlocking <= 0n) unbondingQueryLocks = []
-  // else {
-  //   unbondingQueryLocks = [
-  //     {
-  //       type: "locked",
-  //       source: "substrate-native-unbonding",
-  //       label: "Unbonding",
-  //       amount: totalUnlocking.toString(),
-  //     },
-  //   ]
-  // }
-
-  // // unbonding values should be replaced entirely, not merged or appended
-  // const nonUnbondingValues = balanceJson.values.filter(
-  //   (v) => v.source !== "substrate-native-unbonding",
-  // )
-  // balanceJson.values = nonUnbondingValues.concat(unbondingQueryLocks)
-
-  // // fix any double-counting between Balances.Locks (for staking locks) and Staking.Ledger (for unbonding locks)
-  // balanceJson.values = updateStakingLocksUsingUnbondingLocks(balanceJson.values)
-
-  // return balanceJson
 };
 const decodePoolMemberResult = (coder, value, networkId) => {
   /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
@@ -3960,109 +3862,6 @@ const decodePoolMemberResult = (coder, value, networkId) => {
   };
 };
 
-// const getBaseQuery = (
-//   networkId: string,
-//   address: string,
-//   coder: ScaleStorageCoder,
-// ): RpcStateQuery<Array<AmountWithLabel<string>>> | null => {
-//   // For chains which are using metadata < v14
-//   const getFallbackStateKey = () => {
-//     const addressBytes = decodeAnyAddress(address) // TODO replace with modern api, this is slow
-//     const addressHash = blake2Concat(addressBytes).replace(/^0x/, "")
-//     const moduleHash = "26aa394eea5630e07c48ae0c9558cef7" // util_crypto.xxhashAsHex("System", 128);
-//     const storageHash = "b99d880ec681799c0cf30e8886371da9" // util_crypto.xxhashAsHex("Account", 128);
-//     const moduleStorageHash = `${moduleHash}${storageHash}` // System.Account is the state_storage key prefix for nativeToken balances
-//     return `0x${moduleStorageHash}${addressHash}`
-//   }
-
-//   // const scaleCoder = chainStorageCoders.get(chainId)?.base
-//   // NOTE: Only use fallback key when `scaleCoder` is not defined
-//   // i.e. when chain doesn't have metadata v14/v15
-//   const stateKey = coder
-//     ? encodeStateKey(coder, `Invalid address in ${networkId} base query ${address}`, address)
-//     : getFallbackStateKey()
-//   if (!stateKey) return null
-
-//   const decodeResult = (change: string | null) => {
-//     // BEGIN: Handle chains which use metadata < v14
-//     let oldChainBalance = null
-//     if (!coder) {
-//       const scaleAccountInfo = AccountInfoOverrides[networkId]
-//       if (scaleAccountInfo === undefined) {
-//         // chain metadata version is < 15 and we also don't have an override hardcoded in
-//         // the best way to handle this case: log a warning and return an empty balance
-//         log.debug(
-//           `Native token on chain ${networkId} has no balance type for decoding. Defaulting to a balance of 0 (zero).`,
-//         )
-//         return []
-//       }
-
-//       try {
-//         // eslint-disable-next-line no-var
-//         oldChainBalance = change === null ? null : scaleAccountInfo.dec(change)
-//       } catch (error) {
-//         log.warn(
-//           `Failed to create pre-metadataV14 balance type for native on chain ${networkId}: ${error?.toString()}`,
-//         )
-//         return []
-//       }
-//     }
-//     // END: Handle chains which use metadata < v14
-
-//     /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-//     type DecodedType = {
-//       data?: {
-//         flags?: bigint
-//         free?: bigint
-//         frozen?: bigint
-//         reserved?: bigint
-
-//         // deprecated fields (they only show up on old chains)
-//         feeFrozen?: bigint
-//         miscFrozen?: bigint
-//       }
-//     }
-//     const decoded =
-//       decodeScale<DecodedType>(
-//         coder,
-//         change,
-//         `Failed to decode base native balance on chain ${networkId}`,
-//       ) ?? oldChainBalance
-
-//     const free = (decoded?.data?.free ?? 0n).toString()
-//     const reserved = (decoded?.data?.reserved ?? 0n).toString()
-//     const miscLock = (
-//       (decoded?.data?.miscFrozen ?? 0n) +
-//       // new chains don't split their `frozen` amount into `feeFrozen` and `miscFrozen`.
-//       // for these chains, we'll use the `frozen` amount as `miscFrozen`.
-//       ((decoded?.data as DecodedType["data"])?.frozen ?? 0n)
-//     ).toString()
-//     const feesLock = (decoded?.data?.feeFrozen ?? 0n).toString()
-
-//     // even if these values are 0, we still need to add them to the balanceJson.values array
-//     // so that the balance pool can handle newly zeroed balances
-//     // const existingValues = Object.fromEntries(
-//     //   balanceJson.values.map((v) => [getValueId(v), v]),
-//     // )
-//     const newValues: AmountWithLabel<string>[] = [
-//       { type: "free", label: "free", amount: free.toString() },
-//       { type: "reserved", label: "reserved", amount: reserved.toString() },
-//       { type: "locked", label: "misc", amount: miscLock.toString() },
-//       { type: "locked", label: "fees", amount: feesLock.toString() },
-//     ]
-
-//     return newValues
-
-//     // const newValuesObj = Object.fromEntries(newValues.map((v) => [getValueId(v), v]))
-
-//     // balanceJson.values = Object.values({ ...existingValues, ...newValuesObj })
-
-//     // return balanceJson
-//   }
-
-//   return { chainId: networkId, stateKey, decodeResult }
-// }
-
 /**
  * Each nominationPool in the nominationPools pallet has access to some accountIds which have no
  * associated private key. Instead, they are derived from this function.
@@ -4110,7 +3909,9 @@ const buildNomPoolQueries = (networkId, partialBalances, miniMetadata) => {
         }) => total + BigInt(amount ?? "0"), 0n);
         return {
           ...balance,
-          values: [...(balance.values ?? []), {
+          values: [...(balance.values?.filter(({
+            source
+          }) => source !== "nompools-staking") ?? []), {
             source: "nompools-staking",
             type: "nompool",
             label: "nompools-staking",
@@ -4240,7 +4041,9 @@ const fetchBalances$2 = async ({
   const subtensorBalancesByAddress = await rxjs.firstValueFrom(subtensorBalances$);
   for (const [address, subtensorBalances] of Object.entries(subtensorBalancesByAddress)) {
     const balance = balances.find(b => b.address === address);
-    if (balance?.values) balance.values.push(...subtensorBalances);
+    if (balance?.values) balance.values = [...balance.values.filter(({
+      source
+    }) => source !== "subtensor-staking"), ...subtensorBalances];
   }
   return {
     success: balances,
@@ -4272,7 +4075,7 @@ const fetchTokens$2 = async ({
     decimals: decimals,
     existentialDeposit: miniMetadata.extra.existentialDeposit ?? "0"
   };
-  const token = lodash.assign(nativeToken, tokenConfig);
+  const token = lodashEs.assign(nativeToken, tokenConfig);
   const parsed = chaindataProvider.SubNativeTokenSchema.safeParse(token);
   if (!parsed.success) {
     log.warn(`Ignoring invalid token ${MODULE_TYPE$2}`, token, parsed.error);
@@ -4354,13 +4157,9 @@ const getMiniMetadata$2 = ({
   }, {
     pallet: "Staking",
     items: ["Ledger"]
-  },
-  // TotalColdkeyStake is used until v.2.2.1, then it is replaced by StakingHotkeys+Stake
-  // Need to keep TotalColdkeyStake for a while so chaindata keeps including it in miniMetadatas, so it doesnt break old versions of the wallet
-  // TODO: Since chaindata v4 this is safe to now delete
-  {
+  }, {
     pallet: "SubtensorModule",
-    items: ["TotalColdkeyStake", "StakingHotkeys", "Stake"]
+    items: ["StakingHotkeys", "Stake"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkey"]
@@ -4490,9 +4289,11 @@ const subscribeBalances$2 = ({
   const subtensorBalancesByAddress$ = getSubtensorStakingBalances$(connector, networkId, balanceDefs, miniMetadata);
   return rxjs.combineLatest([baseBalances$, subtensorBalancesByAddress$]).pipe(rxjs.map(([baseBalances, subtensorBalancesByAddress]) => {
     // add subtensor balances to base balances
-    for (const [address, subtensorBalances] of lodash.toPairs(subtensorBalancesByAddress)) {
+    for (const [address, subtensorBalances] of lodashEs.toPairs(subtensorBalancesByAddress)) {
       const balance = baseBalances.find(b => b.address === address);
-      if (balance?.values) balance.values.push(...subtensorBalances);
+      if (balance?.values) balance.values = [...balance.values.filter(({
+        source
+      }) => source !== "subtensor-staking"), ...subtensorBalances];
     }
     return {
       success: baseBalances,
@@ -5805,7 +5606,7 @@ const fetchTokens$1 = async ({
       continue;
     }
   }
-  return lodash.values(tokenList).filter(t => {
+  return lodashEs.values(tokenList).filter(t => {
     const parsed = chaindataProvider.SubPsp22TokenSchema.safeParse(t);
     if (!parsed.success) log.warn(`Ignoring invalid token ${MODULE_TYPE$1}`, t);
     return parsed.success;
@@ -5934,7 +5735,7 @@ const subscribeBalances$1 = ({
     return () => {
       abortController.abort();
     };
-  }).pipe(rxjs.distinctUntilChanged(lodash.isEqual));
+  }).pipe(rxjs.distinctUntilChanged(lodashEs.isEqual));
 };
 
 const SubPsp22BalanceModule = {
@@ -6100,7 +5901,7 @@ const fetchTokens = async ({
   // in this module we do not fetch any token information from the chain
   // this is because there are basically as many pallet implementations as there are networks (Expect Chaos, they said)
   // we rely on the config to provide all the info we need
-  return tokens.map(tokenConfig => lodash.assign({
+  return tokens.map(tokenConfig => lodashEs.assign({
     id: chaindataProvider.subTokensTokenId(networkId, tokenConfig.onChainId),
     type: MODULE_TYPE,
     platform: PLATFORM,
@@ -6347,8 +6148,10 @@ const getMetadataRpc = async (chainConnector, networkId) => {
   if (CACHE$1.has(networkId)) return CACHE$1.get(networkId);
   const pResult = sapi.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
-  );
+  }),
+  // do not allow fallback to v14 unless unavailable.
+  // substrate-native and substrate-hydration need v15 metadata for runtime api calls
+  false);
   CACHE$1.set(networkId, pResult);
   try {
     return await pResult;
@@ -6448,8 +6251,8 @@ class BalancesProvider {
     this.#chaindataProvider = chaindataProvider;
     this.#chainConnectors = chainConnectors;
     this.#storage = new rxjs.BehaviorSubject({
-      balances: lodash.keyBy(storage.balances.filter(util.isNotNil), b => getBalanceId(b)),
-      miniMetadatas: lodash.keyBy(storage.miniMetadatas.filter(util.isNotNil), m => m.id)
+      balances: lodashEs.keyBy(storage.balances.filter(util.isNotNil), b => getBalanceId(b)),
+      miniMetadatas: lodashEs.keyBy(storage.miniMetadatas.filter(util.isNotNil), m => m.id)
     });
   }
   get storage$() {
@@ -6457,8 +6260,8 @@ class BalancesProvider {
       balances,
       miniMetadatas
     }) => ({
-      balances: lodash.values(balances).filter(util.isNotNil),
-      miniMetadatas: lodash.values(miniMetadatas).filter(util.isNotNil)
+      balances: lodashEs.values(balances).filter(util.isNotNil),
+      miniMetadatas: lodashEs.values(miniMetadatas).filter(util.isNotNil)
     })));
   }
 
@@ -6469,7 +6272,7 @@ class BalancesProvider {
     return util.getSharedObservable("BalancesProvider.getBalances$", addressesByTokenId, () => {
       return this.cleanupAddressesByTokenId(addressesByTokenId).pipe(rxjs.map(
       // split by network
-      addressesByTokenId => lodash.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
+      addressesByTokenId => lodashEs.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
         const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
         if (!acc[networkId]) acc[networkId] = {};
         acc[networkId][tokenId] = addresses;
@@ -6478,7 +6281,7 @@ class BalancesProvider {
       // fetch balances and start a 30s timer to mark the whole subscription live after 30s
       rxjs.combineLatest({
         isStale: rxjs.timer(30_000).pipe(rxjs.map(() => true), rxjs.startWith(false)),
-        results: rxjs.combineLatest(lodash.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
+        results: rxjs.combineLatest(lodashEs.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
       })), rxjs.map(
       // combine
       ({
@@ -6495,7 +6298,7 @@ class BalancesProvider {
       })), rxjs.startWith({
         status: "initialising",
         balances: this.getStoredBalances(addressesByTokenId)
-      }), rxjs.distinctUntilChanged(lodash.isEqual));
+      }), rxjs.distinctUntilChanged(lodashEs.isEqual));
     });
   }
   fetchBalances(addressesByTokenId) {
@@ -6511,14 +6314,14 @@ class BalancesProvider {
     const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
     const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
     return rxjs.combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(rxjs.switchMap(([network, miniMetadatas, tokensMapById]) => {
-      const tokensAndAddresses = lodash.toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
+      const tokensAndAddresses = lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
       return rxjs.combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
         const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
-        const moduleAddressesByTokenId = lodash.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+        const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
         const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
 
         // all balance ids expected in result set
-        const balanceIds = lodash.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
           tokenId,
           address
         })));
@@ -6531,15 +6334,15 @@ class BalancesProvider {
         const updateStorage = results => {
           if (results.status !== "live") return;
           const storage = this.#storage.getValue();
-          const balances = lodash.assign({}, storage.balances,
+          const balances = lodashEs.assign({}, storage.balances,
           // delete all balances expected in the result set. because if they are not present it means they are empty.
-          lodash.fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), lodash.keyBy(
+          lodashEs.fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), lodashEs.keyBy(
           // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
           results.balances.map(b => ({
             ...b,
             status: "cache"
           })), b => getBalanceId(b)));
-          this.#storage.next(lodash.assign({}, storage, {
+          this.#storage.next(lodashEs.assign({}, storage, {
             balances
           }));
         };
@@ -6609,12 +6412,12 @@ class BalancesProvider {
         rxjs.tap(newMiniMetadatas => {
           if (!newMiniMetadatas.length) return;
           const storage = this.#storage.getValue();
-          const miniMetadatas = lodash.assign(
+          const miniMetadatas = lodashEs.assign(
           // keep minimetadatas of other networks
-          lodash.keyBy(lodash.values(storage.miniMetadatas).filter(m => m.chainId !== networkId), m => m.id),
+          lodashEs.keyBy(lodashEs.values(storage.miniMetadatas).filter(m => m.chainId !== networkId), m => m.id),
           // add the ones for our network
-          lodash.keyBy(newMiniMetadatas, m => m.id));
-          this.#storage.next(lodash.assign({}, storage, {
+          lodashEs.keyBy(newMiniMetadatas, m => m.id));
+          this.#storage.next(lodashEs.assign({}, storage, {
             miniMetadatas
           }));
         }));
@@ -6626,13 +6429,13 @@ class BalancesProvider {
     });
   }
   getStoredMiniMetadatas$(networkId, specVersion) {
-    return this.storage$.pipe(rxjs.map(storage => storage.miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodash.isEqual));
+    return this.storage$.pipe(rxjs.map(storage => storage.miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   getDefaultMiniMetadatas$(networkId, specVersion) {
-    return this.#chaindataProvider.miniMetadatas$.pipe(rxjs.map(miniMetadatas => miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodash.isEqual));
+    return this.#chaindataProvider.miniMetadatas$.pipe(rxjs.map(miniMetadatas => miniMetadatas.filter(m => m.chainId === networkId && m.specVersion === specVersion && m.version === chaindataProvider.MINIMETADATA_VERSION)), rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   getStoredBalances(addressesByToken) {
-    const balanceDefs = lodash.toPairs(addressesByToken).flatMap(([tokenId, addresses]) => addresses.map(address => [tokenId, address]));
+    const balanceDefs = lodashEs.toPairs(addressesByToken).flatMap(([tokenId, addresses]) => addresses.map(address => [tokenId, address]));
     return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({
       address,
       tokenId
@@ -6640,7 +6443,7 @@ class BalancesProvider {
   }
   cleanupAddressesByTokenId(addressesByTokenId) {
     return this.#chaindataProvider.getNetworksMapById$().pipe(rxjs.map(networksById => {
-      return lodash.fromPairs(lodash.toPairs(addressesByTokenId).map(([tokenId, addresses]) => {
+      return lodashEs.fromPairs(lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => {
         const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
         const network = networksById[networkId];
         return [tokenId, addresses.filter(address => network && isAddressCompatibleWithNetwork(network, address))];