@talismn/balances 1.0.9 → 1.2.0

package/dist/talismn-balances.esm.js

@@ -1,15 +1,15 @@
-import { EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, evmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, SolNativeTokenSchema, solNativeTokenId, SolSplTokenSchema, solSplTokenId, parseSolSplTokenId, SubAssetsTokenSchema, subAssetTokenId, MINIMETADATA_VERSION, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, isNetworkDot } from '@talismn/chaindata-provider';
+import { EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, evmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, SolNativeTokenSchema, solNativeTokenId, SolSplTokenSchema, solSplTokenId, parseSolSplTokenId, SubAssetsTokenSchema, subAssetTokenId, SubDTaoTokenSchema, subDTaoTokenId, getCleanToken, TokenSchema, MINIMETADATA_VERSION, parseSubDTaoTokenId, subNativeTokenId, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, isNetworkDot } from '@talismn/chaindata-provider';
 export { MINIMETADATA_VERSION } from '@talismn/chaindata-provider';
 import { isEthereumAddress, isSolanaAddress, normalizeAddress, getAccountPlatformFromAddress } from '@talismn/crypto';
 import { parseAbi, erc20Abi, getContract, ContractFunctionExecutionError, hexToString, erc20Abi_bytes32, encodeFunctionData, withRetry } from 'viem';
 import { assign, omit, isEqual, uniq, keyBy, toPairs, keys, fromPairs, values } from 'lodash-es';
 import z from 'zod/v4';
 import anylogger from 'anylogger';
-import { of, Observable, distinctUntilChanged, BehaviorSubject, map, timer, switchMap, from, firstValueFrom, combineLatest, shareReplay, startWith, filter, defer, catchError, EMPTY, tap } from 'rxjs';
+import { of, Observable, distinctUntilChanged, BehaviorSubject, map, switchMap, shareReplay, combineLatest, timer, startWith, firstValueFrom, filter, defer, catchError, EMPTY, tap, from } from 'rxjs';
 import BigNumber from 'bignumber.js';
 import { PublicKey, SystemProgram } from '@solana/web3.js';
 import { isNotNil, BigMath, isArrayOf, isBigInt, planckToTokens, isAbortError, getSharedObservable, keepAlive, isTruthy } from '@talismn/util';
-import { parseMetadataRpc, toHex, unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, decodeScale, getStorageKeyPrefix, Twox128, compactMetadata, encodeMetadata, papiParse, papiStringify } from '@talismn/scale';
+import { parseMetadataRpc, toHex, unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, decodeScale, getStorageKeyPrefix, compactMetadata, encodeMetadata, Twox128, papiParse, papiStringify } from '@talismn/scale';
 import { deserializeMetadata } from '@metaplex-foundation/mpl-token-metadata';
 import { sol, publicKey } from '@metaplex-foundation/umi';
 import { MintLayout, getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction, TOKEN_PROGRAM_ID, getAccount } from '@solana/spl-token';
@@ -24,8 +24,8 @@ import { u8aToHex, u8aConcatStrict, u8aToString, hexToNumber } from '@polkadot/u
 import PQueue from 'p-queue';
 import { fetchBestMetadata } from '@talismn/sapi';
 
-const MODULE_TYPE$a = EvmErc20TokenSchema.shape.type.value;
-const PLATFORM$a = EvmErc20TokenSchema.shape.platform.value;
+const MODULE_TYPE$b = EvmErc20TokenSchema.shape.type.value;
+const PLATFORM$b = EvmErc20TokenSchema.shape.platform.value;
 
 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)"]);
 
