@talismn/balances 3.0.0 → 3.0.1

package/dist/index.js

@@ -1778,6 +1778,21 @@ const buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
 	}));
 };
 //#endregion
+//#region src/modules/shared/fetchBestBlockHash.ts
+/**
+* Hash of the current best block, to pin a poll's reads to.
+*
+* Chain state moves between the round-trips of a multi-call poll, and unpinned reads each
+* run against whatever block is best when they land. Combining values read at different
+* blocks fabricates data (eg a dtao basket claim total read one block after its
+* per-validator breakdown leaves an unattributed remainder).
+*/
+const fetchBestBlockHash = async (connector, networkId) => {
+	const blockHash = await connector.send(networkId, "chain_getBlockHash", []);
+	if (!blockHash) throw new Error(`Failed to fetch best block hash on ${networkId}`);
+	return blockHash;
+};
+//#endregion
 //#region src/modules/shared/parseMetadataRpcCached.ts
 /**
 * parseMetadataRpc does a full metadata decode + dynamic-builder build (tens to hundreds
@@ -1825,11 +1840,15 @@ const getRuntimeCall = (builder, apiName, method) => {
 	}
 	return call;
 };
-const fetchRuntimeCallResult = async (connector, networkId, metadataRpcOrBuilder, apiName, method, args) => {
+const fetchRuntimeCallResult = async (connector, networkId, metadataRpcOrBuilder, apiName, method, args, at) => {
 	try {
 		const builder = typeof metadataRpcOrBuilder === "string" ? parseMetadataRpcCached(metadataRpcOrBuilder).builder : metadataRpcOrBuilder;
 		const call = getRuntimeCall(builder, apiName, method);
-		const hex = await connector.send(networkId, "state_call", [`${apiName}_${method}`, (0, _talismn_scale.toHex)(call.args.enc(args))]);
+		const hex = await connector.send(networkId, "state_call", [
+			`${apiName}_${method}`,
+			(0, _talismn_scale.toHex)(call.args.enc(args)),
+			...at ? [at] : []
+		]);
 		const start = performance.now();
 		const result = call.value.dec(hex);
 		(0, _talismn_util.reportJsActivity)(`runtimeCall decode ${networkId} ${apiName}.${method} (~${Math.round((hex?.length ?? 0) / 2048)}KB)`, performance.now() - start);
@@ -1840,10 +1859,10 @@ const fetchRuntimeCallResult = async (connector, networkId, metadataRpcOrBuilder
 };
 //#endregion
 //#region src/modules/shared/rpcQueryPack.ts
-const fetchRpcQueryPack = async (connector, networkId, queries) => {
+const fetchRpcQueryPack = async (connector, networkId, queries, at) => {
 	const allStateKeys = queries.flatMap(({ stateKeys }) => stateKeys).filter(_talismn_util.isNotNil);
 	if (!allStateKeys.length) return queries.map(({ stateKeys, decodeResult }) => decodeResult(stateKeys.map(() => null)));
-	const [result] = await connector.send(networkId, "state_queryStorageAt", [allStateKeys]);
+	const [result] = await connector.send(networkId, "state_queryStorageAt", at ? [allStateKeys, at] : [allStateKeys]);
 	if (!result) throw new Error(`Empty state_queryStorageAt response on ${networkId}`);
 	return decodeRpcQueryPackChunked(queries, new Map(result.changes), { label: `rpcQueryPack decode ${networkId}` });
 };
@@ -3927,6 +3946,74 @@ const taoToAlphaCeil = (tao, scaledAlphaPrice) => {
 	return (tao * ALPHA_PRICE_SCALE + scaledAlphaPrice - 1n) / scaledAlphaPrice;
 };
 //#endregion
+//#region src/modules/substrate-dtao/basketClaims.ts
+/** label of the claimable-rewards values emitted on root staking balances */
+const CLAIMABLE_REWARDS_LABEL = "Claimable rewards";
+/** Whether a lock is a claimable root rewards entitlement */
+const isDTaoClaimableLock = (lock) => lock.label === CLAIMABLE_REWARDS_LABEL;
+/** Sum of a balance's claimable root rewards (TAO plancks, marked NAV quote) */
+const getDTaoClaimablePlancks = (locks) => (locks ?? []).filter(isDTaoClaimableLock).reduce((sum, lock) => sum + lock.amount.planck, 0n);
+/**
+* The target pair's claimable rewards, null once its entitlement is gone (eg claimed elsewhere).
+* Sourced from balances rather than staking positions: the chain keeps basket entitlement
+* after a full unstake, so a claim can have no stake left on its validator.
+*/
+const findDTaoClaimablePlancks = (balances, { networkId, address, hotkey }) => {
+	const balance = balances.find((b) => b.token?.type === "substrate-dtao" && b.token.networkId === networkId && b.token.netuid === 0 && b.token.hotkey === hotkey && (0, _talismn_crypto.isAddressEqual)(b.address, address));
+	const claimablePlancks = balance ? getDTaoClaimablePlancks(balance.locks) : 0n;
+	return claimablePlancks > 0n ? claimablePlancks : null;
+};
+/**
+* Fetches the TAO each coldkey would realize by redeeming its validator beta baskets
+* (Bittensor spec 441 "Root Reborn": root dividends accrue in per-validator escrow funds
+* and must be claimed manually; the payout is TAO staked back onto the root position).
+*
+* Amounts are marked NAV quotes (BetaBasketRuntimeApi), so they move with subnet pool
+* prices as well as accrual. Attribution is per validator hotkey via
+* `get_root_basket_positions`, which walks the chain's own coldkey→hotkeys index and so
+* includes validators the coldkey fully unstaked from (entitlement survives unstaking).
+*
+* It is the only entitlement read: the coldkey-wide `get_root_basket_owed` total sums the
+* same positions, and claiming is per validator hotkey, so entitlement outside a position
+* would be unclaimable anyway.
+*/
+const fetchBasketClaims = async (connector, networkId, metadataRpc, addresses, at) => {
+	if (!addresses.length) return [];
+	const { unifiedMetadata, builder } = parseMetadataRpcCached(metadataRpc);
+	if (!hasRuntimeApi(unifiedMetadata, "BetaBasketRuntimeApi", "get_root_basket_positions")) return [];
+	try {
+		return (await Promise.all(addresses.map(async (address) => [address, await fetchRuntimeCallResult(connector, networkId, builder, "BetaBasketRuntimeApi", "get_root_basket_positions", [address], at)]))).flatMap(([address, positions]) => positions.filter(([, , payoutTao]) => payoutTao > 0n).map(([hotkey, , payoutTao]) => ({
+			address,
+			hotkey,
+			amount: payoutTao
+		})));
+	} catch (cause) {
+		log_default.warn(`Failed to fetch beta basket claims on ${networkId}`, { cause });
+		throw cause;
+	}
+};
+//#endregion
+//#region src/modules/substrate-dtao/fetchStorageKeysPaged.ts
+const PAGE_SIZE = 1e3;
+/**
+* Prefix scan via state_getKeysPaged. The unpaged state_getKeys is classified as heavy storage
+* work and rejected by some public nodes (eg the bittensor testnet one: "Storage work rate limit
+* exceeded"), while the paged variant is universally allowed.
+*/
+const fetchStorageKeysPaged = async (connector, networkId, keyPrefix, at) => {
+	const keys = [];
+	let startKey;
+	do {
+		const params = [keyPrefix, PAGE_SIZE];
+		if (startKey || at) params.push(startKey ?? null);
+		if (at) params.push(at);
+		const page = await connector.send(networkId, "state_getKeysPaged", params);
+		keys.push(...page);
+		startKey = page.length === PAGE_SIZE ? page[page.length - 1] : void 0;
+	} while (startKey);
+	return keys;
+};
+//#endregion
 //#region src/modules/substrate-dtao/convictionLocks.ts
 const convictionLockKey = (address, netuid) => `${address}:${netuid}`;
 const getConvictionLockLabel = (lockType) => lockType === "perpetual" ? "Perpetual Conviction Lock" : "Decaying Conviction Lock";
