@talismn/balances 0.0.0-pr2043-20250626090303 → 0.0.0-pr2043-20250626133240

package/dist/talismn-balances.esm.js

@@ -112,7 +112,7 @@ class EvmTokenFetcher {
 
 var pkg = {
 	name: "@talismn/balances",
-	version: "0.0.0-pr2043-20250626090303"};
+	version: "0.0.0-pr2043-20250626133240"};
 
 var log = anylogger(pkg.name);
 
@@ -3645,11 +3645,18 @@ const getAddresssesByTokenByNetwork = addressesByToken => {
 };
 
 async function subscribeBase(queries, chainConnector, callback) {
-  const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
-    if (error) callback(error);
-    if (result && result.length > 0) callback(null, result);
-  });
-  return unsubscribe;
+  try {
+    const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
+      if (error) callback(error);
+      if (result && result.length > 0) callback(null, result);
+    });
+    return unsubscribe;
+  } catch (err) {
+    if (!isAbortError(err)) log.error("Error subscribing to base queries", {
+      err
+    });
+    return () => {};
+  }
 }
 
 /**
@@ -3686,284 +3693,291 @@ const nompoolStashAccountId = (palletId, poolId) => nompoolAccountId(palletId, p
 
 // TODO make this method chain-specific
 async function subscribeNompoolStaking(chaindataProvider, chainConnector, addressesByToken, callback, signal) {
-  const allChains = await chaindataProvider.getNetworksMapById("polkadot");
-  const tokens = await chaindataProvider.getTokensMapById();
-
-  // there should be only one network here when subscribing to balances, we've split it up by network at the top level
-  const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
-  const miniMetadatas = new Map();
-  for (const networkId of networkIds) {
-    const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native");
-    miniMetadatas.set(networkId, miniMetadata);
-  }
-  signal?.throwIfAborted();
-  const nomPoolTokenIds = Object.entries(tokens).filter(([, token]) => {
-    // ignore non-native tokens
-    if (token.type !== "substrate-native") return false;
-
-    // ignore tokens on chains with no nompools pallet
-    const miniMetadata = miniMetadatas.get(token.networkId);
-    return typeof miniMetadata?.extra?.nominationPoolsPalletId === "string";
-  }).map(([tokenId]) => tokenId);
-
-  // staking can only be done by the native token on chains with the staking pallet
-  const addressesByNomPoolToken = Object.fromEntries(Object.entries(addressesByToken)
-  // remove ethereum addresses
-  .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
-  // remove tokens which aren't nom pool tokens
-  .filter(([tokenId]) => nomPoolTokenIds.includes(tokenId)));
-  const uniqueChainIds = getUniqueChainIds(addressesByNomPoolToken, tokens);
-  const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
-  const chainStorageCoders = buildStorageCoders({
-    chainIds: uniqueChainIds,
-    chains,
-    miniMetadatas,
-    coders: {
-      poolMembers: ["NominationPools", "PoolMembers"],
-      bondedPools: ["NominationPools", "BondedPools"],
-      ledger: ["Staking", "Ledger"],
-      metadata: ["NominationPools", "Metadata"]
-    }
-  });
-  const resultUnsubscribes = [];
-  for (const [tokenId, addresses] of Object.entries(addressesByNomPoolToken)) {
-    const token = tokens[tokenId];
-    if (!token) {
-      log.warn(`Token ${tokenId} not found`);
-      continue;
-    }
-    if (token.type !== "substrate-native") {
-      log.debug(`This module doesn't handle tokens of type ${token.type}`);
-      continue;
-    }
-    const chainId = token.networkId;
-    if (!chainId) {
-      log.warn(`Token ${tokenId} has no chain`);
-      continue;
-    }
-    const chain = chains[chainId];
-    if (!chain) {
-      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
-      continue;
+  try {
+    const allChains = await chaindataProvider.getNetworksMapById("polkadot");
+    const tokens = await chaindataProvider.getTokensMapById();
+
+    // there should be only one network here when subscribing to balances, we've split it up by network at the top level
+    const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
+    const miniMetadatas = new Map();
+    for (const networkId of networkIds) {
+      const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native");
+      miniMetadatas.set(networkId, miniMetadata);
     }
-    const miniMetadata = miniMetadatas.get(chainId);
-    const {
-      nominationPoolsPalletId
-    } = miniMetadata?.extra ?? {};
-    const subscribePoolMembers = (addresses, callback) => {
-      const scaleCoder = chainStorageCoders.get(chainId)?.poolMembers;
-      const queries = addresses.flatMap(address => {
-        const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} poolMembers query ${address}`, address);
-        if (!stateKey) return [];
-        const decodeResult = change => {
-          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-          const decoded = decodeScale(scaleCoder, change, `Failed to decode poolMembers on chain ${chainId}`);
-          const poolId = decoded?.pool_id?.toString?.();
-          const points = decoded?.points?.toString?.();
-          const unbondingEras = Array.from(decoded?.unbonding_eras ?? []).flatMap(entry => {
-            if (entry === undefined) return [];
-            const [key, value] = Array.from(entry);
-            const era = key?.toString?.();
-            const amount = value?.toString?.();
-            if (typeof era !== "string" || typeof amount !== "string") return [];
+    signal?.throwIfAborted();
+    const nomPoolTokenIds = Object.entries(tokens).filter(([, token]) => {
+      // ignore non-native tokens
+      if (token.type !== "substrate-native") return false;
+
+      // ignore tokens on chains with no nompools pallet
+      const miniMetadata = miniMetadatas.get(token.networkId);
+      return typeof miniMetadata?.extra?.nominationPoolsPalletId === "string";
+    }).map(([tokenId]) => tokenId);
+
+    // staking can only be done by the native token on chains with the staking pallet
+    const addressesByNomPoolToken = Object.fromEntries(Object.entries(addressesByToken)
+    // remove ethereum addresses
+    .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
+    // remove tokens which aren't nom pool tokens
+    .filter(([tokenId]) => nomPoolTokenIds.includes(tokenId)));
+    const uniqueChainIds = getUniqueChainIds(addressesByNomPoolToken, tokens);
+    const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
+    const chainStorageCoders = buildStorageCoders({
+      chainIds: uniqueChainIds,
+      chains,
+      miniMetadatas,
+      coders: {
+        poolMembers: ["NominationPools", "PoolMembers"],
+        bondedPools: ["NominationPools", "BondedPools"],
+        ledger: ["Staking", "Ledger"],
+        metadata: ["NominationPools", "Metadata"]
+      }
+    });
+    const resultUnsubscribes = [];
+    for (const [tokenId, addresses] of Object.entries(addressesByNomPoolToken)) {
+      const token = tokens[tokenId];
+      if (!token) {
+        log.warn(`Token ${tokenId} not found`);
+        continue;
+      }
+      if (token.type !== "substrate-native") {
+        log.debug(`This module doesn't handle tokens of type ${token.type}`);
+        continue;
+      }
+      const chainId = token.networkId;
+      if (!chainId) {
+        log.warn(`Token ${tokenId} has no chain`);
+        continue;
+      }
+      const chain = chains[chainId];
+      if (!chain) {
+        log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+        continue;
+      }
+      const miniMetadata = miniMetadatas.get(chainId);
+      const {
+        nominationPoolsPalletId
+      } = miniMetadata?.extra ?? {};
+      const subscribePoolMembers = (addresses, callback) => {
+        const scaleCoder = chainStorageCoders.get(chainId)?.poolMembers;
+        const queries = addresses.flatMap(address => {
+          const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} poolMembers query ${address}`, address);
+          if (!stateKey) return [];
+          const decodeResult = change => {
+            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+            const decoded = decodeScale(scaleCoder, change, `Failed to decode poolMembers on chain ${chainId}`);
+            const poolId = decoded?.pool_id?.toString?.();
+            const points = decoded?.points?.toString?.();
+            const unbondingEras = Array.from(decoded?.unbonding_eras ?? []).flatMap(entry => {
+              if (entry === undefined) return [];
+              const [key, value] = Array.from(entry);
+              const era = key?.toString?.();
+              const amount = value?.toString?.();
+              if (typeof era !== "string" || typeof amount !== "string") return [];
+              return {
+                era,
+                amount
+              };
+            });
             return {
-              era,
-              amount
+              tokenId,
+              address,
+              poolId,
+              points,
+              unbondingEras
             };
-          });
+          };
           return {
-            tokenId,
-            address,
+            chainId,
+            stateKey,
+            decodeResult
+          };
+        });
+        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+        return () => subscription.then(unsubscribe => unsubscribe());
+      };
+      const subscribePoolPoints = (poolIds, callback) => {
+        if (poolIds.length === 0) callback(null, []);
+        const scaleCoder = chainStorageCoders.get(chainId)?.bondedPools;
+        const queries = poolIds.flatMap(poolId => {
+          const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} bondedPools query ${poolId}`, poolId);
+          if (!stateKey) return [];
+          const decodeResult = change => {
+            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+            const decoded = decodeScale(scaleCoder, change, `Failed to decode bondedPools on chain ${chainId}`);
+            const points = decoded?.points?.toString?.();
+            return {
+              poolId,
+              points
+            };
+          };
+          return {
+            chainId,
+            stateKey,
+            decodeResult
+          };
+        });
+        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+        return () => subscription.then(unsubscribe => unsubscribe());
+      };
+      const subscribePoolStake = (poolIds, callback) => {
+        if (poolIds.length === 0) callback(null, []);
+        const scaleCoder = chainStorageCoders.get(chainId)?.ledger;
+        const queries = poolIds.flatMap(poolId => {
+          if (!nominationPoolsPalletId) return [];
+          const stashAddress = nompoolStashAccountId(nominationPoolsPalletId, poolId);
+          const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} ledger query ${stashAddress}`, stashAddress);
+          if (!stateKey) return [];
+          const decodeResult = change => {
+            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+            const decoded = decodeScale(scaleCoder, change, `Failed to decode ledger on chain ${chainId}`);
+            const activeStake = decoded?.active?.toString?.();
+            return {
+              poolId,
+              activeStake
+            };
+          };
+          return {
+            chainId,
+            stateKey,
+            decodeResult
+          };
+        });
+        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+        return () => subscription.then(unsubscribe => unsubscribe());
+      };
+      const subscribePoolMetadata = (poolIds, callback) => {
+        if (poolIds.length === 0) callback(null, []);
+        const scaleCoder = chainStorageCoders.get(chainId)?.metadata;
+        const queries = poolIds.flatMap(poolId => {
+          if (!nominationPoolsPalletId) return [];
+          const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} metadata query ${poolId}`, poolId);
+          if (!stateKey) return [];
+          const decodeResult = change => {
+            /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+            const decoded = decodeScale(scaleCoder, change, `Failed to decode metadata on chain ${chainId}`);
+            const metadata = decoded?.asText?.();
+            return {
+              poolId,
+              metadata
+            };
+          };
+          return {
+            chainId,
+            stateKey,
+            decodeResult
+          };
+        });
+        const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
+        return () => subscription.then(unsubscribe => unsubscribe());
+      };
+      const poolMembersByAddress$ = asObservable(subscribePoolMembers)(addresses).pipe(scan((state, next) => {
+        for (const poolMembers of next) {
+          const {
             poolId,
             points,
             unbondingEras
-          };
-        };
-        return {
-          chainId,
-          stateKey,
-          decodeResult
-        };
-      });
-      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-      return () => subscription.then(unsubscribe => unsubscribe());
-    };
-    const subscribePoolPoints = (poolIds, callback) => {
-      if (poolIds.length === 0) callback(null, []);
-      const scaleCoder = chainStorageCoders.get(chainId)?.bondedPools;
-      const queries = poolIds.flatMap(poolId => {
-        const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} bondedPools query ${poolId}`, poolId);
-        if (!stateKey) return [];
-        const decodeResult = change => {
-          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-          const decoded = decodeScale(scaleCoder, change, `Failed to decode bondedPools on chain ${chainId}`);
-          const points = decoded?.points?.toString?.();
-          return {
+          } = poolMembers;
+          if (typeof poolId === "string" && typeof points === "string") state.set(poolMembers.address, {
+            poolId,
+            points,
+            unbondingEras
+          });else state.set(poolMembers.address, null);
+        }
+        return state;
+      }, new Map()), share());
+      const poolIdByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.poolId ?? null]))));
+      const pointsByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.points ?? null]))));
+      const unbondingErasByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.unbondingEras ?? null]))));
+      const poolIds$ = poolIdByAddress$.pipe(map(byAddress => [...new Set(Array.from(byAddress.values()).flatMap(poolId => poolId ?? []))]));
+      const pointsByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolPoints)(poolIds)), switchAll(), scan((state, next) => {
+        for (const poolPoints of next) {
+          const {
             poolId,
             points
-          };
-        };
-        return {
-          chainId,
-          stateKey,
-          decodeResult
-        };
-      });
-      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-      return () => subscription.then(unsubscribe => unsubscribe());
-    };
-    const subscribePoolStake = (poolIds, callback) => {
-      if (poolIds.length === 0) callback(null, []);
-      const scaleCoder = chainStorageCoders.get(chainId)?.ledger;
-      const queries = poolIds.flatMap(poolId => {
-        if (!nominationPoolsPalletId) return [];
-        const stashAddress = nompoolStashAccountId(nominationPoolsPalletId, poolId);
-        const stateKey = encodeStateKey(scaleCoder, `Invalid address in ${chainId} ledger query ${stashAddress}`, stashAddress);
-        if (!stateKey) return [];
-        const decodeResult = change => {
-          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-          const decoded = decodeScale(scaleCoder, change, `Failed to decode ledger on chain ${chainId}`);
-          const activeStake = decoded?.active?.toString?.();
-          return {
+          } = poolPoints;
+          if (typeof points === "string") state.set(poolId, points);else state.delete(poolId);
+        }
+        return state;
+      }, new Map()));
+      const stakeByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolStake)(poolIds)), switchAll(), scan((state, next) => {
+        for (const poolStake of next) {
+          const {
             poolId,
             activeStake
-          };
-        };
-        return {
-          chainId,
-          stateKey,
-          decodeResult
-        };
-      });
-      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-      return () => subscription.then(unsubscribe => unsubscribe());
-    };
-    const subscribePoolMetadata = (poolIds, callback) => {
-      if (poolIds.length === 0) callback(null, []);
-      const scaleCoder = chainStorageCoders.get(chainId)?.metadata;
-      const queries = poolIds.flatMap(poolId => {
-        if (!nominationPoolsPalletId) return [];
-        const stateKey = encodeStateKey(scaleCoder, `Invalid poolId in ${chainId} metadata query ${poolId}`, poolId);
-        if (!stateKey) return [];
-        const decodeResult = change => {
-          /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
-
-          const decoded = decodeScale(scaleCoder, change, `Failed to decode metadata on chain ${chainId}`);
-          const metadata = decoded?.asText?.();
-          return {
+          } = poolStake;
+          if (typeof activeStake === "string") state.set(poolId, activeStake);else state.delete(poolId);
+        }
+        return state;
+      }, new Map()));
+      const metadataByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolMetadata)(poolIds)), switchAll(), scan((state, next) => {
+        for (const poolMetadata of next) {
+          const {
             poolId,
             metadata
-          };
-        };
-        return {
-          chainId,
-          stateKey,
-          decodeResult
-        };
-      });
-      const subscription = new RpcStateQueryHelper(chainConnector, queries).subscribe(callback);
-      return () => subscription.then(unsubscribe => unsubscribe());
-    };
-    const poolMembersByAddress$ = asObservable(subscribePoolMembers)(addresses).pipe(scan((state, next) => {
-      for (const poolMembers of next) {
-        const {
-          poolId,
-          points,
-          unbondingEras
-        } = poolMembers;
-        if (typeof poolId === "string" && typeof points === "string") state.set(poolMembers.address, {
-          poolId,
-          points,
-          unbondingEras
-        });else state.set(poolMembers.address, null);
-      }
-      return state;
-    }, new Map()), share());
-    const poolIdByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.poolId ?? null]))));
-    const pointsByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.points ?? null]))));
-    const unbondingErasByAddress$ = poolMembersByAddress$.pipe(map(pm => new Map(Array.from(pm).map(([address, pm]) => [address, pm?.unbondingEras ?? null]))));
-    const poolIds$ = poolIdByAddress$.pipe(map(byAddress => [...new Set(Array.from(byAddress.values()).flatMap(poolId => poolId ?? []))]));
-    const pointsByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolPoints)(poolIds)), switchAll(), scan((state, next) => {
-      for (const poolPoints of next) {
-        const {
-          poolId,
-          points
-        } = poolPoints;
-        if (typeof points === "string") state.set(poolId, points);else state.delete(poolId);
-      }
-      return state;
-    }, new Map()));
-    const stakeByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolStake)(poolIds)), switchAll(), scan((state, next) => {
-      for (const poolStake of next) {
-        const {
-          poolId,
-          activeStake
-        } = poolStake;
-        if (typeof activeStake === "string") state.set(poolId, activeStake);else state.delete(poolId);
-      }
-      return state;
-    }, new Map()));
-    const metadataByPool$ = poolIds$.pipe(map(poolIds => asObservable(subscribePoolMetadata)(poolIds)), switchAll(), scan((state, next) => {
-      for (const poolMetadata of next) {
-        const {
-          poolId,
-          metadata
-        } = poolMetadata;
-        if (typeof metadata === "string") state.set(poolId, metadata);else state.delete(poolId);
-      }
-      return state;
-    }, new Map()));
-    const subscription = combineLatest([poolIdByAddress$, pointsByAddress$, unbondingErasByAddress$, pointsByPool$, stakeByPool$, metadataByPool$]).subscribe({
-      next: ([poolIdByAddress, pointsByAddress, unbondingErasByAddress, pointsByPool, stakeByPool, metadataByPool]) => {
-        const balances = Array.from(poolIdByAddress).map(([address, poolId]) => {
-          const parsedPoolId = poolId === null ? undefined : parseInt(poolId);
-          const points = pointsByAddress.get(address) ?? "0";
-          const poolPoints = pointsByPool.get(poolId ?? "") ?? "0";
-          const poolStake = stakeByPool.get(poolId ?? "") ?? "0";
-          const poolMetadata = poolId ? metadataByPool.get(poolId) ?? `Pool ${poolId}` : undefined;
-          const amount = points === "0" || poolPoints === "0" || poolStake === "0" ? 0n : BigInt(poolStake) * BigInt(points) / BigInt(poolPoints);
-          const unbondingAmount = (unbondingErasByAddress.get(address) ?? []).reduce((total, {
-            amount
-          }) => total + BigInt(amount ?? "0"), 0n);
-          return {
-            source: "substrate-native",
-            status: "live",
-            address,
-            networkId: chainId,
-            tokenId,
-            values: [{
-              source: "nompools-staking",
-              type: "nompool",
-              label: "nompools-staking",
-              amount: amount.toString(),
-              meta: {
+          } = poolMetadata;
+          if (typeof metadata === "string") state.set(poolId, metadata);else state.delete(poolId);
+        }
+        return state;
+      }, new Map()));
+      const subscription = combineLatest([poolIdByAddress$, pointsByAddress$, unbondingErasByAddress$, pointsByPool$, stakeByPool$, metadataByPool$]).subscribe({
+        next: ([poolIdByAddress, pointsByAddress, unbondingErasByAddress, pointsByPool, stakeByPool, metadataByPool]) => {
+          const balances = Array.from(poolIdByAddress).map(([address, poolId]) => {
+            const parsedPoolId = poolId === null ? undefined : parseInt(poolId);
+            const points = pointsByAddress.get(address) ?? "0";
+            const poolPoints = pointsByPool.get(poolId ?? "") ?? "0";
+            const poolStake = stakeByPool.get(poolId ?? "") ?? "0";
+            const poolMetadata = poolId ? metadataByPool.get(poolId) ?? `Pool ${poolId}` : undefined;
+            const amount = points === "0" || poolPoints === "0" || poolStake === "0" ? 0n : BigInt(poolStake) * BigInt(points) / BigInt(poolPoints);
+            const unbondingAmount = (unbondingErasByAddress.get(address) ?? []).reduce((total, {
+              amount
+            }) => total + BigInt(amount ?? "0"), 0n);
+            return {
+              source: "substrate-native",
+              status: "live",
+              address,
+              networkId: chainId,
+              tokenId,
+              values: [{
+                source: "nompools-staking",
                 type: "nompool",
-                poolId: parsedPoolId,
-                description: poolMetadata
-              }
-            }, {
-              source: "nompools-staking",
-              type: "nompool",
-              label: "nompools-unbonding",
-              amount: unbondingAmount.toString(),
-              meta: {
-                poolId: parsedPoolId,
-                description: poolMetadata,
-                unbonding: true
-              }
-            }]
-          };
-        }).filter(isNotNil);
-        if (balances.length > 0) callback(null, balances);
-      },
-      error: error => callback(error)
+                label: "nompools-staking",
+                amount: amount.toString(),
+                meta: {
+                  type: "nompool",
+                  poolId: parsedPoolId,
+                  description: poolMetadata
+                }
+              }, {
+                source: "nompools-staking",
+                type: "nompool",
+                label: "nompools-unbonding",
+                amount: unbondingAmount.toString(),
+                meta: {
+                  poolId: parsedPoolId,
+                  description: poolMetadata,
+                  unbonding: true
+                }
+              }]
+            };
+          }).filter(isNotNil);
+          if (balances.length > 0) callback(null, balances);
+        },
+        error: error => callback(error)
+      });
+      resultUnsubscribes.push(() => subscription.unsubscribe());
+    }
+    return () => resultUnsubscribes.forEach(unsub => unsub());
+  } catch (err) {
+    if (!isAbortError(err)) log.error("Error subscribing to nom pool staking", {
+      err
     });
-    resultUnsubscribes.push(() => subscription.unsubscribe());
+    return () => {};
   }
-  return () => resultUnsubscribes.forEach(unsub => unsub());
 }
 
 const SUBTENSOR_ROOT_NETUID = 0;
@@ -4007,227 +4021,234 @@ const calculateTaoFromDynamicInfo = ({
 
 // TODO make this method chain-specific
 async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addressesByToken, callback, signal) {
-  const allChains = await chaindataProvider.getNetworksMapById("polkadot");
-  const tokens = await chaindataProvider.getTokensMapById();
-
-  // there should be only one network here when subscribing to balances, we've split it up by network at the top level
-  const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
-  const miniMetadatas = new Map();
-  for (const networkId of networkIds) {
-    const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native", signal);
-    miniMetadatas.set(networkId, miniMetadata);
-  }
-  signal?.throwIfAborted();
-  const subtensorTokenIds = Object.entries(tokens).filter(([, token]) => {
-    // ignore non-native tokens
-    if (token.type !== "substrate-native") return false;
-    // ignore tokens on chains with no subtensor pallet
-    const miniMetadata = miniMetadatas.get(token.networkId);
-    return miniMetadata?.extra?.hasSubtensorPallet === true;
-  }).map(([tokenId]) => tokenId);
-
-  // staking can only be done by the native token on chains with the subtensor pallet
-  const addressesBySubtensorToken = Object.fromEntries(Object.entries(addressesByToken)
-  // remove ethereum addresses
-  .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
-  // remove tokens which aren't subtensor staking tokens
-  .filter(([tokenId]) => subtensorTokenIds.includes(tokenId)));
-  const uniqueChainIds = getUniqueChainIds(addressesBySubtensorToken, tokens);
-  const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
-  const abortController = new AbortController();
-  for (const [tokenId, addresses] of Object.entries(addressesBySubtensorToken)) {
-    const token = tokens[tokenId];
-    if (!token) {
-      log.warn(`Token ${tokenId} not found`);
-      continue;
-    }
-    if (token.type !== "substrate-native") {
-      log.debug(`This module doesn't handle tokens of type ${token.type}`);
-      continue;
-    }
-    const chainId = token.networkId;
-    const chain = chains[chainId];
-    if (!chain) {
-      log.warn(`Chain ${chainId} for token ${tokenId} not found`);
-      continue;
-    }
-    const miniMetadata = miniMetadatas.get(token.networkId);
-    if (!miniMetadata?.data) {
-      log.warn(`MiniMetadata for chain ${chainId} not found`);
-      continue;
+  try {
+    const allChains = await chaindataProvider.getNetworksMapById("polkadot");
+    const tokens = await chaindataProvider.getTokensMapById();
+
+    // there should be only one network here when subscribing to balances, we've split it up by network at the top level
+    const networkIds = keys(addressesByToken).map(tokenId => parseTokenId(tokenId).networkId);
+    const miniMetadatas = new Map();
+    for (const networkId of networkIds) {
+      const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, "substrate-native", signal);
+      miniMetadatas.set(networkId, miniMetadata);
     }
-    const scaleApi = getScaleApi({
-      chainId,
-      send: (...args) => chainConnector.send(chainId, ...args, {
-        expectErrors: true
-      } // don't pollute the wallet logs when this request fails
-      )
-    }, miniMetadata.data, token, chain.hasCheckMetadataHash, chain.signedExtensions, chain.registryTypes);
-
-    // sets the number of addresses to query in parallel (per chain, since each chain runs in parallel to the others)
-    const concurrency = 4;
-    // In-memory cache for successful dynamic info results
-    const dynamicInfoCache = new Map();
-    const fetchDynamicInfoForNetuids = async uniqueNetuids => {
-      const MAX_RETRIES = 3;
-      const RETRY_DELAY_MS = 500;
-      const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-      const fetchInfo = async netuid => {
-        if (netuid === 0) return null;
-        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-          try {
-            const params = [netuid];
-            const result = await scaleApi.getRuntimeCallValue("SubnetInfoRuntimeApi", "get_dynamic_info", params);
-            dynamicInfoCache.set(netuid, result); // Cache successful response
-            return result;
-          } catch (error) {
-            log.trace(`Attempt ${attempt} failed for netuid ${netuid}:`, error);
-            if (attempt < MAX_RETRIES) {
-              const backoffTime = RETRY_DELAY_MS * 2 ** (attempt - 1);
-              log.trace(`Retrying in ${backoffTime}ms...`);
-              await delay(backoffTime);
+    signal?.throwIfAborted();
+    const subtensorTokenIds = Object.entries(tokens).filter(([, token]) => {
+      // ignore non-native tokens
+      if (token.type !== "substrate-native") return false;
+      // ignore tokens on chains with no subtensor pallet
+      const miniMetadata = miniMetadatas.get(token.networkId);
+      return miniMetadata?.extra?.hasSubtensorPallet === true;
+    }).map(([tokenId]) => tokenId);
+
+    // staking can only be done by the native token on chains with the subtensor pallet
+    const addressesBySubtensorToken = Object.fromEntries(Object.entries(addressesByToken)
+    // remove ethereum addresses
+    .map(([tokenId, addresses]) => [tokenId, addresses.filter(address => !isEthereumAddress(address))])
+    // remove tokens which aren't subtensor staking tokens
+    .filter(([tokenId]) => subtensorTokenIds.includes(tokenId)));
+    const uniqueChainIds = getUniqueChainIds(addressesBySubtensorToken, tokens);
+    const chains = Object.fromEntries(Object.entries(allChains).filter(([chainId]) => uniqueChainIds.includes(chainId)));
+    const abortController = new AbortController();
+    for (const [tokenId, addresses] of Object.entries(addressesBySubtensorToken)) {
+      const token = tokens[tokenId];
+      if (!token) {
+        log.warn(`Token ${tokenId} not found`);
+        continue;
+      }
+      if (token.type !== "substrate-native") {
+        log.debug(`This module doesn't handle tokens of type ${token.type}`);
+        continue;
+      }
+      const chainId = token.networkId;
+      const chain = chains[chainId];
+      if (!chain) {
+        log.warn(`Chain ${chainId} for token ${tokenId} not found`);
+        continue;
+      }
+      const miniMetadata = miniMetadatas.get(token.networkId);
+      if (!miniMetadata?.data) {
+        log.warn(`MiniMetadata for chain ${chainId} not found`);
+        continue;
+      }
+      const scaleApi = getScaleApi({
+        chainId,
+        send: (...args) => chainConnector.send(chainId, ...args, {
+          expectErrors: true
+        } // don't pollute the wallet logs when this request fails
+        )
+      }, miniMetadata.data, token, chain.hasCheckMetadataHash, chain.signedExtensions, chain.registryTypes);
+
+      // sets the number of addresses to query in parallel (per chain, since each chain runs in parallel to the others)
+      const concurrency = 4;
+      // In-memory cache for successful dynamic info results
+      const dynamicInfoCache = new Map();
+      const fetchDynamicInfoForNetuids = async uniqueNetuids => {
+        const MAX_RETRIES = 3;
+        const RETRY_DELAY_MS = 500;
+        const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+        const fetchInfo = async netuid => {
+          if (netuid === 0) return null;
+          for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+            try {
+              const params = [netuid];
+              const result = await scaleApi.getRuntimeCallValue("SubnetInfoRuntimeApi", "get_dynamic_info", params);
+              dynamicInfoCache.set(netuid, result); // Cache successful response
+              return result;
+            } catch (error) {
+              log.trace(`Attempt ${attempt} failed for netuid ${netuid}:`, error);
+              if (attempt < MAX_RETRIES) {
+                const backoffTime = RETRY_DELAY_MS * 2 ** (attempt - 1);
+                log.trace(`Retrying in ${backoffTime}ms...`);
+                await delay(backoffTime);
+              }
             }
           }
-        }
-        if (dynamicInfoCache.has(netuid)) {
-          return dynamicInfoCache.get(netuid); // Use cached value on failure
-        }
-        log.trace(`Failed to fetch dynamic info for netuid ${netuid} after ${MAX_RETRIES} attempts.`);
-        return null;
+          if (dynamicInfoCache.has(netuid)) {
+            return dynamicInfoCache.get(netuid); // Use cached value on failure
+          }
+          log.trace(`Failed to fetch dynamic info for netuid ${netuid} after ${MAX_RETRIES} attempts.`);
+          return null;
+        };
+        return Promise.all(uniqueNetuids.map(fetchInfo));
       };
-      return Promise.all(uniqueNetuids.map(fetchInfo));
-    };
-    const subtensorQueries = from(addresses).pipe(
-    // mergeMap lets us run N concurrent queries, where N is the value of `concurrency`
-    mergeMap(async address => {
-      const queryMethods = [async () => {
-        if (chain.isTestnet) return [];
-        const params = [address];
-        const result = await scaleApi.getRuntimeCallValue("StakeInfoRuntimeApi", "get_stake_info_for_coldkey", params);
-        if (!Array.isArray(result)) return [];
-        const uniqueNetuids = Array.from(new Set(result.map(item => Number(item.netuid)).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID)));
-        await fetchDynamicInfoForNetuids(uniqueNetuids);
-        const stakes = result?.map(({
-          coldkey,
-          hotkey,
-          netuid,
-          stake
-        }) => {
-          return {
-            address: coldkey,
+      const subtensorQueries = from(addresses).pipe(
+      // mergeMap lets us run N concurrent queries, where N is the value of `concurrency`
+      mergeMap(async address => {
+        const queryMethods = [async () => {
+          if (chain.isTestnet) return [];
+          const params = [address];
+          const result = await scaleApi.getRuntimeCallValue("StakeInfoRuntimeApi", "get_stake_info_for_coldkey", params);
+          if (!Array.isArray(result)) return [];
+          const uniqueNetuids = Array.from(new Set(result.map(item => Number(item.netuid)).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID)));
+          await fetchDynamicInfoForNetuids(uniqueNetuids);
+          const stakes = result?.map(({
+            coldkey,
             hotkey,
-            netuid: Number(netuid),
-            stake: BigInt(stake),
-            dynamicInfo: dynamicInfoCache.get(Number(netuid))
-          };
-        }).filter(({
-          stake
-        }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK);
-        return stakes;
-      }];
-      const errors = [];
-      for (const queryMethod of queryMethods) {
-        try {
-          // try each query method
-          return await queryMethod();
-        } catch (cause) {
-          // if it fails, keep track of the error and try the next one
-          errors.push(cause);
+            netuid,
+            stake
+          }) => {
+            return {
+              address: coldkey,
+              hotkey,
+              netuid: Number(netuid),
+              stake: BigInt(stake),
+              dynamicInfo: dynamicInfoCache.get(Number(netuid))
+            };
+          }).filter(({
+            stake
+          }) => stake >= SUBTENSOR_MIN_STAKE_AMOUNT_PLANK);
+          return stakes;
+        }];
+        const errors = [];
+        for (const queryMethod of queryMethods) {
+          try {
+            // try each query method
+            return await queryMethod();
+          } catch (cause) {
+            // if it fails, keep track of the error and try the next one
+            errors.push(cause);
+          }
         }
-      }
 
-      // if we get to here, that means that all query methods failed
-      // let's throw the errors back to the native balance module
-      throw new Error([`Failed to fetch ${tokenId} subtensor staked balance for ${address}:`, ...errors.map(error => String(error))].join("\n\t"));
-    }, concurrency),
-    // instead of emitting each balance as it's fetched, toArray waits for them all to fetch and then it collects them into an array
-    toArray(),
-    // this mergeMap flattens our Array<Array<Stakes>> into just an Array<Stakes>
-    mergeMap(stakes => stakes),
-    // convert our Array<Stakes> into Array<Balances>, which we can then return to the native balance module
-    map(stakes => stakes.map(({
-      address,
-      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 ?? []));
-
-      /** Map from Record<string, Binary> to Record<string, string> */
-      const binaryToText = input => Object.entries(input).reduce((acc, [key, value]) => {
-        acc[key] = value.asText();
-        return acc;
-      }, {});
-      const subnetIdentity = subnet_identity ? binaryToText(subnet_identity) : undefined;
-
-      // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
-      const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
-        dynamicInfo,
-        alphaStaked: stake
-      }) : 1n;
-      const alphaToTaoRate = calculateTaoFromDynamicInfo({
-        dynamicInfo: dynamicInfo ?? null,
-        alphaStaked: ONE_ALPHA_TOKEN
-      }).toString();
-      const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
-      return {
-        source: "substrate-native",
-        status: "live",
+        // if we get to here, that means that all query methods failed
+        // let's throw the errors back to the native balance module
+        throw new Error([`Failed to fetch ${tokenId} subtensor staked balance for ${address}:`, ...errors.map(error => String(error))].join("\n\t"));
+      }, concurrency),
+      // instead of emitting each balance as it's fetched, toArray waits for them all to fetch and then it collects them into an array
+      toArray(),
+      // this mergeMap flattens our Array<Array<Stakes>> into just an Array<Stakes>
+      mergeMap(stakes => stakes),
+      // convert our Array<Stakes> into Array<Balances>, which we can then return to the native balance module
+      map(stakes => stakes.map(({
         address,
-        networkId: chainId,
-        tokenId,
-        values: [{
-          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
+        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 ?? []));
+
+        /** Map from Record<string, Binary> to Record<string, string> */
+        const binaryToText = input => Object.entries(input).reduce((acc, [key, value]) => {
+          acc[key] = value.asText();
+          return acc;
+        }, {});
+        const subnetIdentity = subnet_identity ? binaryToText(subnet_identity) : undefined;
+
+        // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
+        const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
+          dynamicInfo,
+          alphaStaked: stake
+        }) : 1n;
+        const alphaToTaoRate = calculateTaoFromDynamicInfo({
+          dynamicInfo: dynamicInfo ?? null,
+          alphaStaked: ONE_ALPHA_TOKEN
+        }).toString();
+        const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
+        return {
+          source: "substrate-native",
+          status: "live",
+          address,
+          networkId: chainId,
+          tokenId,
+          values: [{
+            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
+                }
               }
             }
-          }
-        }]
-      };
-    })));
-
-    // This observable will run the subtensorQueries on a 30s (30_000ms) interval.
-    // However, if the last run has not yet completed (e.g. its been 30s but we're still fetching some balances),
-    // then exhaustMap will wait until the next interval (so T: 60s, T: 90s, T: 120s, etc) before re-executing the subtensorQueries.
-    const subtensorQueriesInterval = interval(30_000).pipe(startWith(0),
-    // start immediately
-    exhaustMap(() => {
-      return subtensorQueries;
-    }));
+          }]
+        };
+      })));
+
+      // This observable will run the subtensorQueries on a 30s (30_000ms) interval.
+      // However, if the last run has not yet completed (e.g. its been 30s but we're still fetching some balances),
+      // then exhaustMap will wait until the next interval (so T: 60s, T: 90s, T: 120s, etc) before re-executing the subtensorQueries.
+      const subtensorQueriesInterval = interval(30_000).pipe(startWith(0),
+      // start immediately
+      exhaustMap(() => {
+        return subtensorQueries;
+      }));
 