@@ -621,7 +621,7 @@ const getBalanceDefs = addressesByToken => {
 // if there is at least one storage entry, the results will be an array with a single object
 // if the storage has no entries in it (ex: Assets on ewx or moonbeam), the response will be an empty array
 
-const fetchBalances$a = async ({
+const fetchBalances$b = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -633,7 +633,7 @@ const fetchBalances$a = async ({
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$a || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$b || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -663,7 +663,7 @@ const fetchWithoutAggregator = async (client, balanceDefs) => {
         address,
         tokenId: token.id,
         value: result.toString(),
-        source: MODULE_TYPE$a,
+        source: MODULE_TYPE$b,
         networkId: parseEvmErc20TokenId(token.id).networkId,
         status: "live"
       };
@@ -706,7 +706,7 @@ const fetchWithAggregator = async (client, balanceDefs, erc20BalancesAggregatorA
       address: balanceDef.address,
       tokenId: balanceDef.token.id,
       value: erc20Balances[index].toString(),
-      source: MODULE_TYPE$a,
+      source: MODULE_TYPE$b,
       networkId: parseTokenId(balanceDef.token.id).networkId,
       status: "live"
     }));
@@ -775,7 +775,7 @@ const TokenCacheSchema$2 = z.discriminatedUnion("isValid", [z.strictObject({
   id: EvmErc20TokenSchema.shape.id,
   isValid: z.literal(false)
 })]);
-const fetchTokens$a = async ({
+const fetchTokens$b = async ({
   networkId,
   tokens,
   connector,
@@ -815,8 +815,8 @@ const fetchTokens$a = async ({
     }
     const base = {
       id: tokenId,
-      type: MODULE_TYPE$a,
-      platform: PLATFORM$a,
+      type: MODULE_TYPE$b,
+      platform: PLATFORM$b,
       networkId
     };
     const cached2 = cache[tokenId] && TokenCacheSchema$2.safeParse(cache[tokenId]).data;
@@ -834,17 +834,17 @@ const fetchTokens$a = async ({
   return result;
 };
 
-const getMiniMetadata$a = () => {
+const getMiniMetadata$b = () => {
   throw new Error("MiniMetadata is not supported for ethereum tokens");
 };
 
-const getTransferCallData$a = ({
+const getTransferCallData$b = ({
   from,
   to,
   value,
   token
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$a)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$a}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$b)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$b}.`);
   if (!isEthereumAddress(from)) throw new Error("Invalid from address");
   if (!isEthereumAddress(to)) throw new Error("Invalid to address");
   const data = encodeFunctionData({
@@ -859,8 +859,8 @@ const getTransferCallData$a = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$6 = 6_000;
-const subscribeBalances$a = ({
+const SUBSCRIPTION_INTERVAL$7 = 6_000;
+const subscribeBalances$b = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -874,17 +874,17 @@ const subscribeBalances$a = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$a({
+        const balances = await fetchBalances$b({
           networkId,
           tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$7);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$a,
+          module: MODULE_TYPE$b,
           networkId,
           addressesByToken: tokensWithAddresses,
           error
@@ -900,13 +900,13 @@ const subscribeBalances$a = ({
 };
 
 const EvmErc20BalanceModule = {
-  type: MODULE_TYPE$a,
-  platform: PLATFORM$a,
-  getMiniMetadata: getMiniMetadata$a,
-  fetchTokens: fetchTokens$a,
-  fetchBalances: fetchBalances$a,
-  subscribeBalances: subscribeBalances$a,
-  getTransferCallData: getTransferCallData$a
+  type: MODULE_TYPE$b,
+  platform: PLATFORM$b,
+  getMiniMetadata: getMiniMetadata$b,
+  fetchTokens: fetchTokens$b,
+  fetchBalances: fetchBalances$b,
+  subscribeBalances: subscribeBalances$b,
+  getTransferCallData: getTransferCallData$b
 };
 
 const TokenConfigBaseSchema = TokenBaseSchema.partial().omit({
@@ -919,10 +919,10 @@ const EvmErc20TokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$9 = EvmNativeTokenSchema.shape.type.value;
-const PLATFORM$9 = EvmNativeTokenSchema.shape.platform.value;
+const MODULE_TYPE$a = EvmNativeTokenSchema.shape.type.value;
+const PLATFORM$a = EvmNativeTokenSchema.shape.platform.value;
 
-const fetchBalances$9 = async ({
+const fetchBalances$a = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -934,7 +934,7 @@ const fetchBalances$9 = async ({
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$9 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$a || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -961,7 +961,7 @@ const fetchWithoutMulticall = async (client, balanceDefs) => {
         address,
         tokenId: token.id,
         value: result.toString(),
-        source: MODULE_TYPE$9,
+        source: MODULE_TYPE$a,
         networkId: parseTokenId(token.id).networkId,
         status: "live"
       };
@@ -1007,7 +1007,7 @@ const fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
           address: balanceDefs[index].address,
           tokenId: balanceDefs[index].token.id,
           value: result.result.toString(),
-          source: MODULE_TYPE$9,
+          source: MODULE_TYPE$a,
           networkId: parseTokenId(balanceDefs[index].token.id).networkId,
           status: "live"
         });
@@ -1037,7 +1037,7 @@ const fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
   }
 };
 
-const fetchTokens$9 = async ({
+const fetchTokens$a = async ({
   networkId,
   tokens
 }) => {
@@ -1045,8 +1045,8 @@ const fetchTokens$9 = async ({
   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 = assign({
     id: evmNativeTokenId(networkId),
-    type: MODULE_TYPE$9,
-    platform: PLATFORM$9,
+    type: MODULE_TYPE$a,
+    platform: PLATFORM$a,
     networkId,
     isDefault: true
   }, tokens[0]);
@@ -1058,17 +1058,17 @@ const fetchTokens$9 = async ({
   return [parsed.data];
 };
 
-const getMiniMetadata$9 = () => {
+const getMiniMetadata$a = () => {
   throw new Error("MiniMetadata is not supported for ethereum tokens");
 };
 
-const getTransferCallData$9 = ({
+const getTransferCallData$a = ({
   from,
   to,
   value,
   token
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$9)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$9}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$a)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$a}.`);
   if (!isEthereumAddress(from)) throw new Error("Invalid from address");
   if (!isEthereumAddress(to)) throw new Error("Invalid to address");
   return {
@@ -1079,8 +1079,8 @@ const getTransferCallData$9 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$5 = 6_000;
-const subscribeBalances$9 = ({
+const SUBSCRIPTION_INTERVAL$6 = 6_000;
+const subscribeBalances$a = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1094,17 +1094,17 @@ const subscribeBalances$9 = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$9({
+        const balances = await fetchBalances$a({
           networkId,
           tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$6);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$9,
+          module: MODULE_TYPE$a,
           networkId,
           addressesByToken: tokensWithAddresses,
           error
@@ -1120,13 +1120,13 @@ const subscribeBalances$9 = ({
 };
 
 const EvmNativeBalanceModule = {
-  type: MODULE_TYPE$9,
-  platform: PLATFORM$9,
-  getMiniMetadata: getMiniMetadata$9,
-  fetchTokens: fetchTokens$9,
-  fetchBalances: fetchBalances$9,
-  subscribeBalances: subscribeBalances$9,
-  getTransferCallData: getTransferCallData$9
+  type: MODULE_TYPE$a,
+  platform: PLATFORM$a,
+  getMiniMetadata: getMiniMetadata$a,
+  fetchTokens: fetchTokens$a,
+  fetchBalances: fetchBalances$a,
+  subscribeBalances: subscribeBalances$a,
+  getTransferCallData: getTransferCallData$a
 };
 
 // to be used by chaindata too
@@ -1134,10 +1134,10 @@ const EvmNativeTokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$8 = EvmUniswapV2TokenSchema.shape.type.value;
-const PLATFORM$8 = EvmUniswapV2TokenSchema.shape.platform.value;
+const MODULE_TYPE$9 = EvmUniswapV2TokenSchema.shape.type.value;
+const PLATFORM$9 = EvmUniswapV2TokenSchema.shape.platform.value;
 
-const fetchBalances$8 = async ({
+const fetchBalances$9 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1149,7 +1149,7 @@ const fetchBalances$8 = async ({
   const client = await connector.getPublicClientForEvmNetwork(networkId);
   if (!client) throw new Error(`Could not get rpc provider for evm network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$8 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$9 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for EVM ERC20 balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isEthereumAddress(address)) throw new Error(`Invalid ethereum address for EVM ERC20 balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -1236,7 +1236,7 @@ const fetchPoolBalances = async (client, balanceDefs) => {
     acc.success.push({
       address,
       tokenId: token.id,
-      source: MODULE_TYPE$8,
+      source: MODULE_TYPE$9,
       networkId: parseTokenId(token.id).networkId,
       status: "live",
       values: [{
@@ -1314,7 +1314,7 @@ const TokenCacheSchema$1 = z.discriminatedUnion("isValid", [z.strictObject({
   id: EvmUniswapV2TokenSchema.shape.id,
   isValid: z.literal(false)
 })]);
-const fetchTokens$8 = async ({
+const fetchTokens$9 = async ({
   networkId,
   tokens,
   connector,
@@ -1373,8 +1373,8 @@ const fetchTokens$8 = async ({
     }
     const base = {
       id: tokenId,
-      type: MODULE_TYPE$8,
-      platform: PLATFORM$8,
+      type: MODULE_TYPE$9,
+      platform: PLATFORM$9,
       networkId
     };
     const cached2 = cache[tokenId] && TokenCacheSchema$1.safeParse(cache[tokenId]).data;
@@ -1390,17 +1390,17 @@ const fetchTokens$8 = async ({
   return result;
 };
 
-const getMiniMetadata$8 = () => {
+const getMiniMetadata$9 = () => {
   throw new Error("MiniMetadata is not supported for ethereum tokens");
 };
 
-const getTransferCallData$8 = ({
+const getTransferCallData$9 = ({
   from,
   to,
   value,
   token
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$8)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$8}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$9)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$9}.`);
   if (!isEthereumAddress(from)) throw new Error("Invalid from address");
   if (!isEthereumAddress(to)) throw new Error("Invalid to address");
   const data = encodeFunctionData({
@@ -1415,8 +1415,8 @@ const getTransferCallData$8 = ({
   };
 };
 
-const SUBSCRIPTION_INTERVAL$4 = 6_000;
-const subscribeBalances$8 = ({
+const SUBSCRIPTION_INTERVAL$5 = 6_000;
+const subscribeBalances$9 = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1430,17 +1430,17 @@ const subscribeBalances$8 = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$8({
+        const balances = await fetchBalances$9({
           networkId,
           tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$5);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$8,
+          module: MODULE_TYPE$9,
           networkId,
           addressesByToken: tokensWithAddresses,
           error
@@ -1456,13 +1456,13 @@ const subscribeBalances$8 = ({
 };
 
 const EvmUniswapV2BalanceModule = {
-  type: MODULE_TYPE$8,
-  platform: PLATFORM$8,
-  getMiniMetadata: getMiniMetadata$8,
-  fetchTokens: fetchTokens$8,
-  fetchBalances: fetchBalances$8,
-  subscribeBalances: subscribeBalances$8,
-  getTransferCallData: getTransferCallData$8
+  type: MODULE_TYPE$9,
+  platform: PLATFORM$9,
+  getMiniMetadata: getMiniMetadata$9,
+  fetchTokens: fetchTokens$9,
+  fetchBalances: fetchBalances$9,
+  subscribeBalances: subscribeBalances$9,
+  getTransferCallData: getTransferCallData$9
 };
 
 // to be used by chaindata too
@@ -1471,10 +1471,10 @@ const EvmUniswapV2TokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$7 = SolNativeTokenSchema.shape.type.value;
-const PLATFORM$7 = SolNativeTokenSchema.shape.platform.value;
+const MODULE_TYPE$8 = SolNativeTokenSchema.shape.type.value;
+const PLATFORM$8 = SolNativeTokenSchema.shape.platform.value;
 
-const fetchBalances$7 = async ({
+const fetchBalances$8 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1486,7 +1486,7 @@ const fetchBalances$7 = async ({
   const connection = await connector.getConnection(networkId);
   if (!connection) throw new Error(`Could not get rpc provider for sol network ${networkId}`);
   for (const [token, addresses] of tokensWithAddresses) {
-    if (token.type !== MODULE_TYPE$7 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for balance module: ${token.type} on ${token.networkId}`);
+    if (token.type !== MODULE_TYPE$8 || token.networkId !== networkId) throw new Error(`Invalid token type or networkId for balance module: ${token.type} on ${token.networkId}`);
     for (const address of addresses) if (!isSolanaAddress(address)) throw new Error(`Invalid solana address for balance module: ${address} for token ${token.id}`);
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
@@ -1501,7 +1501,7 @@ const fetchBalances$7 = async ({
         address: address,
         tokenId: token.id,
         value: lamports.toString(),
-        source: MODULE_TYPE$7,
+        source: MODULE_TYPE$8,
         networkId: token.networkId,
         status: "live"
       };
@@ -1525,7 +1525,7 @@ const fetchBalances$7 = async ({
   });
 };
 
-const fetchTokens$7 = async ({
+const fetchTokens$8 = async ({
   networkId,
   tokens
 }) => {
@@ -1533,8 +1533,8 @@ const fetchTokens$7 = async ({
   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 = assign({
     id: solNativeTokenId(networkId),
-    type: MODULE_TYPE$7,
-    platform: PLATFORM$7,
+    type: MODULE_TYPE$8,
+    platform: PLATFORM$8,
     networkId,
     isDefault: true
   }, tokens[0]);
@@ -1546,17 +1546,17 @@ const fetchTokens$7 = async ({
   return [parsed.data];
 };
 
-const getMiniMetadata$7 = () => {
+const getMiniMetadata$8 = () => {
   throw new Error("MiniMetadata is not supported for sol-native tokens");
 };
 
-const getTransferCallData$7 = ({
+const getTransferCallData$8 = ({
   from,
   to,
   value,
   token
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$7)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$7}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$8)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$8}.`);
   const fromPubkey = new PublicKey(from);
   const transferIx = SystemProgram.transfer({
     fromPubkey,
@@ -1566,8 +1566,8 @@ const getTransferCallData$7 = ({
   return [transferIx];
 };
 
-const SUBSCRIPTION_INTERVAL$3 = 6_000;
-const subscribeBalances$7 = ({
+const SUBSCRIPTION_INTERVAL$4 = 6_000;
+const subscribeBalances$8 = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1581,17 +1581,17 @@ const subscribeBalances$7 = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$7({
+        const balances = await fetchBalances$8({
           networkId,
           tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$4);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$7,
+          module: MODULE_TYPE$8,
           networkId,
           tokensWithAddresses,
           error
@@ -1607,13 +1607,13 @@ const subscribeBalances$7 = ({
 };
 
 const SolNativeBalanceModule = {
-  type: MODULE_TYPE$7,
-  platform: PLATFORM$7,
-  getMiniMetadata: getMiniMetadata$7,
-  fetchTokens: fetchTokens$7,
-  fetchBalances: fetchBalances$7,
-  subscribeBalances: subscribeBalances$7,
-  getTransferCallData: getTransferCallData$7
+  type: MODULE_TYPE$8,
+  platform: PLATFORM$8,
+  getMiniMetadata: getMiniMetadata$8,
+  fetchTokens: fetchTokens$8,
+  fetchBalances: fetchBalances$8,
+  subscribeBalances: subscribeBalances$8,
+  getTransferCallData: getTransferCallData$8
 };
 
 // to be used by chaindata too
@@ -1621,16 +1621,22 @@ const SolNativeTokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$6 = SolSplTokenSchema.shape.type.value;
-const PLATFORM$6 = SolSplTokenSchema.shape.platform.value;
+const MODULE_TYPE$7 = SolSplTokenSchema.shape.type.value;
+const PLATFORM$7 = SolSplTokenSchema.shape.platform.value;
 
 const fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
-  const {
-    builder
-  } = parseMetadataRpc(metadataRpc);
-  const call = builder.buildRuntimeCall(apiName, method);
-  const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, toHex(call.args.enc(args))]);
-  return call.value.dec(hex);
+  try {
+    const {
+      builder
+    } = parseMetadataRpc(metadataRpc);
+    const call = builder.buildRuntimeCall(apiName, method);
+    const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, toHex(call.args.enc(args))]);
+    return call.value.dec(hex);
+  } catch (cause) {
+    throw new Error(`Error fetching runtime call on ${networkId} for ${apiName}.${method}`, {
+      cause
+    });
+  }
 };
 
 const hasStorageItem = (metadata, palletName, itemName) => {
@@ -1775,7 +1781,7 @@ const setDetectedTokenIds = (address, type, tokenIds) => {
 const getDetectedTokensIds$ = address => tokenIdsByAddress.pipe(map(ownedTokens => ownedTokens[address] ?? []), distinctUntilChanged(isEqual));
 
 const SPL_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-const fetchBalances$6 = async ({
+const fetchBalances$7 = async ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1799,7 +1805,7 @@ const fetchBalances$6 = async ({
           tokenId: solSplTokenId(networkId, mintAddress),
           networkId,
           address,
-          source: MODULE_TYPE$6,
+          source: MODULE_TYPE$7,
           status: "live",
           value
         };
@@ -1813,7 +1819,7 @@ const fetchBalances$6 = async ({
     }).filter(isNotNil);
 
     // allows the wallet to detect new tokens, and enable them automatically
-    setDetectedTokenIds(address, MODULE_TYPE$6, balances.map(b => b.tokenId));
+    setDetectedTokenIds(address, MODULE_TYPE$7, balances.map(b => b.tokenId));
     return [address, balances];
   }));
   const allBalancesByKey = keyBy(balancesPerAddress.flatMap(([, addressBalances]) => addressBalances), b => getBalanceKey(b.tokenId, b.address));
@@ -1826,7 +1832,7 @@ const fetchBalances$6 = async ({
       tokenId: bd.token.id,
       networkId: bd.token.networkId,
       address: bd.address,
-      source: MODULE_TYPE$6,
+      source: MODULE_TYPE$7,
       status: "live",
       value: "0"
     };
@@ -1854,7 +1860,7 @@ const TokenCacheSchema = z.discriminatedUnion("isValid", [z.strictObject({
   isValid: z.literal(false)
 })]);
 const METAPLEX_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
-const fetchTokens$6 = async ({
+const fetchTokens$7 = async ({
   networkId,
   tokens,
   connector,
@@ -1872,8 +1878,8 @@ const fetchTokens$6 = async ({
     if (cached?.isValid === false) continue;
     const base = {
       id: tokenId,
-      type: MODULE_TYPE$6,
-      platform: PLATFORM$6,
+      type: MODULE_TYPE$7,
+      platform: PLATFORM$7,
       networkId
     };
     const token = assign(base, cached?.isValid ? omit(cached, ["isValid"]) : {}, tokenConfig);
@@ -1940,18 +1946,18 @@ const fetchOnChainTokenData = async (connector, tokenId) => {
   return null;
 };
 
-const getMiniMetadata$6 = () => {
+const getMiniMetadata$7 = () => {
   throw new Error("MiniMetadata is not supported for solana tokens");
 };
 
-const getTransferCallData$6 = async ({
+const getTransferCallData$7 = async ({
   from,
   to,
   value,
   token,
   connector
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$6)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$6}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$7)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$7}.`);
   const connection = await connector.getConnection(token.networkId);
   const instructions = [];
   const mint = new PublicKey(token.mintAddress);
@@ -1982,8 +1988,8 @@ const tokenAccountExists = async (connection, address) => {
   }
 };
 
-const SUBSCRIPTION_INTERVAL$2 = 6_000;
-const subscribeBalances$6 = ({
+const SUBSCRIPTION_INTERVAL$3 = 6_000;
+const subscribeBalances$7 = ({
   networkId,
   tokensWithAddresses,
   connector
@@ -1997,17 +2003,17 @@ const subscribeBalances$6 = ({
     const poll = async () => {
       try {
         if (abortController.signal.aborted) return;
-        const balances = await fetchBalances$6({
+        const balances = await fetchBalances$7({
           networkId,
           tokensWithAddresses: tokensWithAddresses,
           connector
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$3);
       } catch (error) {
         log.error("Error", {
-          module: MODULE_TYPE$6,
+          module: MODULE_TYPE$7,
           networkId,
           addressesByToken: tokensWithAddresses,
           error
@@ -2023,13 +2029,13 @@ const subscribeBalances$6 = ({
 };
 
 const SolSplBalanceModule = {
-  type: MODULE_TYPE$6,
-  platform: PLATFORM$6,
-  getMiniMetadata: getMiniMetadata$6,
-  fetchTokens: fetchTokens$6,
-  fetchBalances: fetchBalances$6,
-  subscribeBalances: subscribeBalances$6,
-  getTransferCallData: getTransferCallData$6
+  type: MODULE_TYPE$7,
+  platform: PLATFORM$7,
+  getMiniMetadata: getMiniMetadata$7,
+  fetchTokens: fetchTokens$7,
+  fetchBalances: fetchBalances$7,
+  subscribeBalances: subscribeBalances$7,
+  getTransferCallData: getTransferCallData$7
 };
 
 // to be used by chaindata too
@@ -2038,8 +2044,8 @@ const SolSplTokenConfigSchema = z.strictObject({
   ...TokenConfigBaseSchema.shape
 });
 
-const MODULE_TYPE$5 = SubAssetsTokenSchema.shape.type.value;
-const PLATFORM$5 = SubAssetsTokenSchema.shape.platform.value;
+const MODULE_TYPE$6 = SubAssetsTokenSchema.shape.type.value;
+const PLATFORM$6 = SubAssetsTokenSchema.shape.platform.value;
 
 const buildQueries$2 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
@@ -2115,7 +2121,7 @@ const tryEncode = (scaleCoder, ...args) => {
   }
 };
 
-const fetchBalances$5 = async ({
+const fetchBalances$6 = async ({
   networkId,
   tokensWithAddresses,
   connector,
@@ -2127,7 +2133,7 @@ const fetchBalances$5 = async ({
   };
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (!miniMetadata?.data) {
-    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$5} balances on ${networkId}.`);
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$6} balances on ${networkId}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -2137,19 +2143,19 @@ const fetchBalances$5 = async ({
       }))
     };
   }
-  if (miniMetadata.source !== MODULE_TYPE$5) {
-    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$5}.`);
+  if (miniMetadata.source !== MODULE_TYPE$6) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$6}.`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
         tokenId: def.token.id,
         address: def.address,
-        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$5}`)
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$6}`)
       }))
     };
   }
   if (miniMetadata.chainId !== networkId) {
-    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$5}. Expected chainId is ${networkId}`);
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$6}. Expected chainId is ${networkId}`);
     return {
       success: [],
       errors: balanceDefs.map(def => ({
@@ -2169,7 +2175,7 @@ const fetchBalances$5 = async ({
       address: def.address,
       networkId,
       tokenId: def.token.id,
-      source: MODULE_TYPE$5,
+      source: MODULE_TYPE$6,
       status: "live",
       values: [{
         type: "free",
@@ -2188,7 +2194,7 @@ const fetchBalances$5 = async ({
   });
 };
 
-const fetchTokens$5 = async ({
+const fetchTokens$6 = async ({
   networkId,
   tokens,
   connector,
@@ -2229,7 +2235,7 @@ const fetchTokens$5 = async ({
   const configTokenByAssetId = keyBy(tokens, t => t.assetId);
   return allTokens.map(asset => ({
     id: subAssetTokenId(networkId, String(asset.assetId)),
-    type: MODULE_TYPE$5,
+    type: MODULE_TYPE$6,
     platform: "polkadot",
     networkId,
     assetId: String(asset.assetId),
@@ -2260,6 +2266,394 @@ const fetchTokens$5 = async ({
   });
 };
 
+const MODULE_TYPE$5 = SubDTaoTokenSchema.shape.type.value;
+const PLATFORM$5 = SubDTaoTokenSchema.shape.platform.value;
+
+const TAO_DECIMALS = 9n;
+
+// manipulating price as bigint requires using at least as many decimals as TAO itself
+const ALPHA_PRICE_SCALE = 10n ** TAO_DECIMALS;
+const getScaledAlphaPrice = (alphaIn, taoIn) => {
+  if (!alphaIn || !taoIn) return 0n;
+  return taoIn * ALPHA_PRICE_SCALE / alphaIn;
+};
+const alphaToTao = (alpha, scaledAlphaPrice) => {
+  if (!alpha || !scaledAlphaPrice) return 0n;
+  return alpha * scaledAlphaPrice / ALPHA_PRICE_SCALE;
+};
+const taoToAlpha = (tao, scaledAlphaPrice) => {
+  if (!tao || !scaledAlphaPrice) return 0n;
+  return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
+};
+
+const fetchBalances$5 = async ({
+  networkId,
+  tokensWithAddresses,
+  connector,
+  miniMetadata
+}) => {
+  if (!tokensWithAddresses.length) return {
+    success: [],
+    errors: []
+  };
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
+  if (!miniMetadata?.data) {
+    log.warn(`MiniMetadata is required for fetching ${MODULE_TYPE$5} balances on ${networkId}.`, {
+      tokensWithAddresses
+    });
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error("Minimetadata is required for fetching balances")
+      }))
+    };
+  }
+  if (miniMetadata.source !== MODULE_TYPE$5) {
+    log.warn(`Ignoring miniMetadata with source ${miniMetadata.source} in ${MODULE_TYPE$5}.`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: miniMetadata source is not ${MODULE_TYPE$5}`)
+      }))
+    };
+  }
+  if (miniMetadata.chainId !== networkId) {
+    log.warn(`Ignoring miniMetadata with chainId ${miniMetadata.chainId} in ${MODULE_TYPE$5}. Expected chainId is ${networkId}`);
+    return {
+      success: [],
+      errors: balanceDefs.map(def => ({
+        tokenId: def.token.id,
+        address: def.address,
+        error: new Error(`Invalid request: Expected chainId is ${networkId}`)
+      }))
+    };
+  }
+  const addresses = uniq(balanceDefs.map(def => def.address));
+  try {
+    const [stakeInfos, dynamicInfos] = await Promise.all([fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "StakeInfoRuntimeApi", "get_stake_info_for_coldkeys", [addresses]), fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "SubnetInfoRuntimeApi", "get_all_dynamic_info", [])]);
+    const dynamicInfoByNetuid = keyBy(dynamicInfos.filter(isNotNil), info => info.netuid);
+    const balances = stakeInfos.flatMap(([address, stakes]) => stakes.map(stake => {
+      const dynamicInfo = dynamicInfoByNetuid[stake.netuid];
+      const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+      return {
+        address,
+        tokenId: subDTaoTokenId(networkId, stake.netuid, stake.hotkey),
+        baseTokenId: subDTaoTokenId(networkId, stake.netuid),
+        stake: stake.stake,
+        hotkey: stake.hotkey,
+        netuid: stake.netuid,
+        scaledAlphaPrice
+      };
+    }));
+    const tokensById = keyBy(tokensWithAddresses.map(([token]) => token), t => t.id);
+    const dynamicTokens = [];
+
+    // identify tokens that were not requested but have balances
+    // BalanceProvider will be register them in ChaindataProvider at runtime, so they will be requested on next call
+    for (const bal of balances) {
+      if (!balanceDefs.some(def => def.token.id === bal.tokenId)) {
+        const baseToken = tokensById[bal.baseTokenId];
+        // define a token specific to this staking hotkey
+        if (baseToken) {
+          const cleanToken = getCleanToken(baseToken);
+          const newToken = TokenSchema.parse({
+            ...cleanToken,
+            id: bal.tokenId,
+            hotkey: bal.hotkey
+          });
+          dynamicTokens.push(newToken);
+        }
+      }
+    }
+    const success = balanceDefs.map(def => {
+      const stake = balances.find(b => b.address === def.address && b.tokenId === def.token.id);
+      const meta = {
+        scaledAlphaPrice: stake?.scaledAlphaPrice.toString() ?? "0"
+      };
+      const balanceValue = {
+        type: "free",
+        label: stake?.netuid === 0 ? "Root Staking" : `Subnet Staking`,
+        amount: stake?.stake.toString() ?? "0",
+        meta
+      };
+      return {
+        address: def.address,
+        networkId,
+        tokenId: def.token.id,
+        source: MODULE_TYPE$5,
+        status: "live",
+        values: [balanceValue]
+      };
+    });
+    return {
+      success,
+      errors: [],
+      dynamicTokens
+    };
+  } catch (err) {
+    log.warn("Failed to fetch balances for substrate-dtao", {
+      err
+    });
+    const errors = balanceDefs.map(def => ({
+      tokenId: def.token.id,
+      address: def.address,
+      error: new Error(`Failed to fetch balance for ${def.address} on ${networkId}`)
+    }));
+    return {
+      success: [],
+      errors
+    };
+  }
+};
+
+// hardcoded because we dont have access to native tokens from the balance module
+const NATIVE_TOKEN_SYMBOLS = {
+  "bittensor": "TAO",
+  "bittensor-testnet": "testTAO"
+};
+const fetchTokens$5 = async ({
+  networkId,
+  connector,
+  tokens,
+  miniMetadata
+}) => {
+  const anyMiniMetadata = miniMetadata;
+  if (!anyMiniMetadata?.data) return [];
+  const [transferableTokensMap, dynamicInfos] = await Promise.all([fetchTransferableTokensMap(connector, anyMiniMetadata.data, networkId), fetchRuntimeCallResult(connector, networkId, anyMiniMetadata.data, "SubnetInfoRuntimeApi", "get_all_dynamic_info", [])]);
+  return dynamicInfos.filter(isNotNil).map(info => {
+    const config = tokens.find(t => t.netuid === info.netuid);
+    let symbol = new TextDecoder().decode(Uint8Array.from(info.token_symbol));
+    const subnetName = info.subnet_identity?.subnet_name?.asText() ?? (info.netuid === 0 ? "Root" : `Subnet ${info.netuid}`);
+    const name = `SN${info.netuid} | ${subnetName} ${symbol}`;
+
+    // for root we want same symbol as native so they can be grouped together in portfolio
+    if (info.netuid === 0 && NATIVE_TOKEN_SYMBOLS[networkId]) symbol = NATIVE_TOKEN_SYMBOLS[networkId];
+
+    // if not stage in storage, consider transferable
+    const isTransferable = transferableTokensMap[info.netuid] ?? true;
+    const token = {
+      id: subDTaoTokenId(networkId, info.netuid),
+      type: MODULE_TYPE$5,
+      platform: PLATFORM$5,
+      networkId,
+      netuid: info.netuid,
+      isDefault: true,
+      symbol,
+      decimals: 9,
+      name,
+      subnetName,
+      isTransferable
+    };
+    return Object.assign({}, token, config);
+  }).filter(t => {
+    const parsed = SubDTaoTokenSchema.safeParse(t);
+    return parsed.success;
+  });
+};
+const fetchTransferableTokensMap = async (connector, metadata, networkId) => {
+  const {
+    builder
+  } = parseMetadataRpc(metadata);
+  const transferToggleCodec = builder.buildStorage("SubtensorModule", "TransferToggle");
+  const transferToggleKeys = await connector.send(networkId, "state_getKeys", [getStorageKeyPrefix("SubtensorModule", "TransferToggle")]);
+  const transferToggleResults = await connector.send(networkId, "state_queryStorageAt", [transferToggleKeys]);
+  const transferToggleEntries = transferToggleResults.length ? transferToggleResults[0].changes : [];
+  return fromPairs(transferToggleEntries.map(([key, value]) => {
+    const [netuid] = transferToggleCodec.keys.dec(key);
+    const isTransferable = transferToggleCodec.value.dec(value);
+    return [netuid, isTransferable];
+  }));
+};
+
+const getMiniMetadata$6 = ({
+  networkId,
+  specVersion,
+  metadataRpc
+}) => {
+  const source = MODULE_TYPE$5;
+  const chainId = networkId;
+  const systemVersion = getConstantValue(metadataRpc, "System", "Version");
+  if (specVersion !== systemVersion.spec_version) throw new Error(`specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`);
+  const id = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion
+  });
+  const {
+    unifiedMetadata
+  } = parseMetadataRpc(metadataRpc);
+  if (unifiedMetadata.version < 14) throw new Error(`Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`);
+  return {
+    id,
+    source,
+    chainId,
+    specVersion,
+    version: MINIMETADATA_VERSION,
+    data: getData$4(metadataRpc),
+    extra: null
+  };
+};
+const getData$4 = metadataRpc => {
+  const {
+    metadata,
+    unifiedMetadata
+  } = parseMetadataRpc(metadataRpc);
+  const isBittensor = unifiedMetadata.pallets.some(({
+    name
+  }) => name === "SubtensorModule");
+  if (!isBittensor) return null;
+  compactMetadata(metadata, [{
+    pallet: "SubtensorModule",
+    items: ["TransferToggle"]
+  }], [{
+    runtimeApi: "StakeInfoRuntimeApi",
+    methods: ["get_stake_info_for_coldkeys"]
+  }, {
+    runtimeApi: "SubnetInfoRuntimeApi",
+    methods: ["get_all_dynamic_info"]
+  }]);
+  return encodeMetadata(metadata);
+};
+
+const getTransferCallData$6 = ({
+  from,
+  to,
+  value,
+  token,
+  metadataRpc
+}) => {
+  if (!isTokenOfType(token, MODULE_TYPE$5)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$5}.`);
+  const {
+    netuid: subnetId,
+    hotkey
+  } = parseSubDTaoTokenId(token.id);
+  if (!hotkey) throw new Error(`Missing hotkey`);
+  const {
+    builder
+  } = parseMetadataRpc(metadataRpc);
+  const {
+    codec,
+    location
+  } = builder.buildCall("SubtensorModule", "transfer_stake");
+  const args = codec.enc({
+    origin_netuid: subnetId,
+    hotkey,
+    destination_coldkey: to,
+    destination_netuid: subnetId,
+    alpha_amount: value
+  });
+  const callData = Binary.fromBytes(mergeUint8([new Uint8Array(location), args]));
+  return {
+    address: from,
+    method: callData.asHex()
+  };
+};
+
+const SUBSCRIPTION_INTERVAL$2 = 6_000;
+const subscribeBalances$6 = ({
+  networkId,
+  tokensWithAddresses,
+  connector,
+  miniMetadata
+}) => {
+  if (!tokensWithAddresses.length) return of({
+    success: [],
+    errors: []
+  });
+  return new Observable(subscriber => {
+    const abortController = new AbortController();
+
+    // on hydration balances are fetched using a runtimeApi, which can't be subscribed to.
+    // => poll values for each block
+    const poll = async () => {
+      try {
+        if (abortController.signal.aborted) return;
+        const balances = await fetchBalances$5({
+          networkId,
+          tokensWithAddresses: tokensWithAddresses,
+          connector,
+          miniMetadata
+        });
+        if (abortController.signal.aborted) return;
+        subscriber.next(balances);
+        setTimeout(poll, SUBSCRIPTION_INTERVAL$2);
+      } catch (error) {
+        log.error("Error", {
+          module: MODULE_TYPE$5,
+          networkId,
+          miniMetadata,
+          addressesByToken: tokensWithAddresses,
+          error
+        });
+        subscriber.error(error);
+      }
+    };
+    poll();
+    return () => {
+      abortController.abort();
+    };
+  }).pipe(distinctUntilChanged(isEqual));
+};
+
+const SubDTaoBalanceModule = {
+  type: MODULE_TYPE$5,
+  platform: PLATFORM$5,
+  getMiniMetadata: getMiniMetadata$6,
+  fetchTokens: fetchTokens$5,
+  fetchBalances: fetchBalances$5,
+  subscribeBalances: subscribeBalances$6,
+  getTransferCallData: getTransferCallData$6
+};
+
+// to be used by chaindata too
+const SubDTaoTokenConfigSchema = z.strictObject({
+  netuid: SubDTaoTokenSchema.shape.netuid,
+  ...TokenConfigBaseSchema.shape
+});
+
+const ONE_ALPHA = 10n ** TAO_DECIMALS;
+
+/**
+ * To be used for tokens that don't have a coingecko id
+ *
+ * @param token
+ * @param tokenRates
+ * @param scaledAlphaPrice
+ * @returns
+ */
+const getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice) => {
+  try {
+    const taoTokenId = subNativeTokenId(token.networkId);
+    const taoTokenRates = tokenRates[taoTokenId];
+    if (!taoTokenRates) return null;
+
+    // for root subnet, same rates as TAO
+    if (token.netuid === 0) return structuredClone(taoTokenRates);
+    const alphaRates = newTokenRates();
+    for (const [currency, taoRate] of Object.entries(taoTokenRates)) {
+      if (!taoRate) {
+        alphaRates[currency] = null;
+      } else {
+        const taoPrice = alphaToTao(ONE_ALPHA, BigInt(scaledAlphaPrice));
+        const priceRatio = Number(taoPrice) / Number(ALPHA_PRICE_SCALE);
+        alphaRates[currency] = {
+          price: taoRate.price * priceRatio,
+          marketCap: taoRate.marketCap ? taoRate.marketCap * priceRatio : undefined,
+          change24h: undefined // cannot be determined from TAO rates alone
+        };
+      }
+    }
+    return alphaRates;
+  } catch (err) {
+    log.error(err);
+    return null;
+  }
+};
+
 function excludeFromTransferableAmount(locks) {
   if (typeof locks === "string") return BigInt(locks);
   if (!Array.isArray(locks)) locks = [locks];
@@ -2588,6 +2982,16 @@ class Balance {
       return lpTokenRates;
     }
 
+    // dTAO balances need to be converted to the native token to compute their rate, unless we have a coingeckoId
+    if (this.token?.type === "substrate-dtao" && !this.token.coingeckoId) {
+      if (!this.#db?.tokenRates) return null;
+      const balances = this.#valueGetter.get("free");
+      if (!balances.length) return null;
+      const balanceMeta = balances[0].meta;
+      if (!balanceMeta?.scaledAlphaPrice) return null;
+      return getDTaoTokenRates(this.token, this.#db.tokenRates, balanceMeta.scaledAlphaPrice);
+    }
+
     // other tokens can just pick from the tokenRates db using the tokenId
     return this.#db?.tokenRates && this.#db.tokenRates[this.tokenId] || null;
   }
@@ -2634,9 +3038,7 @@ class Balance {
     const nomPoolStakedPlancks = this.locks.some(lock => lock.source === "substrate-native-holds" && lock.label === "DelegatedStaking") ? 0n : this.nompools.map(({
       amount
     }) => amount.planck).reduce((a, b) => a + b, 0n);
-    return this.#format(this.free.planck + this.reserved.planck + nomPoolStakedPlancks + this.subtensor.map(({
-      amount
-    }) => amount.planck).reduce((a, b) => a + b, 0n) + includeInTotalExtraAmount(extra));
+    return this.#format(this.free.planck + this.reserved.planck + nomPoolStakedPlancks + includeInTotalExtraAmount(extra));
   }
   /** The non-reserved balance of this token. Includes the frozen amount. Is included in the total. */
   get free() {
@@ -2673,9 +3075,6 @@ class Balance {
   get nompools() {
     return this.getValue("nompool");
   }
-  get subtensor() {
-    return this.getValue("subtensor");
-  }
 
   /** The extra balance of this token */
   get extra() {
@@ -2748,8 +3147,7 @@ class Balance {
     const nomPoolStakedPlancks = this.locks.some(lock => lock.source === "substrate-native-holds" && lock.label === "DelegatedStaking") ? 0n : this.nompools.map(({
       amount
     }) => amount.planck).reduce((a, b) => a + b, 0n);
-    const otherUnavailable = nomPoolStakedPlancks + this.subtensor.reduce((total, each) => total + each.amount.planck, 0n);
-    return this.#format(baseUnavailable + otherUnavailable);
+    return this.#format(baseUnavailable + nomPoolStakedPlancks);
   }
 
   /** The feePayable balance of this token. Is generally the free amount - the feeFrozen amount. */
@@ -2996,13 +3394,6 @@ const getValueId = amount => {
     const meta = amount.meta;
     if (!meta) return "";
     if (amount.type === "nompool") return meta.poolId?.toString() ?? "";
-    if (amount.type === "subtensor") {
-      const {
-        hotkey,
-        netuid
-      } = meta;
-      if (hotkey && netuid !== undefined) return `${hotkey.toString()}${netuid.toString()}`;
-    }
     return "";
   };
   return [amount.label, amount.type, amount.source, getMetaId()].join("::");
@@ -3024,7 +3415,7 @@ const getMiniMetadata$5 = ({
   specVersion,
   metadataRpc
 }) => {
-  const source = MODULE_TYPE$5;
+  const source = MODULE_TYPE$6;
   const chainId = networkId;
   const systemVersion = getConstantValue(metadataRpc, "System", "Version");
   if (specVersion !== systemVersion.spec_version) throw new Error(`specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`);
@@ -3070,7 +3461,7 @@ const getTransferCallData$5 = ({
   type,
   metadataRpc
 }) => {
-  if (!isTokenOfType(token, MODULE_TYPE$5)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$5}.`);
+  if (!isTokenOfType(token, MODULE_TYPE$6)) throw new Error(`Token type ${token.type} is not ${MODULE_TYPE$6}.`);
   const {
     builder
   } = parseMetadataRpc(metadataRpc);
@@ -3178,11 +3569,11 @@ const subscribeBalances$5 = ({
 };
 
 const SubAssetsBalanceModule = {
-  type: MODULE_TYPE$5,
-  platform: PLATFORM$5,
+  type: MODULE_TYPE$6,
+  platform: PLATFORM$6,
   getMiniMetadata: getMiniMetadata$5,
-  fetchTokens: fetchTokens$5,
-  fetchBalances: fetchBalances$5,
+  fetchTokens: fetchTokens$6,
+  fetchBalances: fetchBalances$6,
   subscribeBalances: subscribeBalances$5,
   getTransferCallData: getTransferCallData$5
 };
@@ -3903,154 +4294,6 @@ const SubHydrationBalanceModule = {
 const MODULE_TYPE$2 = SubNativeTokenSchema.shape.type.value;
 const PLATFORM$2 = SubNativeTokenSchema.shape.platform.value;
 
-const SUBTENSOR_ROOT_NETUID = 0;
-const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = 1000000n;
-const TAO_DECIMALS = 9n;
-const SCALE_FACTOR = 10n ** TAO_DECIMALS; // Equivalent to 10e9 for precision
-const ONE_ALPHA_TOKEN = SCALE_FACTOR;
-const calculateAlphaPrice = ({
-  dynamicInfo
-}) => {
-  if (!dynamicInfo) return 0n;
-  const {
-    alpha_in,
-    tao_in
-  } = dynamicInfo;
-
-  // Scale taoIn before division to preserve precision
-  const result = tao_in * SCALE_FACTOR / alpha_in;
-  return result; // Scaled price as bigint
-};
-const calculateTaoAmountFromAlpha = ({
-  alphaPrice,
-  alphaStaked
-}) => {
-  if (!alphaStaked || !alphaPrice) return 0n;
-  const expectedAlpha = alphaStaked * alphaPrice;
-  return expectedAlpha / SCALE_FACTOR;
-};
-const calculateTaoFromDynamicInfo = ({
-  dynamicInfo,
-  alphaStaked
-}) => {
-  const alphaPrice = calculateAlphaPrice({
-    dynamicInfo
-  });
-  return calculateTaoAmountFromAlpha({
-    alphaPrice,
-    alphaStaked
-  });
-};
-
-// per address, lists of values to add to the native balance
-
-const getSubtensorStakingBalances$ = (connector, networkId, balanceDefs, miniMetadata) => {
-  const addresses = balanceDefs.map(def => def.address);
-  const token = balanceDefs[0].token;
-  if (!addresses.length || !token || !miniMetadata.extra.hasSubtensorPallet || !miniMetadata.data) return of({});
-
-  // we are only doing runtime calls, there is no way to subscribe to changes, except polling
-  // => start immediately, then repeat every 30 seconds
-  return timer(0, 30000).pipe(switchMap(() => from(fetchStakeInfoByAddress(connector, networkId, miniMetadata, addresses)).pipe(switchMap(stakeInfoByAddress => fetchStakingBalanceValuesByAddress(connector, networkId, miniMetadata, stakeInfoByAddress)))));
-};
-const fetchStakingBalanceValuesByAddress = async (connector, networkId, miniMetadata, stakeInfoByAddress) => {
-  const uniqueNetuids = uniq(values(stakeInfoByAddress).flatMap(infos => infos.map(info => info.netuid))).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID);
-  const dynamicInfoByNetuid = await fetchDynamicInfoByNetuid(connector, networkId, miniMetadata, uniqueNetuids);
-  return fromPairs(toPairs(stakeInfoByAddress).map(([address, stakeInfos]) => {
-    const stakesBalances = stakeInfos.filter(({
-      stake
-    }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK).map(({
-      hotkey,
-      netuid,
-      stake
-    }) => ({
-      hotkey,
-      netuid: Number(netuid),
-      stake: BigInt(stake),
-      dynamicInfo: dynamicInfoByNetuid[Number(netuid)]
-    })).map(({
-      hotkey,
-      stake,
-      netuid,
-      dynamicInfo
-    }) => {
-      const {
-        token_symbol,
-        subnet_name,
-        subnet_identity
-      } = dynamicInfo ?? {};
-      const tokenSymbol = new TextDecoder().decode(Uint8Array.from(token_symbol ?? []));
-      const subnetName = new TextDecoder().decode(Uint8Array.from(subnet_name ?? []));
-      const subnetIdentity = subnet_identity ? fromPairs(toPairs(subnet_identity).map(([key, binary]) => [key, binary.asText()])) : undefined;
-
-      // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
-      const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
-        dynamicInfo,
-        alphaStaked: stake
-      }) : 1n;
-      const alphaToTaoRate = calculateTaoFromDynamicInfo({
-        dynamicInfo: dynamicInfo ?? null,
-        alphaStaked: ONE_ALPHA_TOKEN
-      }).toString();
-      const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
-      const balanceValue = {
-        source: "subtensor-staking",
-        type: "subtensor",
-        label: "subtensor-staking",
-        amount: stakeByNetuid.toString(),
-        meta: {
-          type: "subtensor-staking",
-          hotkey,
-          netuid,
-          amountStaked: stake.toString(),
-          alphaToTaoRate,
-          dynamicInfo: {
-            tokenSymbol,
-            subnetName,
-            subnetIdentity: {
-              ...subnetIdentity,
-              subnetName: subnetIdentity?.subnet_name || subnetName
-            }
-          }
-        }
-      };
-      return balanceValue;
-    });
-    return [address, stakesBalances];
-  }));
-};
-const fetchStakeInfoByAddress = async (connector, networkId, miniMetadata, addresses) => {
-  const pairs = await Promise.all(addresses.map(async address => [address, await withRetry(() => fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "StakeInfoRuntimeApi", "get_stake_info_for_coldkey", [address]), {
-    delay: 500,
-    retryCount: 3
-  })]));
-  return fromPairs(pairs);
-};
-
-// assume dynamic info doesnt change over the course of a browser session
-const dynamicInfoCache = new Map();
-const getCacheKey$1 = (networkId, netuid) => `${networkId}:${netuid}`;
-const fetchDynamicInfoByNetuid = async (connector, networkId, miniMetadata, uniqueNetuids) => {
-  const fetchInfo = async netuid => {
-    if (netuid === SUBTENSOR_ROOT_NETUID) return null;
-    const cacheKey = getCacheKey$1(networkId, netuid);
-    if (!dynamicInfoCache.has(cacheKey)) {
-      await withRetry(async () => {
-        const result = await fetchRuntimeCallResult(connector, networkId, miniMetadata.data, "SubnetInfoRuntimeApi", "get_dynamic_info", [netuid]);
-        dynamicInfoCache.set(cacheKey, result); // Cache successful response
-
-        return result;
-      }, {
-        delay: 500,
-        retryCount: 3
-      });
-    }
-    return dynamicInfoCache.get(cacheKey) ?? null;
-  };
-  const results = await Promise.all(uniqueNetuids.map(async netuid => [netuid, await fetchInfo(netuid)]));
-  return fromPairs(results);
-};
-
 const getOtherType = input => `other-${input}`;
 
 /**
@@ -4491,17 +4734,6 @@ const fetchBalances$2 = async ({
   // now for each balance that includes nomPoolStaking, we need to fetch the metadata for the pool
   const nomPoolQueries = buildNomPoolQueries(networkId, partialBalances, miniMetadata);
   const balances = await fetchRpcQueryPack(connector, networkId, nomPoolQueries);
-
-  // TODO ⚠️ dedupe locks
-
-  const subtensorBalances$ = getSubtensorStakingBalances$(connector, networkId, balanceDefs, miniMetadata);
-  const subtensorBalancesByAddress = await firstValueFrom(subtensorBalances$);
-  for (const [address, subtensorBalances] of Object.entries(subtensorBalancesByAddress)) {
-    const balance = balances.find(b => b.address === address);
-    if (balance?.values) balance.values = [...balance.values.filter(({
-      source
-    }) => source !== "subtensor-staking"), ...subtensorBalances];
-  }
   return {
     success: balances,
     errors: []
@@ -4590,7 +4822,6 @@ const getMiniMetadata$2 = ({
   };
   const existentialDeposit = tryGetConstantValue(metadataRpc, "Balances", "ExistentialDeposit")?.toString();
   const nominationPoolsPalletId = tryGetConstantValue(metadataRpc, "NominationPools", "PalletId")?.asText();
-  const hasSubtensorPallet = !!tryGetConstantValue(metadataRpc, "SubtensorModule", "KeySwapCost");
   const hasFreezesItem = Boolean(unifiedMetadata.pallets.find(({
     name
   }) => name === "Balances")?.storage?.items.find(({
@@ -4610,15 +4841,6 @@ const getMiniMetadata$2 = ({
   }, {
     pallet: "Staking",
     items: ["Ledger"]
-  }, {
-    pallet: "SubtensorModule",
-    items: ["StakingHotkeys", "Stake"]
-  }], [{
-    runtimeApi: "StakeInfoRuntimeApi",
-    methods: ["get_stake_info_for_coldkey"]
-  }, {
-    runtimeApi: "SubnetInfoRuntimeApi",
-    methods: ["get_dynamic_info"]
   }]);
   return {
     id,
@@ -4630,8 +4852,7 @@ const getMiniMetadata$2 = ({
     extra: {
       useLegacyTransferableCalculation,
       existentialDeposit,
-      nominationPoolsPalletId,
-      hasSubtensorPallet
+      nominationPoolsPalletId
     }
   };
 };
@@ -4741,19 +4962,12 @@ const subscribeBalances$2 = ({
   // could be use as shared observable key if we decide to cache the sub
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   const baseQueries = buildBaseQueries(networkId, balanceDefs, miniMetadata);
-  const baseBalances$ = getRpcQueryPack$(connector, networkId, baseQueries).pipe(switchMap(partialBalances => {
+  return getRpcQueryPack$(connector, networkId, baseQueries).pipe(switchMap(partialBalances => {
     // now for each balance that includes nomPoolStaking, we need to fetch the metadata for the pool
     const nomPoolQueries = buildNomPoolQueries(networkId, partialBalances, miniMetadata);
     return getRpcQueryPack$(connector, networkId, nomPoolQueries);
-  }));
-  const subtensorBalancesByAddress$ = getSubtensorStakingBalances$(connector, networkId, balanceDefs, miniMetadata);
-  return combineLatest([baseBalances$, subtensorBalancesByAddress$]).pipe(map(([baseBalances, subtensorBalancesByAddress]) => ({
-    success: [...baseBalances.map(b => ({
-      ...b,
-      values: [...(b.values?.filter(({
-        source
-      }) => source !== "subtensor-staking") ?? []), ...(subtensorBalancesByAddress[b.address] ?? [])]
-    }))],
+  }), map(balances => ({
+    success: balances,
     errors: []
   })));
 };
@@ -4785,8 +4999,7 @@ const SubNativeMiniMetadataExtraSchema = z.strictObject({
   disable: z.boolean().optional(),
   useLegacyTransferableCalculation: z.boolean().optional(),
   existentialDeposit: z.string().optional(),
-  nominationPoolsPalletId: z.string().optional(),
-  hasSubtensorPallet: z.boolean().optional()
+  nominationPoolsPalletId: z.string().optional()
 });
 
 // Do not use this type outside of this module
@@ -6589,7 +6802,7 @@ const SubTokensMiniMetadataExtraSchema = z.strictObject({
   palletId: z.string()
 });
 
-const BALANCE_MODULES = [SubNativeBalanceModule, SubAssetsBalanceModule, SubHydrationBalanceModule, SubForeignAssetsBalanceModule, SubPsp22BalanceModule, SubTokensBalanceModule, EvmErc20BalanceModule, EvmUniswapV2BalanceModule, EvmNativeBalanceModule, SolNativeBalanceModule, SolSplBalanceModule];
+const BALANCE_MODULES = [SubNativeBalanceModule, SubAssetsBalanceModule, SubDTaoBalanceModule, SubHydrationBalanceModule, SubForeignAssetsBalanceModule, SubPsp22BalanceModule, SubTokensBalanceModule, EvmErc20BalanceModule, EvmUniswapV2BalanceModule, EvmNativeBalanceModule, SolNativeBalanceModule, SolSplBalanceModule];
 
 // share requests as all modules will call this at once
 const CACHE$1 = new Map();
@@ -6745,7 +6958,8 @@ class BalancesProvider {
       balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
         ...b,
         status: "stale"
-      } : b)).sort(sortByBalanceId)
+      } : b)).sort(sortByBalanceId),
+      failedBalanceIds: results.flatMap(result => result.failedBalanceIds)
     })), distinctUntilChanged(isEqual));
   }
   fetchBalances(addressesByTokenId) {
@@ -6786,17 +7000,25 @@ class BalancesProvider {
               });
               return of({
                 status: "live",
-                balances: []
+                balances: [],
+                failedBalanceIds: []
               });
             }
         }
       }));
     }), map(results => {
+      // for each balance that could not be fetched, see if we have a stored balance and return it, marked as stale
+      const errorBalanceIds = results.flatMap(result => result.failedBalanceIds);
+      const staleBalances = errorBalanceIds.map(balanceId => this.#storage.value.balances[balanceId]).filter(isNotNil).map(b => ({
+        ...b,
+        status: "stale"
+      }));
       return {
         status: results.some(({
           status
         }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+        balances: results.flatMap(result => result.balances).concat(staleBalances).sort(sortByBalanceId),
+        failedBalanceIds: []
       };
     }), distinctUntilChanged(isEqual));
   }
@@ -6808,7 +7030,8 @@ class BalancesProvider {
     }, () => {
       if (!tokensWithAddresses.length) return of({
         status: "live",
-        balances: []
+        balances: [],
+        failedBalanceIds: []
       });
       const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
 
@@ -6821,7 +7044,8 @@ class BalancesProvider {
         log.warn("[balances] no substrate connector or miniMetadata for module", mod.type);
         return defer(() => of({
           status: "initialising",
-          balances: this.getStoredBalances(moduleAddressesByTokenId)
+          balances: this.getStoredBalances(moduleAddressesByTokenId),
+          failedBalanceIds: []
         }));
       }
       const moduleBalances$ = this.getNetworkMiniMetadatas$(networkId).pipe(map(miniMetadatas => miniMetadatas.find(m => m.source === mod.type)), switchMap(miniMetadata => mod.subscribeBalances({
@@ -6831,10 +7055,22 @@ class BalancesProvider {
         miniMetadata: miniMetadata
       })), catchError(() => EMPTY),
       // don't emit, let provider mark balances stale
-      map(results => ({
+      tap(results => {
+        if (results.dynamicTokens?.length) {
+          // register missing tokens in the chaindata provider
+          this.#chaindataProvider.registerDynamicTokens(results.dynamicTokens);
+        }
+      }), map(results => ({
         status: "live",
         // exclude zero balances
-        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n),
+        failedBalanceIds: results.errors.map(({
+          tokenId,
+          address
+        }) => getBalanceId({
+          tokenId,
+          address
+        }))
       })), tap(results => {
         this.updateStorage$(balanceIds, results);
       }),
@@ -6847,7 +7083,8 @@ class BalancesProvider {
       // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
       return defer(() => moduleBalances$.pipe(startWith({
         status: "initialising",
-        balances: this.getStoredBalances(moduleAddressesByTokenId)
+        balances: this.getStoredBalances(moduleAddressesByTokenId),
+        failedBalanceIds: []
       })));
     });
   }
@@ -6859,7 +7096,8 @@ class BalancesProvider {
     }, () => {
       if (!tokensWithAddresses.length) return of({
         status: "live",
-        balances: []
+        balances: [],
+        failedBalanceIds: []
       });
       const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
 
@@ -6872,7 +7110,8 @@ class BalancesProvider {
         log.warn("[balances] no ethereum connector for module", mod.type);
         return defer(() => of({
           status: "initialising",
-          balances: this.getStoredBalances(moduleAddressesByTokenId)
+          balances: this.getStoredBalances(moduleAddressesByTokenId),
+          failedBalanceIds: []
         }));
       }
       const moduleBalances$ = mod.subscribeBalances({
@@ -6884,7 +7123,14 @@ class BalancesProvider {
       map(results => ({
         status: "live",
         // exclude zero balances
-        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n),
+        failedBalanceIds: results.errors.map(({
+          tokenId,
+          address
+        }) => getBalanceId({
+          tokenId,
+          address
+        }))
       })), tap(results => {
         this.updateStorage$(balanceIds, results);
       }),
@@ -6897,7 +7143,8 @@ class BalancesProvider {
       // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
       return defer(() => moduleBalances$.pipe(startWith({
         status: "initialising",
-        balances: this.getStoredBalances(moduleAddressesByTokenId)
+        balances: this.getStoredBalances(moduleAddressesByTokenId),
+        failedBalanceIds: []
       })));
     });
   }
@@ -6909,7 +7156,8 @@ class BalancesProvider {
     }, () => {
       if (!tokensWithAddresses.length) return of({
         status: "live",
-        balances: []
+        balances: [],
+        failedBalanceIds: []
       });
       const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
 
@@ -6922,7 +7170,8 @@ class BalancesProvider {
         log.warn("[balances] no solana connector for module", mod.type);
         return defer(() => of({
           status: "initialising",
-          balances: this.getStoredBalances(moduleAddressesByTokenId)
+          balances: this.getStoredBalances(moduleAddressesByTokenId),
+          failedBalanceIds: []
         }));
       }
       const moduleBalances$ = mod.subscribeBalances({
@@ -6934,7 +7183,14 @@ class BalancesProvider {
       map(results => ({
         status: "live",
         // exclude zero balances
-        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n),
+        failedBalanceIds: results.errors.map(({
+          tokenId,
+          address
+        }) => getBalanceId({
+          tokenId,
+          address
+        }))
       })), tap(results => {
         this.updateStorage$(balanceIds, results);
       }),
@@ -6947,7 +7203,8 @@ class BalancesProvider {
       // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
       return defer(() => moduleBalances$.pipe(startWith({
         status: "initialising",
-        balances: this.getStoredBalances(moduleAddressesByTokenId)
+        balances: this.getStoredBalances(moduleAddressesByTokenId),
+        failedBalanceIds: []
       })));
     });
   }
@@ -6955,13 +7212,19 @@ class BalancesProvider {
     if (balancesResult.status !== "live") return;
     const storage = this.#storage.getValue();
     const balances = assign({}, storage.balances,
-    // delete all balances expected in the result set. because if they are not present it means they are empty.
-    fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), keyBy(
+    // delete all balances expected in the result set (except the ones that failed). because if they are not present it means they are empty.
+    fromPairs(balanceIds.filter(bid => !balancesResult.failedBalanceIds.includes(bid)).map(balanceId => [balanceId, undefined])), keyBy(
     // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
     balancesResult.balances.map(b => ({
       ...b,
       status: "cache"
     })), b => getBalanceId(b)));
+
+    // update status of stale balances
+    for (const errorBalanceId of balancesResult.failedBalanceIds) {
+      const balance = balances[errorBalanceId];
+      if (balance) balance.status = "stale";
+    }
     this.#storage.next(assign({}, storage, {
       balances
     }));
@@ -7099,4 +7362,4 @@ const isAddressCompatibleWithNetwork = (network, address) => {
 const sortByBalanceId = (a, b) => getBalanceId(a).localeCompare(getBalanceId(b));
 const sortByMiniMetadataId = (a, b) => a.id.localeCompare(b.id);
 
-export { BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, BalancesProvider, Change24hCurrencyFormatter, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SolNativeBalanceModule, SolNativeTokenConfigSchema, SolSplBalanceModule, SolSplTokenConfigSchema, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, abiMulticall, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, deriveMiniMetadataId, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getLockedType, getValueId, includeInTotalExtraAmount, uniswapV2PairAbi };
+export { ALPHA_PRICE_SCALE, BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, BalancesProvider, Change24hCurrencyFormatter, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, PlanckSumBalancesFormatter, SolNativeBalanceModule, SolNativeTokenConfigSchema, SolSplBalanceModule, SolSplTokenConfigSchema, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubDTaoBalanceModule, SubDTaoTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, TAO_DECIMALS, abiMulticall, alphaToTao, deriveMiniMetadataId, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getDTaoTokenRates, getLockTitle, getLockedType, getScaledAlphaPrice, getValueId, includeInTotalExtraAmount, taoToAlpha, uniswapV2PairAbi };