@@ -3974,17 +4061,17 @@ const toBigIntValue = (value) => {
 * the chain keeps a zero-mass Lock entry alive while it still carries conviction ("ghost" lock),
 * even after the coldkey fully unstaked from the subnet.
 */
-const fetchConvictionLocks = async (connector, networkId, metadataRpc, addresses) => {
+const fetchConvictionLocks = async (connector, networkId, metadataRpc, addresses, at) => {
 	if (!addresses.length) return [];
 	const { unifiedMetadata, builder } = parseMetadataRpcCached(metadataRpc);
 	if (!hasRuntimeApi(unifiedMetadata, "StakeInfoRuntimeApi", "get_coldkey_lock") || !hasStorageItems(unifiedMetadata, "SubtensorModule", ["Lock", "DecayingLock"])) return [];
 	try {
 		const lockStorageCoder = builder.buildStorage("SubtensorModule", "Lock");
 		const decayingLockStorageCoder = builder.buildStorage("SubtensorModule", "DecayingLock");
-		const lockStorageKeys = await fetchConvictionLockStorageKeys(connector, networkId, addresses, lockStorageCoder);
+		const lockStorageKeys = await fetchConvictionLockStorageKeys(connector, networkId, addresses, lockStorageCoder, at);
 		if (!lockStorageKeys.length) return [];
 		const hotkeyByPair = new Map(lockStorageKeys.map(({ address, netuid, hotkey }) => [convictionLockKey(address, netuid), hotkey]));
-		const [lockModesByPair, lockStates] = await Promise.all([fetchConvictionLockModes(connector, networkId, lockStorageKeys, decayingLockStorageCoder), fetchColdkeyLockStates(connector, networkId, builder, lockStorageKeys)]);
+		const [lockModesByPair, lockStates] = await Promise.all([fetchConvictionLockModes(connector, networkId, lockStorageKeys, decayingLockStorageCoder, at), fetchColdkeyLockStates(connector, networkId, builder, lockStorageKeys, at)]);
 		return lockStates.flatMap(({ address, netuid, lockState }) => {
 			const amount = lockState?.locked_mass ?? 0n;
 			const convictionRaw = toBigIntValue(lockState?.conviction);
@@ -4012,7 +4099,7 @@ const fetchConvictionLocks = async (connector, networkId, metadataRpc, addresses
 * Encoding only the first map key (the coldkey) yields the storage key prefix covering all of the
 * coldkey's (netuid, hotkey) entries, using the hashers declared in metadata.
 */
-const fetchConvictionLockStorageKeys = async (connector, networkId, addresses, storageCoder) => {
+const fetchConvictionLockStorageKeys = async (connector, networkId, addresses, storageCoder, at) => {
 	return (await Promise.all(addresses.map(async (address) => {
 		let keyPrefix;
 		try {
@@ -4023,7 +4110,7 @@ const fetchConvictionLockStorageKeys = async (connector, networkId, addresses, s
 		}
 		let stateKeys;
 		try {
-			stateKeys = await connector.send(networkId, "state_getKeys", [keyPrefix]);
+			stateKeys = await fetchStorageKeysPaged(connector, networkId, keyPrefix, at);
 		} catch (cause) {
 			log_default.warn(`Failed to fetch conviction Lock keys (address=${address}) on ${networkId}`, { cause });
 			throw cause;
@@ -4043,7 +4130,7 @@ const fetchConvictionLockStorageKeys = async (connector, networkId, addresses, s
 		});
 	}))).flat();
 };
-const fetchConvictionLockModes = async (connector, networkId, pairs, storageCoder) => {
+const fetchConvictionLockModes = async (connector, networkId, pairs, storageCoder, at) => {
 	const queries = pairs.map(({ address, netuid }) => {
 		let stateKey;
 		try {
@@ -4064,15 +4151,15 @@ const fetchConvictionLockModes = async (connector, networkId, pairs, storageCode
 			}
 		};
 	});
-	return new Map(await fetchRpcQueryPack(connector, networkId, queries));
+	return new Map(await fetchRpcQueryPack(connector, networkId, queries, at));
 };
-const fetchColdkeyLockStates = async (connector, networkId, builder, pairs) => {
+const fetchColdkeyLockStates = async (connector, networkId, builder, pairs, at) => {
 	return Promise.all(pairs.map(async ({ address, netuid }) => {
 		try {
 			return {
 				address,
 				netuid,
-				lockState: await fetchRuntimeCallResult(connector, networkId, builder, "StakeInfoRuntimeApi", "get_coldkey_lock", [address, netuid])
+				lockState: await fetchRuntimeCallResult(connector, networkId, builder, "StakeInfoRuntimeApi", "get_coldkey_lock", [address, netuid], at)
 			};
 		} catch (cause) {
 			log_default.warn(`Failed to fetch get_coldkey_lock for (netuid=${netuid}, address=${address}) on ${networkId}`, { cause });
@@ -4085,29 +4172,122 @@ const fetchColdkeyLockStates = async (connector, networkId, builder, pairs) => {
 const MODULE_TYPE$5 = _talismn_chaindata_provider.SubDTaoTokenSchema.shape.type.value;
 const PLATFORM$5 = _talismn_chaindata_provider.SubDTaoTokenSchema.shape.platform.value;
 //#endregion
-//#region src/modules/substrate-dtao/calculatePendingRootClaimable.ts
-const calculatePendingRootClaimable = ({ stake, hotkey, address, networkId, validatorRootClaimableRate, alreadyClaimedByNetuid }) => {
-	const pendingRootClaimBalances = [];
-	for (const [netuid, claimableRate] of validatorRootClaimableRate) {
-		if (claimableRate === 0n) continue;
-		const totalClaimable = stake * claimableRate + (1n << 31n) >> 32n;
-		const alreadyClaimed = alreadyClaimedByNetuid.get(netuid) ?? 0n;
-		const pendingRootClaim = totalClaimable > alreadyClaimed ? totalClaimable - alreadyClaimed : 0n;
-		pendingRootClaimBalances.push({
-			address,
-			tokenId: (0, _talismn_chaindata_provider.subDTaoTokenId)(networkId, netuid, hotkey),
-			baseTokenId: (0, _talismn_chaindata_provider.subDTaoTokenId)(networkId, netuid),
-			hotkey,
-			netuid,
-			pendingRootClaim,
-			stake: 0n
+//#region src/modules/substrate-dtao/rootStakeHold.ts
+/**
+* Extracts the root-stake hold from a balance's raw values (BalanceJson), if any.
+* While present, the pair's root stake cannot leave root — unstake/move/swap/transfer
+* would fail with `RootStakeLocked`. Only present while the window was still running
+* as of the last balances poll.
+*/
+const findDTaoRootStakeHold = (balance) => {
+	for (const value of balance?.values ?? []) {
+		const hold = value.meta?.rootStakeHold;
+		if (hold?.type === "root-stake-hold") return hold;
+	}
+	return null;
+};
+/**
+* Fetches active root-stake hold windows (spec 441): when `RootStakeUnlockInterval` is
+* non-zero, root stake cannot leave root (remove/move/swap/transfer) until `interval`
+* blocks after the pair's last root stake add/remove/claim (`LastColdkeyHotkeyStakeBlock`).
+* Pairs already past their window are omitted — a returned hold means the pair's root
+* stake is currently unremovable.
+*
+* The interval is 0 (disabled) unless governance enables it — either by setting the
+* storage entry or via a runtime default that leaves it unset (metadata fallback). The
+* per-pair queries only run when it is non-zero.
+*/
+const fetchRootStakeHolds = async (connector, networkId, metadataRpc, rootPairs, at) => {
+	if (!rootPairs.length) return [];
+	const { unifiedMetadata, builder } = parseMetadataRpcCached(metadataRpc);
+	if (!hasStorageItems(unifiedMetadata, "SubtensorModule", ["RootStakeUnlockInterval", "LastColdkeyHotkeyStakeBlock"])) return [];
+	try {
+		const interval = await fetchUnlockInterval(connector, networkId, unifiedMetadata, builder, at);
+		if (interval === 0n) return [];
+		const { currentBlock, lastStakeBlocks } = await fetchLastStakeBlocks(connector, networkId, builder, rootPairs, at);
+		return lastStakeBlocks.flatMap(({ address, hotkey, lastStakeBlock }) => {
+			if (lastStakeBlock === 0n) return [];
+			const unlockAtBlock = lastStakeBlock + interval;
+			if (unlockAtBlock <= BigInt(currentBlock)) return [];
+			return [{
+				address,
+				hotkey,
+				unlockAtBlock: Number(unlockAtBlock)
+			}];
 		});
+	} catch (cause) {
+		log_default.warn(`Failed to fetch root stake holds on ${networkId}`, { cause });
+		throw cause;
 	}
-	return pendingRootClaimBalances;
+};
+const fetchUnlockInterval = async (connector, networkId, unifiedMetadata, builder, at) => {
+	const storageCoder = builder.buildStorage("SubtensorModule", "RootStakeUnlockInterval");
+	const [interval] = await fetchRpcQueryPack(connector, networkId, [{
+		stateKeys: [storageCoder.keys.enc()],
+		decodeResult: (changes) => {
+			const encoded = changes[0] ?? getUnlockIntervalFallback(unifiedMetadata, networkId);
+			const decoded = (0, _talismn_scale.decodeScale)(storageCoder, encoded, `Failed to decode RootStakeUnlockInterval on ${networkId}`);
+			if (decoded === null) throw new Error(`Failed to decode RootStakeUnlockInterval on ${networkId}`);
+			return decoded;
+		}
+	}], at);
+	return interval ?? 0n;
+};
+const getUnlockIntervalFallback = (unifiedMetadata, networkId) => {
+	const fallback = unifiedMetadata.pallets.find((pallet) => pallet.name === "SubtensorModule")?.storage?.items.find((item) => item.name === "RootStakeUnlockInterval")?.fallback;
+	if (!fallback) throw new Error(`Missing RootStakeUnlockInterval metadata fallback on ${networkId}`);
+	return fallback;
+};
+/**
+* Reads each pair's `LastColdkeyHotkeyStakeBlock` plus the current block number, all from
+* one state snapshot: `System.Number` rides along as an extra key of the same
+* `state_queryStorageAt` instead of costing a separate `chain_getHeader` round trip.
+*/
+const fetchLastStakeBlocks = async (connector, networkId, builder, rootPairs, at) => {
+	const numberCoder = builder.buildStorage("System", "Number");
+	const currentBlockQuery = {
+		stateKeys: [numberCoder.keys.enc()],
+		decodeResult: (changes) => {
+			const decoded = (0, _talismn_scale.decodeScale)(numberCoder, changes[0], `Failed to decode System.Number on ${networkId}`);
+			if (decoded === null) throw new Error(`Failed to decode System.Number on ${networkId}`);
+			return Number(decoded);
+		}
+	};
+	const storageCoder = builder.buildStorage("SubtensorModule", "LastColdkeyHotkeyStakeBlock");
+	const [currentBlock, ...lastStakeBlocks] = await fetchRpcQueryPack(connector, networkId, [currentBlockQuery, ...rootPairs.map(({ address, hotkey }) => {
+		let stateKey;
+		try {
+			stateKey = storageCoder.keys.enc(address, hotkey);
+		} catch (cause) {
+			log_default.warn(`Failed to encode LastColdkeyHotkeyStakeBlock key (address=${address}, hotkey=${hotkey}) on ${networkId}`, { cause });
+			throw cause;
+		}
+		return {
+			stateKeys: [stateKey],
+			decodeResult: (changes) => {
+				const hexValue = changes[0];
+				if (!hexValue) return {
+					address,
+					hotkey,
+					lastStakeBlock: 0n
+				};
+				const decoded = (0, _talismn_scale.decodeScale)(storageCoder, hexValue, `Failed to decode LastColdkeyHotkeyStakeBlock for (address=${address}, hotkey=${hotkey}) on ${networkId}`);
+				if (decoded === null) throw new Error(`Failed to decode LastColdkeyHotkeyStakeBlock for (address=${address}, hotkey=${hotkey}) on ${networkId}`);
+				return {
+					address,
+					hotkey,
+					lastStakeBlock: decoded
+				};
+			}
+		};
+	})], at);
+	return {
+		currentBlock,
+		lastStakeBlocks
+	};
 };
 //#endregion
 //#region src/modules/substrate-dtao/fetchBalances.ts
-const ROOT_NETUID = 0;
 const fetchBalances$5 = async ({ networkId, tokensWithAddresses, connector, miniMetadata, signal }) => {
 	if (!tokensWithAddresses.length) return {
 		success: [],
@@ -4150,29 +4330,36 @@ const fetchBalances$5 = async ({ networkId, tokensWithAddresses, connector, mini
 	const addresses = (0, lodash_es.uniq)(balanceDefs.map((def) => def.address));
 	try {
 		const { builder } = parseMetadataRpcCached(miniMetadata.data);
-		const stakeInfos = await fetchRuntimeCallResult(connector, networkId, builder, "StakeInfoRuntimeApi", "get_stake_info_for_coldkeys", [addresses]);
-		const rootHotkeys = (0, lodash_es.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) : /* @__PURE__ */ new Map();
-		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 (const netuid of claimableRates.keys()) addressHotkeyNetuidPairs.push([
+		const at = await fetchBestBlockHash(connector, networkId);
+		const stakeInfos = await fetchRuntimeCallResult(connector, networkId, builder, "StakeInfoRuntimeApi", "get_stake_info_for_coldkeys", [addresses], at);
+		const rootPairs = [];
+		const seenRootPairs = /* @__PURE__ */ new Set();
+		for (const [address, stakes] of stakeInfos) for (const stake of stakes) {
+			if (stake.netuid !== 0) continue;
+			const pairKey = `${address}:${stake.hotkey}`;
+			if (seenRootPairs.has(pairKey)) continue;
+			seenRootPairs.add(pairKey);
+			rootPairs.push({
 				address,
-				stake.hotkey,
-				netuid
-			]);
+				hotkey: stake.hotkey
+			});
 		}
-		const [rootClaimedAmounts, convictionLocks] = await Promise.all([addressHotkeyNetuidPairs.length && miniMetadata.data ? fetchRootClaimedAmounts(connector, networkId, miniMetadata.data, addressHotkeyNetuidPairs) : Promise.resolve(/* @__PURE__ */ new Map()), miniMetadata.data ? fetchConvictionLocks(connector, networkId, miniMetadata.data, addresses) : Promise.resolve([])]);
+		const [convictionLocks, basketClaims, rootStakeHolds] = miniMetadata.data ? await Promise.all([
+			fetchConvictionLocks(connector, networkId, miniMetadata.data, addresses, at),
+			fetchBasketClaims(connector, networkId, miniMetadata.data, addresses, at),
+			fetchRootStakeHolds(connector, networkId, miniMetadata.data, rootPairs, at)
+		]) : [
+			[],
+			[],
+			[]
+		];
 		const upsertBalance = (acc, address, tokenId, balance) => {
 			const key = `${address}:${tokenId}`;
 			const recordedBalance = acc[key];
-			if (recordedBalance) acc[key] = {
-				...recordedBalance,
-				stake: recordedBalance.stake + balance.stake,
-				...balance.pendingRootClaim !== void 0 && { pendingRootClaim: balance.pendingRootClaim },
-				...balance.convictionLock !== void 0 && { convictionLock: balance.convictionLock }
-			};
-			else acc[key] = balance;
+			acc[key] = recordedBalance ? (0, lodash_es.mergeWith)({}, recordedBalance, balance, (recorded, incoming, field) => {
+				if (field === "stake" && recorded !== void 0) return recorded + incoming;
+				return incoming;
+			}) : balance;
 		};
 		const slicer = (0, _talismn_util.createTimeSlicer)({
 			signal,
@@ -4189,21 +4376,21 @@ const fetchBalances$5 = async ({ networkId, tokensWithAddresses, connector, mini
 				netuid: stake.netuid
 			};
 			upsertBalance(balancesRaw, address, balance.tokenId, balance);
-			if (stake.netuid === ROOT_NETUID) {
-				const claimableRates = rootClaimableRatesByHotkey.get(stake.hotkey) ?? /* @__PURE__ */ new Map();
-				const alreadyClaimedMap = rootClaimedAmounts.get(address)?.get(stake.hotkey) ?? /* @__PURE__ */ new Map();
-				calculatePendingRootClaimable({
-					stake: stake.stake,
-					hotkey: stake.hotkey,
-					address,
-					networkId,
-					validatorRootClaimableRate: claimableRates,
-					alreadyClaimedByNetuid: alreadyClaimedMap
-				}).forEach((balance) => {
-					upsertBalance(balancesRaw, address, balance.tokenId, balance);
-				});
-			}
 		}, { slicer });
+		const upsertRootPairFields = (items, getFields) => (0, _talismn_util.forEachWithYield)(items, (item) => {
+			const tokenId = (0, _talismn_chaindata_provider.subDTaoTokenId)(networkId, 0, item.hotkey);
+			upsertBalance(balancesRaw, item.address, tokenId, {
+				address: item.address,
+				tokenId,
+				baseTokenId: (0, _talismn_chaindata_provider.subDTaoTokenId)(networkId, 0),
+				stake: 0n,
+				hotkey: item.hotkey,
+				netuid: 0,
+				...getFields(item)
+			});
+		}, { slicer });
+		await upsertRootPairFields(basketClaims, ({ amount }) => ({ claimable: amount }));
+		await upsertRootPairFields(rootStakeHolds, ({ unlockAtBlock }) => ({ rootStakeHoldUnlockBlock: unlockAtBlock }));
 		await (0, _talismn_util.forEachWithYield)(convictionLocks, ({ address, netuid, lock }) => {
 			const balance = {
 				address,
@@ -4240,21 +4427,35 @@ const fetchBalances$5 = async ({ networkId, tokensWithAddresses, connector, mini
 				const stake = balancesRaw[`${def.address}:${def.token.id}`];
 				if (!stake) return null;
 				const stakeAmount = BigInt(stake.stake?.toString() ?? "0");
-				const pendingRootClaimAmount = BigInt(stake.pendingRootClaim?.toString() ?? "0");
+				const claimableAmount = BigInt(stake.claimable?.toString() ?? "0");
 				const convictionLockAmount = BigInt(stake.convictionLock?.amount?.toString() ?? "0");
 				const convictionLockConviction = BigInt(stake.convictionLock?.convictionRaw ?? "0");
-				const hasZeroStake = stakeAmount === 0n;
-				const hasPendingRootClaim = pendingRootClaimAmount > 0n;
+				const rootStakeHoldMeta = stake.rootStakeHoldUnlockBlock !== void 0 ? { rootStakeHold: {
+					type: "root-stake-hold",
+					unlockAtBlock: stake.rootStakeHoldUnlockBlock
+				} } : void 0;
 				const values = [{
 					type: "free",
 					label: stake.netuid === 0 ? "Root Staking" : `Subnet Staking`,
-					amount: stakeAmount.toString()
-				}, {
-					type: "locked",
-					label: "Pending root claim",
-					amount: pendingRootClaimAmount.toString(),
-					includeInTransferable: true
+					amount: stakeAmount.toString(),
+					...rootStakeHoldMeta && { meta: rootStakeHoldMeta }
 				}];
+				if (claimableAmount > 0n) {
+					const claimable = {
+						label: CLAIMABLE_REWARDS_LABEL,
+						amount: claimableAmount.toString()
+					};
+					values.push({
+						...claimable,
+						type: "locked",
+						includeInTransferable: true
+					});
+					values.push({
+						...claimable,
+						type: "extra",
+						includeInTotal: true
+					});
+				}
 				if (stake.convictionLock && (convictionLockAmount > 0n || convictionLockConviction > 0n)) {
 					const convictionLockMeta = { convictionLock: {
 						type: "conviction-lock",
@@ -4268,12 +4469,6 @@ const fetchBalances$5 = async ({ networkId, tokensWithAddresses, connector, mini
 						meta: convictionLockMeta
 					});
 				}
-				if (hasZeroStake && hasPendingRootClaim) values.push({
-					type: "extra",
-					label: "Pending root claim",
-					amount: pendingRootClaimAmount.toString(),
-					includeInTotal: true
-				});
 				return {
 					address: def.address,
 					networkId,
@@ -4299,124 +4494,6 @@ const fetchBalances$5 = async ({ networkId, tokensWithAddresses, connector, mini
 		};
 	}
 };
-const buildStorageCoder = (metadataRpc, pallet, entry) => {
-	const { builder } = parseMetadataRpcCached(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_default.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_default.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;
-		try {
-			stateKey = storageCoder.keys.enc(hotkey);
-		} catch (cause) {
-			log_default.warn(`Failed to encode storage key for hotkey ${hotkey} on ${networkId}`, { cause });
-			throw cause;
-		}
-		const decodeResult = (changes) => {
-			const hexValue = changes[0];
-			if (!hexValue) return [hotkey, /* @__PURE__ */ new Map()];
-			const decoded = (0, _talismn_scale.decodeScale)(storageCoder, hexValue, `Failed to decode RootClaimable for hotkey ${hotkey} on ${networkId}`);
-			if (decoded === null) throw new Error(`Failed to decode RootClaimable for hotkey ${hotkey} on ${networkId}`);
-			return [hotkey, new Map(decoded)];
-		};
-		return {
-			stateKeys: [stateKey],
-			decodeResult
-		};
-	});
-};
-const fetchRootClaimableRates = async (connector, networkId, metadataRpc, hotkeys) => {
-	if (!hotkeys.length) return /* @__PURE__ */ new Map();
-	const storageCoder = await buildRootClaimableStorageCoder(connector, networkId, metadataRpc);
-	if (!storageCoder) return new Map(hotkeys.map((hotkey) => [hotkey, /* @__PURE__ */ new Map()]));
-	const queries = buildRootClaimableQueries(networkId, hotkeys, storageCoder);
-	try {
-		const results = await fetchRpcQueryPack(connector, networkId, queries);
-		return new Map(results);
-	} catch (cause) {
-		log_default.warn(`Failed to fetch RootClaimable for hotkeys on ${networkId}`, { cause });
-		throw cause;
-	}
-};
-const buildRootClaimedQueries = (networkId, addressHotkeyNetuidPairs, storageCoder) => {
-	return addressHotkeyNetuidPairs.map(([address, hotkey, netuid]) => {
-		let stateKey;
-		try {
-			stateKey = storageCoder.keys.enc(netuid, hotkey, address);
-		} catch (cause) {
-			log_default.warn(`Failed to encode storage key for RootClaimed (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`, { cause });
-			throw cause;
-		}
-		const decodeResult = (changes) => {
-			const hexValue = changes[0];
-			if (!hexValue) return [
-				address,
-				hotkey,
-				netuid,
-				0n
-			];
-			const decoded = (0, _talismn_scale.decodeScale)(storageCoder, hexValue, `Failed to decode RootClaimed for (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`);
-			if (decoded === null) throw new Error(`Failed to decode RootClaimed for (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`);
-			return [
-				address,
-				hotkey,
-				netuid,
-				decoded
-			];
-		};
-		return {
-			stateKeys: [stateKey],
-			decodeResult
-		};
-	});
-};
-const fetchRootClaimedAmounts = async (connector, networkId, metadataRpc, addressHotkeyNetuidPairs) => {
-	if (!addressHotkeyNetuidPairs.length) return /* @__PURE__ */ new Map();
-	const storageCoder = await buildRootClaimedStorageCoder(networkId, metadataRpc);
-	if (!storageCoder) {
-		const result = /* @__PURE__ */ new Map();
-		for (const [address, hotkey, netuid] of addressHotkeyNetuidPairs) {
-			if (!result.has(address)) result.set(address, /* @__PURE__ */ new Map());
-			const addressMap = result.get(address);
-			if (!addressMap.has(hotkey)) addressMap.set(hotkey, /* @__PURE__ */ new Map());
-			addressMap.get(hotkey).set(netuid, 0n);
-		}
-		return result;
-	}
-	const queries = buildRootClaimedQueries(networkId, addressHotkeyNetuidPairs, storageCoder);
-	try {
-		const results = await fetchRpcQueryPack(connector, networkId, queries);
-		const result = /* @__PURE__ */ new Map();
-		for (const [address, hotkey, netuid, claimed] of results) {
-			if (!result.has(address)) result.set(address, /* @__PURE__ */ new Map());
-			const addressMap = result.get(address);
-			if (!addressMap.has(hotkey)) addressMap.set(hotkey, /* @__PURE__ */ new Map());
-			addressMap.get(hotkey).set(netuid, claimed);
-		}
-		return result;
-	} catch (cause) {
-		log_default.warn(`Failed to fetch RootClaimed for address-hotkey-netuid pairs on ${networkId}`, { cause });
-		throw cause;
-	}
-};
 //#endregion
 //#region src/modules/substrate-dtao/fetchTokens.ts
 const NATIVE_TOKEN_SYMBOLS = {
@@ -4455,7 +4532,7 @@ const fetchTokens$5 = async ({ networkId, connector, tokens, miniMetadata }) =>
 const fetchTransferableTokensMap = async (connector, metadata, networkId) => {
 	const { builder } = parseMetadataRpcCached(metadata);
 	const transferToggleCodec = builder.buildStorage("SubtensorModule", "TransferToggle");
-	const transferToggleKeys = await connector.send(networkId, "state_getKeys", [(0, _talismn_scale.getStorageKeyPrefix)("SubtensorModule", "TransferToggle")]);
+	const transferToggleKeys = await fetchStorageKeysPaged(connector, networkId, (0, _talismn_scale.getStorageKeyPrefix)("SubtensorModule", "TransferToggle"));
 	const transferToggleResults = await connector.send(networkId, "state_queryStorageAt", [transferToggleKeys]);
 	return (0, lodash_es.fromPairs)((transferToggleResults.length ? transferToggleResults[0].changes : []).map(([key, value]) => {
 		const [netuid] = transferToggleCodec.keys.dec(key);
@@ -4493,18 +4570,28 @@ const getData$3 = (metadataRpc) => {
 		pallet: "SubtensorModule",
 		items: [
 			"TransferToggle",
-			"RootClaimable",
-			"RootClaimed",
 			"Lock",
-			"DecayingLock"
+			"DecayingLock",
+			"RootStakeUnlockInterval",
+			"LastColdkeyHotkeyStakeBlock"
 		]
-	}], [{
-		runtimeApi: "StakeInfoRuntimeApi",
-		methods: ["get_stake_info_for_coldkeys", "get_coldkey_lock"]
 	}, {
-		runtimeApi: "SubnetInfoRuntimeApi",
-		methods: ["get_all_dynamic_info"]
-	}]);
+		pallet: "System",
+		items: ["Number"]
+	}], [
+		{
+			runtimeApi: "StakeInfoRuntimeApi",
+			methods: ["get_stake_info_for_coldkeys", "get_coldkey_lock"]
+		},
+		{
+			runtimeApi: "SubnetInfoRuntimeApi",
+			methods: ["get_all_dynamic_info"]
+		},
+		{
+			runtimeApi: "BetaBasketRuntimeApi",
+			methods: ["get_root_basket_positions"]
+		}
+	]);
 	return (0, _talismn_scale.encodeMetadata)(metadata);
 };
 //#endregion
@@ -4530,7 +4617,8 @@ const getTransferCallData$5 = ({ from, to, value, token, metadataRpc }) => {
 };
 //#endregion
 //#region src/modules/substrate-dtao/isEffectivelyEqualDTaoBalance.ts
-/** root dividends accrue continuously; the pending-claim display is informational */
+/** basket claimable amounts are marked NAV quotes: they move with subnet pool prices and
+* dividend accrual on (nearly) every block; the display is informational */
 const CLAIM_DRIFT_TOLERANCE_BPS = 100n;
 /**
 * subnet staking positions auto-compound: dividend injections land once per subnet tempo
@@ -4541,8 +4629,8 @@ const CLAIM_DRIFT_TOLERANCE_BPS = 100n;
 const STAKE_DRIFT_TOLERANCE_BPS = 100n;
 /**
 * dtao balances embed values that drift on (nearly) every block even when the user's
-* position is untouched: "Pending root claim" amounts accrue continuously, staking
-* positions auto-compound, and conviction locks decay.
+* position is untouched: staking positions auto-compound, basket claimable quotes move,
+* and conviction locks decay.
 *
 * Without special handling, every 6s poll re-emits the full result set, which defeats
 * every distinctUntilChanged stage downstream and forces the whole pipeline
@@ -4554,9 +4642,7 @@ const STAKE_DRIFT_TOLERANCE_BPS = 100n;
 *   drift-prone values above (relative to the previously EMITTED value, so movement
 *   accumulates and a sustained move still surfaces)
 * - "drift" when ONLY the drift-prone values moved, beyond tolerance. The stabilizer
-*   re-emits these at most once per refresh interval — important for fast-accruing
-*   values (a young pending claim can grow >1% per poll indefinitely, so a purely
-*   relative tolerance can never suppress it)
+*   re-emits these at most once per refresh interval
 * - "changed" for structural changes (stake, locks, status, value set) — emitted
 *   immediately
 */
@@ -4575,14 +4661,13 @@ const isWithinDriftTolerance = (previous, next, toleranceBps) => {
 	const max = a > b ? a : b;
 	return diff * 10000n <= max * toleranceBps;
 };
-/** the only labels whose amounts accrue per block (see fetchBalances) */
-const PENDING_ROOT_CLAIM_LABEL = "Pending root claim";
 const changed = (reason) => ({
 	equivalence: "changed",
 	reason
 });
-/** claims accrue and locks decay — their values may appear/disappear as amounts cross zero */
-const isDriftProneValue = (value) => value.label === PENDING_ROOT_CLAIM_LABEL || !!value.meta?.convictionLock;
+/** claimable quotes and decaying locks may appear as their amounts cross zero */
+const isDriftProneValue = (value) => value.label === "Claimable rewards" || hasConvictionLock(value);
+const hasConvictionLock = (value) => !!value.meta?.convictionLock;
 const classifyValue = (previous, next) => {
 	if (("includeInTransferable" in previous ? previous.includeInTransferable : void 0) !== ("includeInTransferable" in next ? next.includeInTransferable : void 0) || ("includeInTotal" in previous ? previous.includeInTotal : void 0) !== ("includeInTotal" in next ? next.includeInTotal : void 0)) return changed("variant flags");
 	const previousMeta = previous.meta;
@@ -4590,8 +4675,9 @@ const classifyValue = (previous, next) => {
 	const previousLock = previousMeta?.convictionLock;
 	const nextLock = nextMeta?.convictionLock;
 	if (previousLock?.type !== nextLock?.type || previousLock?.hotkey !== nextLock?.hotkey || previousLock?.lockType !== nextLock?.lockType) return changed("conviction lock meta");
+	if (previousMeta?.rootStakeHold?.unlockAtBlock !== nextMeta?.rootStakeHold?.unlockAtBlock) return changed("root stake hold meta");
 	let drift = false;
-	if (previous.amount !== next.amount) if (previous.label === PENDING_ROOT_CLAIM_LABEL) {
+	if (previous.amount !== next.amount) if (previous.label === "Claimable rewards") {
 		if (!isWithinDriftTolerance(previous.amount, next.amount, CLAIM_DRIFT_TOLERANCE_BPS)) drift = true;
 	} else if (previousLock) drift = true;
 	else if (isWithinDriftTolerance(previous.amount, next.amount, STAKE_DRIFT_TOLERANCE_BPS)) drift = true;
@@ -4614,7 +4700,7 @@ const classifyBalance = (previous, next) => {
 	for (const [key, previousValue] of previousByKey) {
 		const nextValue = nextByKey.get(key);
 		if (!nextValue) {
-			if (!isDriftProneValue(previousValue)) return changed(`value removed: ${key}`);
+			if (!hasConvictionLock(previousValue)) return changed(`value removed: ${key}`);
 			drift = true;
 			continue;
 		}
@@ -7486,11 +7572,14 @@ exports.excludeFromFeePayableLocks = excludeFromFeePayableLocks;
 exports.excludeFromTransferableAmount = excludeFromTransferableAmount;
 exports.filterBaseLocks = filterBaseLocks;
 exports.filterMirrorTokens = filterMirrorTokens;
+exports.findDTaoClaimablePlancks = findDTaoClaimablePlancks;
 exports.findDTaoConvictionLock = findDTaoConvictionLock;
+exports.findDTaoRootStakeHold = findDTaoRootStakeHold;
 exports.getBalanceFingerprint = getBalanceFingerprint;
 exports.getBalanceId = getBalanceId;
 exports.getBalanceStorageFingerprint = getBalanceStorageFingerprint;
 exports.getConvictionLockLabel = getConvictionLockLabel;
+exports.getDTaoClaimablePlancks = getDTaoClaimablePlancks;
 exports.getEpochTransferFee = getEpochTransferFee;
 exports.getExtension = getExtension;
 exports.getLockTitle = getLockTitle;
@@ -7504,6 +7593,7 @@ exports.getTransferFeeConfig = getTransferFeeConfig;
 exports.getTransferHook = getTransferHook;
 exports.getValueId = getValueId;
 exports.includeInTotalExtraAmount = includeInTotalExtraAmount;
+exports.isDTaoClaimableLock = isDTaoClaimableLock;
 exports.isEqualBalanceArrays = isEqualBalanceArrays;
 exports.isEqualBalancesResult = isEqualBalancesResult;
 exports.isEqualMiniMetadatas = isEqualMiniMetadatas;