-    // subscribe to the balances
-    const subscription = subtensorQueriesInterval.subscribe({
-      next: balances => callback(null, balances),
-      error: error => callback(error)
-    });
+      // subscribe to the balances
+      const subscription = subtensorQueriesInterval.subscribe({
+        next: balances => callback(null, balances),
+        error: error => callback(error)
+      });
 
-    // use the abortController to tear the subscription down when we don't need it anymore
-    abortController.signal.addEventListener("abort", () => {
-      subscription.unsubscribe();
+      // use the abortController to tear the subscription down when we don't need it anymore
+      abortController.signal.addEventListener("abort", () => {
+        subscription.unsubscribe();
+      });
+    }
+    return () => abortController.abort();
+  } catch (err) {
+    if (!isAbortError(err)) log.error("Error subscribing to subtensor staking", {
+      err
     });
+    return () => {};
   }
-  return () => abortController.abort();
 }
 
 const getOtherType = input => `other-${input}`;
@@ -4906,17 +4927,9 @@ const SubNativeModule = hydrate => {
           if (!chainConnectors.substrate) return;
           const unsubSubtensorStaking = subscribeSubtensorStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("subtensor-staking"), signal);
           const unsubNompoolStaking = subscribeNompoolStaking(chaindataProvider, chainConnectors.substrate, newAddressesByToken, handleUpdateForSource("nompools-staking"), signal);
-          // const unsubCrowdloans = subscribeCrowdloans(
-          //   chaindataProvider,
-          //   chainConnectors.substrate,
-          //   newAddressesByToken,
-          //   handleUpdateForSource("crowdloan"),
-          //   signal,
-          // )
           const unsubBase = subscribeBase(baseQueries, chainConnectors.substrate, handleUpdateForSource("base"));
           subscriber.add(async () => (await unsubSubtensorStaking)());
           subscriber.add(async () => (await unsubNompoolStaking)());
-          // subscriber.add(async () => (await unsubCrowdloans)())
           subscriber.add(async () => (await unsubBase)());
         });
       }));