@talismn/balances 1.2.2 → 1.3.1

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

@@ -0,0 +1,12 @@
+import { GetDynamicInfosResult, SubDTaoBalance } from "./types";
+type DynamicInfo = NonNullable<GetDynamicInfosResult[number]>;
+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/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,47 @@ const taoToAlpha = (tao, scaledAlphaPrice) => {
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
 
+const calculatePendingRootClaimable = ({
+  stake,
+  hotkey,
+  address,
+  networkId,
+  validatorRootClaimableRate,
+  dynamicInfoByNetuid,
+  alreadyClaimedByNetuid
+}) => {
+  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 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),
+      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 +2385,83 @@ 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();
+
+    // 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);
-    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 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: claimableRates,
+            dynamicInfoByNetuid,
+            alreadyClaimedByNetuid: alreadyClaimedMap
+          });
+          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 +2487,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 +2548,149 @@ 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 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;
+    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()]));
+  }
+};
+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 = {
@@ -2517,7 +2790,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   scale.compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle"]
+    items: ["TransferToggle", "RootClaimable", "RootClaimed"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

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

@@ -2295,6 +2295,47 @@ const taoToAlpha = (tao, scaledAlphaPrice) => {
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
 
+const calculatePendingRootClaimable = ({
+  stake,
+  hotkey,
+  address,
+  networkId,
+  validatorRootClaimableRate,
+  dynamicInfoByNetuid,
+  alreadyClaimedByNetuid
+}) => {
+  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 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),
+      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 +2385,83 @@ 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();
+
+    // 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);
-    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 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: claimableRates,
+            dynamicInfoByNetuid,
+            alreadyClaimedByNetuid: alreadyClaimedMap
+          });
+          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 +2487,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 +2548,149 @@ 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 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;
+    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()]));
+  }
+};
+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 = {
@@ -2517,7 +2790,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   scale.compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle"]
+    items: ["TransferToggle", "RootClaimable", "RootClaimed"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

package/dist/talismn-balances.esm.js

@@ -2286,6 +2286,47 @@ const taoToAlpha = (tao, scaledAlphaPrice) => {
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
 
+const calculatePendingRootClaimable = ({
+  stake,
+  hotkey,
+  address,
+  networkId,
+  validatorRootClaimableRate,
+  dynamicInfoByNetuid,
+  alreadyClaimedByNetuid
+}) => {
+  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 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),
+      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 +2376,83 @@ 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();
+
+    // 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);
-    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 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: claimableRates,
+            dynamicInfoByNetuid,
+            alreadyClaimedByNetuid: alreadyClaimedMap
+          });
+          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 +2478,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 +2539,149 @@ 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 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;
+    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()]));
+  }
+};
+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 = {
@@ -2508,7 +2781,7 @@ const getData$4 = metadataRpc => {
   if (!isBittensor) return null;
   compactMetadata(metadata, [{
     pallet: "SubtensorModule",
-    items: ["TransferToggle"]
+    items: ["TransferToggle", "RootClaimable", "RootClaimed"]
   }], [{
     runtimeApi: "StakeInfoRuntimeApi",
     methods: ["get_stake_info_for_coldkeys"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "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.4",
     "@talismn/crypto": "0.3.0",
+    "@talismn/chain-connectors": "0.0.13",
     "@talismn/sapi": "0.1.0",
     "@talismn/scale": "0.3.0",
     "@talismn/solana": "0.0.5",
-    "@talismn/token-rates": "3.0.13",
-    "@talismn/util": "0.5.6",
-    "@talismn/chaindata-provider": "1.3.2",
-    "@talismn/chain-connectors": "0.0.11"
+    "@talismn/token-rates": "3.0.15",
+    "@talismn/util": "0.5.6"
   },
   "devDependencies": {
     "@polkadot/api-contract": "16.1.2",