@talismn/balances 1.3.0 → 1.3.1

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

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

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

@@ -2301,7 +2301,8 @@ const calculatePendingRootClaimable = ({
   address,
   networkId,
   validatorRootClaimableRate,
-  dynamicInfoByNetuid
+  dynamicInfoByNetuid,
+  alreadyClaimedByNetuid
 }) => {
   const pendingRootClaimBalances = [];
   for (const [netuid, claimableRate] of validatorRootClaimableRate) {
@@ -2315,7 +2316,11 @@ const calculatePendingRootClaimable = ({
 
     // Multiply claimable_rate by root_stake
     // I96F32 multiplication: round((a * b) / 2^32)
-    const pendingRootClaim = stake * claimableRate + (1n << 31n) >> 32n;
+    const totalClaimable = stake * claimableRate + (1n << 31n) >> 32n;
+
+    // Subtract already claimed amount to get net pending claimable
+    const alreadyClaimed = alreadyClaimedByNetuid.get(netuid) ?? 0n;
+    const pendingRootClaim = totalClaimable > alreadyClaimed ? totalClaimable - alreadyClaimed : 0n;
     pendingRootClaimBalances.push({
       address,
       tokenId: chaindataProvider.subDTaoTokenId(networkId, netuid, hotkey),
@@ -2382,6 +2387,23 @@ const fetchBalances$5 = async ({
     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();
+
+    // Collect all (address, hotkey, netuid) pairs for root stakes to fetch RootClaimed amounts
+    const addressHotkeyNetuidPairs = [];
+    for (const [address, stakes] of stakeInfos) {
+      for (const stake of stakes) {
+        if (stake.netuid === ROOT_NETUID) {
+          const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey);
+          if (claimableRates) {
+            // For each netuid that has a claimable rate, we need to check RootClaimed
+            for (const netuid of claimableRates.keys()) {
+              addressHotkeyNetuidPairs.push([address, stake.hotkey, netuid]);
+            }
+          }
+        }
+      }
+    }
+    const rootClaimedAmounts = addressHotkeyNetuidPairs.length && miniMetadata.data ? await fetchRootClaimedAmounts(connector, networkId, miniMetadata.data, addressHotkeyNetuidPairs) : new Map();
     const dynamicInfoByNetuid = lodashEs.keyBy(dynamicInfos.filter(util.isNotNil), info => info.netuid);
 
     // Upserts a balance into the accumulator, merging stake values if the balance already exists.
@@ -2421,13 +2443,16 @@ const fetchBalances$5 = async ({
 
         // Root stake cases, we need to calculate the pending root claim and add to the balances
         if (stake.netuid === ROOT_NETUID) {
+          const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map();
+          const alreadyClaimedMap = rootClaimedAmounts.get(address)?.get(stake.hotkey) ?? new Map();
           const pendingRootClaimBalances = calculatePendingRootClaimable({
             stake: stake.stake,
             hotkey: stake.hotkey,
             address,
             networkId,
-            validatorRootClaimableRate: rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map(),
-            dynamicInfoByNetuid
+            validatorRootClaimableRate: claimableRates,
+            dynamicInfoByNetuid,
+            alreadyClaimedByNetuid: alreadyClaimedMap
           });
           pendingRootClaimBalances.forEach(balance => {
             upsertBalance(acc, address, balance.tokenId, balance);
@@ -2542,6 +2567,19 @@ const buildRootClaimableStorageCoder = async (connector, networkId, metadataRpc)
   }
   return storageCoder;
 };
+const buildRootClaimedStorageCoder = async (networkId, metadataRpc) => {
+  let storageCoder = null;
+  if (metadataRpc) {
+    try {
+      storageCoder = buildStorageCoder(metadataRpc, "SubtensorModule", "RootClaimed");
+    } catch (cause) {
+      log.warn(`Failed to build storage coder for SubtensorModule.RootClaimed using provided metadata on ${networkId}`, {
+        cause
+      });
+    }
+  }
+  return storageCoder;
+};
 const buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
   return hotkeys.map(hotkey => {
     let stateKey = null;
@@ -2585,6 +2623,74 @@ const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkey
     return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
   }
 };
+const buildRootClaimedQueries = (networkId, addressHotkeyNetuidPairs, storageCoder) => {
+  return addressHotkeyNetuidPairs.map(([address, hotkey, netuid]) => {
+    let stateKey = null;
+    try {
+      // RootClaimed storage takes params: [netuid, hotkey, coldkey_ss58]
+      stateKey = storageCoder.keys.enc(netuid, hotkey, address);
+    } catch (cause) {
+      log.warn(`Failed to encode storage key for RootClaimed (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`, {
+        cause
+      });
+    }
+    const decodeResult = changes => {
+      const hexValue = changes[0];
+      if (!hexValue) {
+        return [address, hotkey, netuid, 0n];
+      }
+      const decoded = scale.decodeScale(storageCoder, hexValue, `Failed to decode RootClaimed for (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`);
+      return [address, hotkey, netuid, decoded ?? 0n];
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  });
+};
+const fetchRootClaimedAmounts = async (connector, networkId, metadataRpc, addressHotkeyNetuidPairs) => {
+  if (!addressHotkeyNetuidPairs.length) {
+    return new Map();
+  }
+  const storageCoder = await buildRootClaimedStorageCoder(networkId, metadataRpc);
+  if (!storageCoder) {
+    // Fallback: return empty map for all pairs
+    const result = new Map();
+    for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, 0n);
+    }
+    return result;
+  }
+  const queries = buildRootClaimedQueries(networkId, addressHotkeyNetuidPairs, storageCoder);
+  try {
+    const results = await fetchRpcQueryPack(connector, networkId, queries);
+    // Build a nested map: address -> hotkey -> netuid -> claimed amount
+    const result = new Map();
+    for (const [address, hotkey, netuid, claimed] of results) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, claimed);
+    }
+    return result;
+  } catch (cause) {
+    log.warn(`Failed to fetch RootClaimed for address-hotkey-netuid pairs on ${networkId}`, {
+      cause
+    });
+    // Fallback: return empty map for all pairs
+    const result = new Map();
+    for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, 0n);
+    }
+    return result;
+  }
+};
 
 // hardcoded because we dont have access to native tokens from the balance module
 const NATIVE_TOKEN_SYMBOLS = {
@@ -2684,7 +2790,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   scale.compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle", "RootClaimable"]
+    items: ["TransferToggle", "RootClaimable", "RootClaimed"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

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

@@ -2301,7 +2301,8 @@ const calculatePendingRootClaimable = ({
   address,
   networkId,
   validatorRootClaimableRate,
-  dynamicInfoByNetuid
+  dynamicInfoByNetuid,
+  alreadyClaimedByNetuid
 }) => {
   const pendingRootClaimBalances = [];
   for (const [netuid, claimableRate] of validatorRootClaimableRate) {
@@ -2315,7 +2316,11 @@ const calculatePendingRootClaimable = ({
 
     // Multiply claimable_rate by root_stake
     // I96F32 multiplication: round((a * b) / 2^32)
-    const pendingRootClaim = stake * claimableRate + (1n << 31n) >> 32n;
+    const totalClaimable = stake * claimableRate + (1n << 31n) >> 32n;
+
+    // Subtract already claimed amount to get net pending claimable
+    const alreadyClaimed = alreadyClaimedByNetuid.get(netuid) ?? 0n;
+    const pendingRootClaim = totalClaimable > alreadyClaimed ? totalClaimable - alreadyClaimed : 0n;
     pendingRootClaimBalances.push({
       address,
       tokenId: chaindataProvider.subDTaoTokenId(networkId, netuid, hotkey),
@@ -2382,6 +2387,23 @@ const fetchBalances$5 = async ({
     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();
+
+    // Collect all (address, hotkey, netuid) pairs for root stakes to fetch RootClaimed amounts
+    const addressHotkeyNetuidPairs = [];
+    for (const [address, stakes] of stakeInfos) {
+      for (const stake of stakes) {
+        if (stake.netuid === ROOT_NETUID) {
+          const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey);
+          if (claimableRates) {
+            // For each netuid that has a claimable rate, we need to check RootClaimed
+            for (const netuid of claimableRates.keys()) {
+              addressHotkeyNetuidPairs.push([address, stake.hotkey, netuid]);
+            }
+          }
+        }
+      }
+    }
+    const rootClaimedAmounts = addressHotkeyNetuidPairs.length && miniMetadata.data ? await fetchRootClaimedAmounts(connector, networkId, miniMetadata.data, addressHotkeyNetuidPairs) : new Map();
     const dynamicInfoByNetuid = lodashEs.keyBy(dynamicInfos.filter(util.isNotNil), info => info.netuid);
 
     // Upserts a balance into the accumulator, merging stake values if the balance already exists.
@@ -2421,13 +2443,16 @@ const fetchBalances$5 = async ({
 
         // Root stake cases, we need to calculate the pending root claim and add to the balances
         if (stake.netuid === ROOT_NETUID) {
+          const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map();
+          const alreadyClaimedMap = rootClaimedAmounts.get(address)?.get(stake.hotkey) ?? new Map();
           const pendingRootClaimBalances = calculatePendingRootClaimable({
             stake: stake.stake,
             hotkey: stake.hotkey,
             address,
             networkId,
-            validatorRootClaimableRate: rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map(),
-            dynamicInfoByNetuid
+            validatorRootClaimableRate: claimableRates,
+            dynamicInfoByNetuid,
+            alreadyClaimedByNetuid: alreadyClaimedMap
           });
           pendingRootClaimBalances.forEach(balance => {
             upsertBalance(acc, address, balance.tokenId, balance);
@@ -2542,6 +2567,19 @@ const buildRootClaimableStorageCoder = async (connector, networkId, metadataRpc)
   }
   return storageCoder;
 };
+const buildRootClaimedStorageCoder = async (networkId, metadataRpc) => {
+  let storageCoder = null;
+  if (metadataRpc) {
+    try {
+      storageCoder = buildStorageCoder(metadataRpc, "SubtensorModule", "RootClaimed");
+    } catch (cause) {
+      log.warn(`Failed to build storage coder for SubtensorModule.RootClaimed using provided metadata on ${networkId}`, {
+        cause
+      });
+    }
+  }
+  return storageCoder;
+};
 const buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
   return hotkeys.map(hotkey => {
     let stateKey = null;
@@ -2585,6 +2623,74 @@ const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkey
     return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
   }
 };
+const buildRootClaimedQueries = (networkId, addressHotkeyNetuidPairs, storageCoder) => {
+  return addressHotkeyNetuidPairs.map(([address, hotkey, netuid]) => {
+    let stateKey = null;
+    try {
+      // RootClaimed storage takes params: [netuid, hotkey, coldkey_ss58]
+      stateKey = storageCoder.keys.enc(netuid, hotkey, address);
+    } catch (cause) {
+      log.warn(`Failed to encode storage key for RootClaimed (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`, {
+        cause
+      });
+    }
+    const decodeResult = changes => {
+      const hexValue = changes[0];
+      if (!hexValue) {
+        return [address, hotkey, netuid, 0n];
+      }
+      const decoded = scale.decodeScale(storageCoder, hexValue, `Failed to decode RootClaimed for (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`);
+      return [address, hotkey, netuid, decoded ?? 0n];
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  });
+};
+const fetchRootClaimedAmounts = async (connector, networkId, metadataRpc, addressHotkeyNetuidPairs) => {
+  if (!addressHotkeyNetuidPairs.length) {
+    return new Map();
+  }
+  const storageCoder = await buildRootClaimedStorageCoder(networkId, metadataRpc);
+  if (!storageCoder) {
+    // Fallback: return empty map for all pairs
+    const result = new Map();
+    for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, 0n);
+    }
+    return result;
+  }
+  const queries = buildRootClaimedQueries(networkId, addressHotkeyNetuidPairs, storageCoder);
+  try {
+    const results = await fetchRpcQueryPack(connector, networkId, queries);
+    // Build a nested map: address -> hotkey -> netuid -> claimed amount
+    const result = new Map();
+    for (const [address, hotkey, netuid, claimed] of results) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, claimed);
+    }
+    return result;
+  } catch (cause) {
+    log.warn(`Failed to fetch RootClaimed for address-hotkey-netuid pairs on ${networkId}`, {
+      cause
+    });
+    // Fallback: return empty map for all pairs
+    const result = new Map();
+    for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, 0n);
+    }
+    return result;
+  }
+};
 
 // hardcoded because we dont have access to native tokens from the balance module
 const NATIVE_TOKEN_SYMBOLS = {
@@ -2684,7 +2790,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   scale.compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle", "RootClaimable"]
+    items: ["TransferToggle", "RootClaimable", "RootClaimed"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

package/dist/talismn-balances.esm.js

@@ -2292,7 +2292,8 @@ const calculatePendingRootClaimable = ({
   address,
   networkId,
   validatorRootClaimableRate,
-  dynamicInfoByNetuid
+  dynamicInfoByNetuid,
+  alreadyClaimedByNetuid
 }) => {
   const pendingRootClaimBalances = [];
   for (const [netuid, claimableRate] of validatorRootClaimableRate) {
@@ -2306,7 +2307,11 @@ const calculatePendingRootClaimable = ({
 
     // Multiply claimable_rate by root_stake
     // I96F32 multiplication: round((a * b) / 2^32)
-    const pendingRootClaim = stake * claimableRate + (1n << 31n) >> 32n;
+    const totalClaimable = stake * claimableRate + (1n << 31n) >> 32n;
+
+    // Subtract already claimed amount to get net pending claimable
+    const alreadyClaimed = alreadyClaimedByNetuid.get(netuid) ?? 0n;
+    const pendingRootClaim = totalClaimable > alreadyClaimed ? totalClaimable - alreadyClaimed : 0n;
     pendingRootClaimBalances.push({
       address,
       tokenId: subDTaoTokenId(networkId, netuid, hotkey),
@@ -2373,6 +2378,23 @@ const fetchBalances$5 = async ({
     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();
+
+    // Collect all (address, hotkey, netuid) pairs for root stakes to fetch RootClaimed amounts
+    const addressHotkeyNetuidPairs = [];
+    for (const [address, stakes] of stakeInfos) {
+      for (const stake of stakes) {
+        if (stake.netuid === ROOT_NETUID) {
+          const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey);
+          if (claimableRates) {
+            // For each netuid that has a claimable rate, we need to check RootClaimed
+            for (const netuid of claimableRates.keys()) {
+              addressHotkeyNetuidPairs.push([address, stake.hotkey, netuid]);
+            }
+          }
+        }
+      }
+    }
+    const rootClaimedAmounts = addressHotkeyNetuidPairs.length && miniMetadata.data ? await fetchRootClaimedAmounts(connector, networkId, miniMetadata.data, addressHotkeyNetuidPairs) : new Map();
     const dynamicInfoByNetuid = keyBy(dynamicInfos.filter(isNotNil), info => info.netuid);
 
     // Upserts a balance into the accumulator, merging stake values if the balance already exists.
@@ -2412,13 +2434,16 @@ const fetchBalances$5 = async ({
 
         // Root stake cases, we need to calculate the pending root claim and add to the balances
         if (stake.netuid === ROOT_NETUID) {
+          const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map();
+          const alreadyClaimedMap = rootClaimedAmounts.get(address)?.get(stake.hotkey) ?? new Map();
           const pendingRootClaimBalances = calculatePendingRootClaimable({
             stake: stake.stake,
             hotkey: stake.hotkey,
             address,
             networkId,
-            validatorRootClaimableRate: rootClaimableRatesByHotkey.get(stake.hotkey) ?? new Map(),
-            dynamicInfoByNetuid
+            validatorRootClaimableRate: claimableRates,
+            dynamicInfoByNetuid,
+            alreadyClaimedByNetuid: alreadyClaimedMap
           });
           pendingRootClaimBalances.forEach(balance => {
             upsertBalance(acc, address, balance.tokenId, balance);
@@ -2533,6 +2558,19 @@ const buildRootClaimableStorageCoder = async (connector, networkId, metadataRpc)
   }
   return storageCoder;
 };
+const buildRootClaimedStorageCoder = async (networkId, metadataRpc) => {
+  let storageCoder = null;
+  if (metadataRpc) {
+    try {
+      storageCoder = buildStorageCoder(metadataRpc, "SubtensorModule", "RootClaimed");
+    } catch (cause) {
+      log.warn(`Failed to build storage coder for SubtensorModule.RootClaimed using provided metadata on ${networkId}`, {
+        cause
+      });
+    }
+  }
+  return storageCoder;
+};
 const buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
   return hotkeys.map(hotkey => {
     let stateKey = null;
@@ -2576,6 +2614,74 @@ const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkey
     return new Map(hotkeys.map(hotkey => [hotkey, new Map()]));
   }
 };
+const buildRootClaimedQueries = (networkId, addressHotkeyNetuidPairs, storageCoder) => {
+  return addressHotkeyNetuidPairs.map(([address, hotkey, netuid]) => {
+    let stateKey = null;
+    try {
+      // RootClaimed storage takes params: [netuid, hotkey, coldkey_ss58]
+      stateKey = storageCoder.keys.enc(netuid, hotkey, address);
+    } catch (cause) {
+      log.warn(`Failed to encode storage key for RootClaimed (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`, {
+        cause
+      });
+    }
+    const decodeResult = changes => {
+      const hexValue = changes[0];
+      if (!hexValue) {
+        return [address, hotkey, netuid, 0n];
+      }
+      const decoded = decodeScale(storageCoder, hexValue, `Failed to decode RootClaimed for (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`);
+      return [address, hotkey, netuid, decoded ?? 0n];
+    };
+    return {
+      stateKeys: [stateKey],
+      decodeResult
+    };
+  });
+};
+const fetchRootClaimedAmounts = async (connector, networkId, metadataRpc, addressHotkeyNetuidPairs) => {
+  if (!addressHotkeyNetuidPairs.length) {
+    return new Map();
+  }
+  const storageCoder = await buildRootClaimedStorageCoder(networkId, metadataRpc);
+  if (!storageCoder) {
+    // Fallback: return empty map for all pairs
+    const result = new Map();
+    for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, 0n);
+    }
+    return result;
+  }
+  const queries = buildRootClaimedQueries(networkId, addressHotkeyNetuidPairs, storageCoder);
+  try {
+    const results = await fetchRpcQueryPack(connector, networkId, queries);
+    // Build a nested map: address -> hotkey -> netuid -> claimed amount
+    const result = new Map();
+    for (const [address, hotkey, netuid, claimed] of results) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, claimed);
+    }
+    return result;
+  } catch (cause) {
+    log.warn(`Failed to fetch RootClaimed for address-hotkey-netuid pairs on ${networkId}`, {
+      cause
+    });
+    // Fallback: return empty map for all pairs
+    const result = new Map();
+    for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
+      if (!result.has(address)) result.set(address, new Map());
+      const addressMap = result.get(address);
+      if (!addressMap.has(hotkey)) addressMap.set(hotkey, new Map());
+      addressMap.get(hotkey).set(netuid, 0n);
+    }
+    return result;
+  }
+};
 
 // hardcoded because we dont have access to native tokens from the balance module
 const NATIVE_TOKEN_SYMBOLS = {
@@ -2675,7 +2781,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle", "RootClaimable"]
+    items: ["TransferToggle", "RootClaimable", "RootClaimed"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -38,13 +38,13 @@
     "scale-ts": "^1.6.1",
     "viem": "^2.27.3",
     "zod": "^3.25.76",
-    "@talismn/chain-connectors": "0.0.12",
-    "@talismn/sapi": "0.1.0",
-    "@talismn/chaindata-provider": "1.3.3",
+    "@talismn/chaindata-provider": "1.3.4",
     "@talismn/crypto": "0.3.0",
+    "@talismn/chain-connectors": "0.0.13",
+    "@talismn/sapi": "0.1.0",
     "@talismn/scale": "0.3.0",
-    "@talismn/token-rates": "3.0.14",
     "@talismn/solana": "0.0.5",
+    "@talismn/token-rates": "3.0.15",
     "@talismn/util": "0.5.6"
   },
   "devDependencies": {
@@ -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": "*",