@talismn/balances 0.0.0-pr2277-20251211070508 → 0.0.0-pr2279-20251222112424

package/dist/declarations/src/modules/substrate-dtao/calculatePendingRootClaimable.d.ts

@@ -0,0 +1,11 @@
+import { GetDynamicInfosResult, SubDTaoBalance } from "./types";
+type DynamicInfo = NonNullable<GetDynamicInfosResult[number]>;
+export declare const calculatePendingRootClaimable: ({ stake, hotkey, address, networkId, validatorRootClaimableRate, dynamicInfoByNetuid, }: {
+    stake: bigint;
+    hotkey: string;
+    address: string;
+    networkId: string;
+    validatorRootClaimableRate: Map<number, bigint>;
+    dynamicInfoByNetuid: Record<number, DynamicInfo | undefined>;
+}) => SubDTaoBalance[];
+export {};

package/dist/declarations/src/modules/substrate-dtao/types.d.ts

@@ -1,3 +1,4 @@
+import type { bittensor } from "@polkadot-api/descriptors";
 import z from "zod/v4";
 export declare const SubDTaoTokenConfigSchema: z.ZodObject<{
     symbol: z.ZodOptional<z.ZodString>;
@@ -15,3 +16,15 @@ export type SubDTaoTokenConfig = z.infer<typeof SubDTaoTokenConfigSchema>;
 export type SubDTaoBalanceMeta = {
     scaledAlphaPrice: string;
 };
+export type SubDTaoBalance = {
+    address: string;
+    tokenId: string;
+    baseTokenId: string;
+    stake: bigint;
+    pendingRootClaim?: bigint;
+    hotkey: string;
+    netuid: number;
+    scaledAlphaPrice: bigint;
+};
+export type GetDynamicInfosResult = (typeof bittensor)["descriptors"]["apis"]["SubnetInfoRuntimeApi"]["get_all_dynamic_info"][1];
+export type GetStakeInfosResult = (typeof bittensor)["descriptors"]["apis"]["StakeInfoRuntimeApi"]["get_stake_info_for_coldkeys"][1];

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

@@ -2295,6 +2295,42 @@ const taoToAlpha = (tao, scaledAlphaPrice) => {
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
 
+const calculatePendingRootClaimable = ({
+  stake,
+  hotkey,
+  address,
+  networkId,
+  validatorRootClaimableRate,
+  dynamicInfoByNetuid
+}) => {
+  const pendingRootClaimBalances = [];
+  for (const [netuid, claimableRate] of validatorRootClaimableRate) {
+    if (claimableRate === 0n) {
+      continue;
+    }
+    const dynamicInfo = dynamicInfoByNetuid[netuid];
+    const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+    // Calculate claimable = claimable_rate * root_stake
+    // Note: claimableRate is a I96F32, a fixed-point number format
+
+    // Multiply claimable_rate by root_stake
+    // I96F32 multiplication: round((a * b) / 2^32)
+    const pendingRootClaim = stake * claimableRate + (1n << 31n) >> 32n;
+    pendingRootClaimBalances.push({
+      address,
+      tokenId: chaindataProvider.subDTaoTokenId(networkId, netuid, hotkey),
+      baseTokenId: chaindataProvider.subDTaoTokenId(networkId, netuid),
+      hotkey: hotkey,
+      netuid: netuid,
+      scaledAlphaPrice,
+      pendingRootClaim,
+      stake: 0n
+    });
+  }
+  return pendingRootClaimBalances;
+};
+
+const ROOT_NETUID = 0;
 const fetchBalances$5 = async ({
   networkId,
   tokensWithAddresses,
@@ -2344,20 +2380,63 @@ const fetchBalances$5 = async ({
   const addresses = lodashEs.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 rootHotkeys = lodashEs.uniq(stakeInfos.flatMap(([, stakes]) => stakes.filter(stake => stake.netuid === ROOT_NETUID).map(stake => stake.hotkey)));
+    const rootClaimableRatesByHotkey = rootHotkeys.length && miniMetadata.data ? await fetchRootClaimableRates(connector, networkId, miniMetadata.data, rootHotkeys) : new Map();
     const dynamicInfoByNetuid = lodashEs.keyBy(dynamicInfos.filter(util.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: chaindataProvider.subDTaoTokenId(networkId, stake.netuid, stake.hotkey),
-        baseTokenId: chaindataProvider.subDTaoTokenId(networkId, stake.netuid),
-        stake: stake.stake,
-        hotkey: stake.hotkey,
-        netuid: stake.netuid,
-        scaledAlphaPrice
-      };
-    }));
+
+    // Upserts a balance into the accumulator, merging stake values if the balance already exists.
+    // Eg: Acc X has root staked with validator Y, but also staked on sn 45 with the same validator Y.
+    // We merge the pending root claim of sn 45 and the sn 45 stake in the same balance.
+    const upsertBalance = (acc, address, tokenId, balance) => {
+      const key = `${address}:${tokenId}`;
+      const recordedBalance = acc[key];
+      if (recordedBalance) {
+        acc[key] = {
+          ...recordedBalance,
+          stake: recordedBalance.stake + balance.stake,
+          // If the new balance has pendingRootClaim, use it (it's calculated from current state)
+          ...(balance.pendingRootClaim !== undefined && {
+            pendingRootClaim: balance.pendingRootClaim
+          })
+        };
+      } else {
+        acc[key] = balance;
+      }
+    };
+    const balancesRaw = stakeInfos.reduce((acc, [address, stakes]) => {
+      for (const stake of stakes) {
+        // Regular stake cases
+        const dynamicInfo = dynamicInfoByNetuid[stake.netuid];
+        const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+        const balance = {
+          address,
+          tokenId: chaindataProvider.subDTaoTokenId(networkId, stake.netuid, stake.hotkey),
+          baseTokenId: chaindataProvider.subDTaoTokenId(networkId, stake.netuid),
+          stake: stake.stake,
+          hotkey: stake.hotkey,
+          netuid: stake.netuid,
+          scaledAlphaPrice
+        };
+        upsertBalance(acc, address, balance.tokenId, balance);
+
+        // Root stake cases, we need to calculate the pending root claim and add to the balances
+        if (stake.netuid === ROOT_NETUID) {
+          const pendingRootClaimBalances = calculatePendingRootClaimable({
+            stake: stake.stake,
+            hotkey: stake.hotkey,
+            address,
+            networkId,
+            validatorRootClaimableRate: rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map(),
+            dynamicInfoByNetuid
+          });
+          pendingRootClaimBalances.forEach(balance => {
+            upsertBalance(acc, address, balance.tokenId, balance);
+          });
+        }
+      }
+      return acc;
+    }, {});
+    const balances = Object.values(balancesRaw);
     const tokensById = lodashEs.keyBy(tokensWithAddresses.map(([token]) => token), t => t.id);
     const dynamicTokens = [];
 
@@ -2383,19 +2462,45 @@ const fetchBalances$5 = async ({
       const meta = {
         scaledAlphaPrice: stake?.scaledAlphaPrice.toString() ?? "0"
       };
+      const stakeAmount = BigInt(stake?.stake?.toString() ?? "0");
+      const pendingRootClaimAmount = BigInt(stake?.pendingRootClaim?.toString() ?? "0");
+      const hasZeroStake = stakeAmount === 0n;
+      const hasPendingRootClaim = pendingRootClaimAmount > 0n;
       const balanceValue = {
         type: "free",
         label: stake?.netuid === 0 ? "Root Staking" : `Subnet Staking`,
-        amount: stake?.stake.toString() ?? "0",
+        amount: stakeAmount.toString(),
         meta
       };
+      const pendingRootClaimValue = {
+        type: "locked",
+        label: "Pending root claim",
+        amount: pendingRootClaimAmount.toString(),
+        meta
+      };
+      const values = [balanceValue, pendingRootClaimValue];
+
+      // If stake is 0n but there's a pendingRootClaim, add it as an extra amount
+      // with includeInTotal: true so it counts toward the total balance.
+      // This ensures the balance isn't filtered out when stake is 0n.
+      // The total.planck calculation is: free + reserved + extra (with includeInTotal: true)
+      // So by adding pendingRootClaim as extra, it will be included in total.planck.
+      if (hasZeroStake && hasPendingRootClaim) {
+        values.push({
+          type: "extra",
+          label: "Pending root claim",
+          amount: pendingRootClaimAmount.toString(),
+          includeInTotal: true,
+          meta
+        });
+      }
       return {
         address: def.address,
         networkId,
         tokenId: def.token.id,
         source: MODULE_TYPE$5,
         status: "live",
-        values: [balanceValue]
+        values
       };
     });
     return {
@@ -2418,6 +2523,68 @@ const fetchBalances$5 = async ({
     };
   }
 };
+const buildStorageCoder = (metadataRpc, pallet, entry) => {
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  return builder.buildStorage(pallet, entry);
+};
+const buildRootClaimableStorageCoder = async (connector, networkId, metadataRpc) => {
+  let storageCoder = null;
+  if (metadataRpc) {
+    try {
+      storageCoder = buildStorageCoder(metadataRpc, "SubtensorModule", "RootClaimable");
+    } catch (cause) {
+      log.warn(`Failed to build storage coder for SubtensorModule.RootClaimable using provided metadata on ${networkId}`, {
+        cause
+      });
+    }
+  }
+  return storageCoder;
+};
+const buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
+  return hotkeys.map(hotkey => {
+    let stateKey = null;
+    try {
+      stateKey = storageCoder.keys.enc(hotkey);
+    } catch (cause) {
+      log.warn(`Failed to encode storage key for hotkey ${hotkey} on ${networkId}`, {
+        cause
+      });
+    }
+    const decodeResult = changes => {
+      const hexValue = changes[0];
+      if (!hexValue) {
+        return [hotkey, new Map()];
+      }
+      const decoded = scale.decodeScale(storageCoder, hexValue, `Failed to decode RootClaimable for hotkey ${hotkey} on ${networkId}`);
+      return [hotkey, decoded ? new Map(decoded) : new Map()];
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  });
+};
+const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkeys) => {
+  if (!hotkeys.length) return new Map();
+  const storageCoder = await buildRootClaimableStorageCoder(connector, networkId, metadataRpc);
+  if (!storageCoder) {
+    // Fallback: return empty map for all hotkeys
+    return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
+  }
+  const queries = buildRootClaimableQueries(networkId, hotkeys, storageCoder);
+  try {
+    const results = await fetchRpcQueryPack(connector, networkId, queries);
+    return new Map(results);
+  } catch (cause) {
+    log.warn(`Failed to fetch RootClaimable for hotkeys on ${networkId}`, {
+      cause
+    });
+    // Fallback: return empty map for all hotkeys
+    return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
+  }
+};
 
 // hardcoded because we dont have access to native tokens from the balance module
 const NATIVE_TOKEN_SYMBOLS = {
@@ -2517,7 +2684,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   scale.compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle"]
+    items: ["TransferToggle", "RootClaimable"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

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

@@ -2295,6 +2295,42 @@ const taoToAlpha = (tao, scaledAlphaPrice) => {
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
 
+const calculatePendingRootClaimable = ({
+  stake,
+  hotkey,
+  address,
+  networkId,
+  validatorRootClaimableRate,
+  dynamicInfoByNetuid
+}) => {
+  const pendingRootClaimBalances = [];
+  for (const [netuid, claimableRate] of validatorRootClaimableRate) {
+    if (claimableRate === 0n) {
+      continue;
+    }
+    const dynamicInfo = dynamicInfoByNetuid[netuid];
+    const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+    // Calculate claimable = claimable_rate * root_stake
+    // Note: claimableRate is a I96F32, a fixed-point number format
+
+    // Multiply claimable_rate by root_stake
+    // I96F32 multiplication: round((a * b) / 2^32)
+    const pendingRootClaim = stake * claimableRate + (1n << 31n) >> 32n;
+    pendingRootClaimBalances.push({
+      address,
+      tokenId: chaindataProvider.subDTaoTokenId(networkId, netuid, hotkey),
+      baseTokenId: chaindataProvider.subDTaoTokenId(networkId, netuid),
+      hotkey: hotkey,
+      netuid: netuid,
+      scaledAlphaPrice,
+      pendingRootClaim,
+      stake: 0n
+    });
+  }
+  return pendingRootClaimBalances;
+};
+
+const ROOT_NETUID = 0;
 const fetchBalances$5 = async ({
   networkId,
   tokensWithAddresses,
@@ -2344,20 +2380,63 @@ const fetchBalances$5 = async ({
   const addresses = lodashEs.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 rootHotkeys = lodashEs.uniq(stakeInfos.flatMap(([, stakes]) => stakes.filter(stake => stake.netuid === ROOT_NETUID).map(stake => stake.hotkey)));
+    const rootClaimableRatesByHotkey = rootHotkeys.length && miniMetadata.data ? await fetchRootClaimableRates(connector, networkId, miniMetadata.data, rootHotkeys) : new Map();
     const dynamicInfoByNetuid = lodashEs.keyBy(dynamicInfos.filter(util.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: chaindataProvider.subDTaoTokenId(networkId, stake.netuid, stake.hotkey),
-        baseTokenId: chaindataProvider.subDTaoTokenId(networkId, stake.netuid),
-        stake: stake.stake,
-        hotkey: stake.hotkey,
-        netuid: stake.netuid,
-        scaledAlphaPrice
-      };
-    }));
+
+    // Upserts a balance into the accumulator, merging stake values if the balance already exists.
+    // Eg: Acc X has root staked with validator Y, but also staked on sn 45 with the same validator Y.
+    // We merge the pending root claim of sn 45 and the sn 45 stake in the same balance.
+    const upsertBalance = (acc, address, tokenId, balance) => {
+      const key = `${address}:${tokenId}`;
+      const recordedBalance = acc[key];
+      if (recordedBalance) {
+        acc[key] = {
+          ...recordedBalance,
+          stake: recordedBalance.stake + balance.stake,
+          // If the new balance has pendingRootClaim, use it (it's calculated from current state)
+          ...(balance.pendingRootClaim !== undefined && {
+            pendingRootClaim: balance.pendingRootClaim
+          })
+        };
+      } else {
+        acc[key] = balance;
+      }
+    };
+    const balancesRaw = stakeInfos.reduce((acc, [address, stakes]) => {
+      for (const stake of stakes) {
+        // Regular stake cases
+        const dynamicInfo = dynamicInfoByNetuid[stake.netuid];
+        const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+        const balance = {
+          address,
+          tokenId: chaindataProvider.subDTaoTokenId(networkId, stake.netuid, stake.hotkey),
+          baseTokenId: chaindataProvider.subDTaoTokenId(networkId, stake.netuid),
+          stake: stake.stake,
+          hotkey: stake.hotkey,
+          netuid: stake.netuid,
+          scaledAlphaPrice
+        };
+        upsertBalance(acc, address, balance.tokenId, balance);
+
+        // Root stake cases, we need to calculate the pending root claim and add to the balances
+        if (stake.netuid === ROOT_NETUID) {
+          const pendingRootClaimBalances = calculatePendingRootClaimable({
+            stake: stake.stake,
+            hotkey: stake.hotkey,
+            address,
+            networkId,
+            validatorRootClaimableRate: rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map(),
+            dynamicInfoByNetuid
+          });
+          pendingRootClaimBalances.forEach(balance => {
+            upsertBalance(acc, address, balance.tokenId, balance);
+          });
+        }
+      }
+      return acc;
+    }, {});
+    const balances = Object.values(balancesRaw);
     const tokensById = lodashEs.keyBy(tokensWithAddresses.map(([token]) => token), t => t.id);
     const dynamicTokens = [];
 
@@ -2383,19 +2462,45 @@ const fetchBalances$5 = async ({
       const meta = {
         scaledAlphaPrice: stake?.scaledAlphaPrice.toString() ?? "0"
       };
+      const stakeAmount = BigInt(stake?.stake?.toString() ?? "0");
+      const pendingRootClaimAmount = BigInt(stake?.pendingRootClaim?.toString() ?? "0");
+      const hasZeroStake = stakeAmount === 0n;
+      const hasPendingRootClaim = pendingRootClaimAmount > 0n;
       const balanceValue = {
         type: "free",
         label: stake?.netuid === 0 ? "Root Staking" : `Subnet Staking`,
-        amount: stake?.stake.toString() ?? "0",
+        amount: stakeAmount.toString(),
         meta
       };
+      const pendingRootClaimValue = {
+        type: "locked",
+        label: "Pending root claim",
+        amount: pendingRootClaimAmount.toString(),
+        meta
+      };
+      const values = [balanceValue, pendingRootClaimValue];
+
+      // If stake is 0n but there's a pendingRootClaim, add it as an extra amount
+      // with includeInTotal: true so it counts toward the total balance.
+      // This ensures the balance isn't filtered out when stake is 0n.
+      // The total.planck calculation is: free + reserved + extra (with includeInTotal: true)
+      // So by adding pendingRootClaim as extra, it will be included in total.planck.
+      if (hasZeroStake && hasPendingRootClaim) {
+        values.push({
+          type: "extra",
+          label: "Pending root claim",
+          amount: pendingRootClaimAmount.toString(),
+          includeInTotal: true,
+          meta
+        });
+      }
       return {
         address: def.address,
         networkId,
         tokenId: def.token.id,
         source: MODULE_TYPE$5,
         status: "live",
-        values: [balanceValue]
+        values
       };
     });
     return {
@@ -2418,6 +2523,68 @@ const fetchBalances$5 = async ({
     };
   }
 };
+const buildStorageCoder = (metadataRpc, pallet, entry) => {
+  const {
+    builder
+  } = scale.parseMetadataRpc(metadataRpc);
+  return builder.buildStorage(pallet, entry);
+};
+const buildRootClaimableStorageCoder = async (connector, networkId, metadataRpc) => {
+  let storageCoder = null;
+  if (metadataRpc) {
+    try {
+      storageCoder = buildStorageCoder(metadataRpc, "SubtensorModule", "RootClaimable");
+    } catch (cause) {
+      log.warn(`Failed to build storage coder for SubtensorModule.RootClaimable using provided metadata on ${networkId}`, {
+        cause
+      });
+    }
+  }
+  return storageCoder;
+};
+const buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
+  return hotkeys.map(hotkey => {
+    let stateKey = null;
+    try {
+      stateKey = storageCoder.keys.enc(hotkey);
+    } catch (cause) {
+      log.warn(`Failed to encode storage key for hotkey ${hotkey} on ${networkId}`, {
+        cause
+      });
+    }
+    const decodeResult = changes => {
+      const hexValue = changes[0];
+      if (!hexValue) {
+        return [hotkey, new Map()];
+      }
+      const decoded = scale.decodeScale(storageCoder, hexValue, `Failed to decode RootClaimable for hotkey ${hotkey} on ${networkId}`);
+      return [hotkey, decoded ? new Map(decoded) : new Map()];
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  });
+};
+const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkeys) => {
+  if (!hotkeys.length) return new Map();
+  const storageCoder = await buildRootClaimableStorageCoder(connector, networkId, metadataRpc);
+  if (!storageCoder) {
+    // Fallback: return empty map for all hotkeys
+    return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
+  }
+  const queries = buildRootClaimableQueries(networkId, hotkeys, storageCoder);
+  try {
+    const results = await fetchRpcQueryPack(connector, networkId, queries);
+    return new Map(results);
+  } catch (cause) {
+    log.warn(`Failed to fetch RootClaimable for hotkeys on ${networkId}`, {
+      cause
+    });
+    // Fallback: return empty map for all hotkeys
+    return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
+  }
+};
 
 // hardcoded because we dont have access to native tokens from the balance module
 const NATIVE_TOKEN_SYMBOLS = {
@@ -2517,7 +2684,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   scale.compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle"]
+    items: ["TransferToggle", "RootClaimable"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

package/dist/talismn-balances.esm.js

@@ -2286,6 +2286,42 @@ const taoToAlpha = (tao, scaledAlphaPrice) => {
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
 
+const calculatePendingRootClaimable = ({
+  stake,
+  hotkey,
+  address,
+  networkId,
+  validatorRootClaimableRate,
+  dynamicInfoByNetuid
+}) => {
+  const pendingRootClaimBalances = [];
+  for (const [netuid, claimableRate] of validatorRootClaimableRate) {
+    if (claimableRate === 0n) {
+      continue;
+    }
+    const dynamicInfo = dynamicInfoByNetuid[netuid];
+    const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+    // Calculate claimable = claimable_rate * root_stake
+    // Note: claimableRate is a I96F32, a fixed-point number format
+
+    // Multiply claimable_rate by root_stake
+    // I96F32 multiplication: round((a * b) / 2^32)
+    const pendingRootClaim = stake * claimableRate + (1n << 31n) >> 32n;
+    pendingRootClaimBalances.push({
+      address,
+      tokenId: subDTaoTokenId(networkId, netuid, hotkey),
+      baseTokenId: subDTaoTokenId(networkId, netuid),
+      hotkey: hotkey,
+      netuid: netuid,
+      scaledAlphaPrice,
+      pendingRootClaim,
+      stake: 0n
+    });
+  }
+  return pendingRootClaimBalances;
+};
+
+const ROOT_NETUID = 0;
 const fetchBalances$5 = async ({
   networkId,
   tokensWithAddresses,
@@ -2335,20 +2371,63 @@ const fetchBalances$5 = async ({
   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 rootHotkeys = uniq(stakeInfos.flatMap(([, stakes]) => stakes.filter(stake => stake.netuid === ROOT_NETUID).map(stake => stake.hotkey)));
+    const rootClaimableRatesByHotkey = rootHotkeys.length && miniMetadata.data ? await fetchRootClaimableRates(connector, networkId, miniMetadata.data, rootHotkeys) : new Map();
     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
-      };
-    }));
+
+    // Upserts a balance into the accumulator, merging stake values if the balance already exists.
+    // Eg: Acc X has root staked with validator Y, but also staked on sn 45 with the same validator Y.
+    // We merge the pending root claim of sn 45 and the sn 45 stake in the same balance.
+    const upsertBalance = (acc, address, tokenId, balance) => {
+      const key = `${address}:${tokenId}`;
+      const recordedBalance = acc[key];
+      if (recordedBalance) {
+        acc[key] = {
+          ...recordedBalance,
+          stake: recordedBalance.stake + balance.stake,
+          // If the new balance has pendingRootClaim, use it (it's calculated from current state)
+          ...(balance.pendingRootClaim !== undefined && {
+            pendingRootClaim: balance.pendingRootClaim
+          })
+        };
+      } else {
+        acc[key] = balance;
+      }
+    };
+    const balancesRaw = stakeInfos.reduce((acc, [address, stakes]) => {
+      for (const stake of stakes) {
+        // Regular stake cases
+        const dynamicInfo = dynamicInfoByNetuid[stake.netuid];
+        const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+        const balance = {
+          address,
+          tokenId: subDTaoTokenId(networkId, stake.netuid, stake.hotkey),
+          baseTokenId: subDTaoTokenId(networkId, stake.netuid),
+          stake: stake.stake,
+          hotkey: stake.hotkey,
+          netuid: stake.netuid,
+          scaledAlphaPrice
+        };
+        upsertBalance(acc, address, balance.tokenId, balance);
+
+        // Root stake cases, we need to calculate the pending root claim and add to the balances
+        if (stake.netuid === ROOT_NETUID) {
+          const pendingRootClaimBalances = calculatePendingRootClaimable({
+            stake: stake.stake,
+            hotkey: stake.hotkey,
+            address,
+            networkId,
+            validatorRootClaimableRate: rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map(),
+            dynamicInfoByNetuid
+          });
+          pendingRootClaimBalances.forEach(balance => {
+            upsertBalance(acc, address, balance.tokenId, balance);
+          });
+        }
+      }
+      return acc;
+    }, {});
+    const balances = Object.values(balancesRaw);
     const tokensById = keyBy(tokensWithAddresses.map(([token]) => token), t => t.id);
     const dynamicTokens = [];
 
@@ -2374,19 +2453,45 @@ const fetchBalances$5 = async ({
       const meta = {
         scaledAlphaPrice: stake?.scaledAlphaPrice.toString() ?? "0"
       };
+      const stakeAmount = BigInt(stake?.stake?.toString() ?? "0");
+      const pendingRootClaimAmount = BigInt(stake?.pendingRootClaim?.toString() ?? "0");
+      const hasZeroStake = stakeAmount === 0n;
+      const hasPendingRootClaim = pendingRootClaimAmount > 0n;
       const balanceValue = {
         type: "free",
         label: stake?.netuid === 0 ? "Root Staking" : `Subnet Staking`,
-        amount: stake?.stake.toString() ?? "0",
+        amount: stakeAmount.toString(),
         meta
       };
+      const pendingRootClaimValue = {
+        type: "locked",
+        label: "Pending root claim",
+        amount: pendingRootClaimAmount.toString(),
+        meta
+      };
+      const values = [balanceValue, pendingRootClaimValue];
+
+      // If stake is 0n but there's a pendingRootClaim, add it as an extra amount
+      // with includeInTotal: true so it counts toward the total balance.
+      // This ensures the balance isn't filtered out when stake is 0n.
+      // The total.planck calculation is: free + reserved + extra (with includeInTotal: true)
+      // So by adding pendingRootClaim as extra, it will be included in total.planck.
+      if (hasZeroStake && hasPendingRootClaim) {
+        values.push({
+          type: "extra",
+          label: "Pending root claim",
+          amount: pendingRootClaimAmount.toString(),
+          includeInTotal: true,
+          meta
+        });
+      }
       return {
         address: def.address,
         networkId,
         tokenId: def.token.id,
         source: MODULE_TYPE$5,
         status: "live",
-        values: [balanceValue]
+        values
       };
     });
     return {
@@ -2409,6 +2514,68 @@ const fetchBalances$5 = async ({
     };
   }
 };
+const buildStorageCoder = (metadataRpc, pallet, entry) => {
+  const {
+    builder
+  } = parseMetadataRpc(metadataRpc);
+  return builder.buildStorage(pallet, entry);
+};
+const buildRootClaimableStorageCoder = async (connector, networkId, metadataRpc) => {
+  let storageCoder = null;
+  if (metadataRpc) {
+    try {
+      storageCoder = buildStorageCoder(metadataRpc, "SubtensorModule", "RootClaimable");
+    } catch (cause) {
+      log.warn(`Failed to build storage coder for SubtensorModule.RootClaimable using provided metadata on ${networkId}`, {
+        cause
+      });
+    }
+  }
+  return storageCoder;
+};
+const buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
+  return hotkeys.map(hotkey => {
+    let stateKey = null;
+    try {
+      stateKey = storageCoder.keys.enc(hotkey);
+    } catch (cause) {
+      log.warn(`Failed to encode storage key for hotkey ${hotkey} on ${networkId}`, {
+        cause
+      });
+    }
+    const decodeResult = changes => {
+      const hexValue = changes[0];
+      if (!hexValue) {
+        return [hotkey, new Map()];
+      }
+      const decoded = decodeScale(storageCoder, hexValue, `Failed to decode RootClaimable for hotkey ${hotkey} on ${networkId}`);
+      return [hotkey, decoded ? new Map(decoded) : new Map()];
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  });
+};
+const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkeys) => {
+  if (!hotkeys.length) return new Map();
+  const storageCoder = await buildRootClaimableStorageCoder(connector, networkId, metadataRpc);
+  if (!storageCoder) {
+    // Fallback: return empty map for all hotkeys
+    return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
+  }
+  const queries = buildRootClaimableQueries(networkId, hotkeys, storageCoder);
+  try {
+    const results = await fetchRpcQueryPack(connector, networkId, queries);
+    return new Map(results);
+  } catch (cause) {
+    log.warn(`Failed to fetch RootClaimable for hotkeys on ${networkId}`, {
+      cause
+    });
+    // Fallback: return empty map for all hotkeys
+    return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
+  }
+};
 
 // hardcoded because we dont have access to native tokens from the balance module
 const NATIVE_TOKEN_SYMBOLS = {
@@ -2508,7 +2675,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle"]
+    items: ["TransferToggle", "RootClaimable"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances",
-  "version": "0.0.0-pr2277-20251211070508",
+  "version": "0.0.0-pr2279-20251222112424",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -38,14 +38,14 @@
     "scale-ts": "^1.6.1",
     "viem": "^2.27.3",
     "zod": "^3.25.76",
-    "@talismn/chaindata-provider": "1.3.1",
-    "@talismn/chain-connectors": "0.0.10",
-    "@talismn/sapi": "0.0.0-pr2277-20251211070508",
-    "@talismn/crypto": "0.0.0-pr2277-20251211070508",
-    "@talismn/token-rates": "3.0.12",
-    "@talismn/scale": "0.0.0-pr2277-20251211070508",
-    "@talismn/util": "0.5.6",
-    "@talismn/solana": "0.0.0-pr2277-20251211070508"
+    "@talismn/chain-connectors": "0.0.0-pr2279-20251222112424",
+    "@talismn/chaindata-provider": "0.0.0-pr2279-20251222112424",
+    "@talismn/sapi": "0.1.0",
+    "@talismn/crypto": "0.3.0",
+    "@talismn/scale": "0.3.0",
+    "@talismn/solana": "0.0.5",
+    "@talismn/token-rates": "0.0.0-pr2279-20251222112424",
+    "@talismn/util": "0.5.6"
   },
   "devDependencies": {
     "@polkadot/api-contract": "16.1.2",
@@ -60,8 +60,8 @@
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/tsconfig": "0.0.3",
-    "@talismn/eslint-config": "0.0.3"
+    "@talismn/eslint-config": "0.0.3",
+    "@talismn/tsconfig": "0.0.3"
   },
   "peerDependencies": {
     "@polkadot/api-contract": "*",