@talismn/balances 1.4.0 → 2.0.0

package/dist/index.mjs

@@ -1,3 +1,8 @@
+// src/configureBigNumber.ts
+import BigNumber from "bignumber.js";
+BigNumber.set({ STRICT: false });
+var configureBigNumber_default = BigNumber;
+
 // src/BalancesProvider.ts
 import {
   isNetworkDot,
@@ -38,7 +43,7 @@ import anylogger from "anylogger";
 // package.json
 var package_default = {
   name: "@talismn/balances",
-  version: "1.4.0",
+  version: "2.0.0",
   author: "Talisman",
   homepage: "https://talisman.xyz",
   license: "GPL-3.0-or-later",
@@ -66,9 +71,9 @@ var package_default = {
   },
   dependencies: {
     "@metaplex-foundation/mpl-token-metadata": "^3.4.0",
-    "@metaplex-foundation/umi": "^1.2.0",
-    "@polkadot-api/utils": "0.2.0",
-    "@solana/spl-token": "^0.4.13",
+    "@metaplex-foundation/umi": "^1.5.1",
+    "@polkadot-api/utils": "0.4.0",
+    "@solana/spl-token": "^0.4.14",
     "@solana/web3.js": "^1.98.2",
     "@talismn/chain-connectors": "workspace:*",
     "@talismn/chaindata-provider": "workspace:*",
@@ -78,21 +83,22 @@ var package_default = {
     "@talismn/token-rates": "workspace:*",
     "@talismn/util": "workspace:*",
     anylogger: "^1.0.11",
-    "bignumber.js": "^9.1.2",
-    "lodash-es": "4.17.21",
+    "bignumber.js": "^11.1.3",
+    "lodash-es": "4.18.1",
     "p-queue": "8.1.0",
-    "polkadot-api": "1.23.3",
-    rxjs: "^7.8.1",
+    "polkadot-api": "2.1.6",
+    rxjs: "^7.8.2",
     "scale-ts": "^1.6.1",
-    viem: "^2.27.3",
-    zod: "^3.25.76"
+    viem: "2.52.2",
+    zod: "^4.4.3"
   },
   devDependencies: {
     "@polkadot/api-contract": "16.1.2",
     "@polkadot/types": "16.1.2",
     "@talismn/tsconfig": "workspace:*",
     "@types/lodash-es": "4.17.12",
-    typescript: "^5.6.3"
+    "@types/node": "^24.5.1",
+    typescript: "^6.0.3"
   },
   peerDependencies: {
     "@polkadot/api-contract": "*",
@@ -1019,13 +1025,8 @@ import { assign, omit } from "lodash-es";
 import z from "zod/v4";
 
 // src/modules/evm-erc20/utils.ts
-import {
-  ContractFunctionExecutionError,
-  erc20Abi as erc20Abi2,
-  erc20Abi_bytes32,
-  getContract,
-  hexToString
-} from "viem";
+import { isErrorOfName } from "@talismn/util";
+import { erc20Abi as erc20Abi2, erc20Abi_bytes32, getContract, hexToString } from "viem";
 var getErc20ContractData = async (client, contractAddress) => {
   try {
     const contract = getTypedContract(client, erc20Abi2, contractAddress);
@@ -1035,7 +1036,7 @@ var getErc20ContractData = async (client, contractAddress) => {
       contract.read.name()
     ]);
   } catch (e) {
-    if (e instanceof ContractFunctionExecutionError) {
+    if (isErrorOfName(e, "ContractFunctionExecutionError")) {
       const contract = getTypedContract(client, erc20Abi_bytes32, contractAddress);
       var [bytesSymbol, decimals, nameSymbol] = await Promise.all([
         contract.read.symbol(),
@@ -1252,21 +1253,30 @@ var fetchBalances2 = async ({
   }
   const balanceDefs = getBalanceDefs(tokensWithAddresses);
   if (client.chain?.contracts?.multicall3 && balanceDefs.length > 1) {
-    const multicall3 = client.chain.contracts.multicall3;
-    return fetchWithMulticall(client, balanceDefs, multicall3.address);
+    try {
+      return await fetchWithMulticall(
+        client,
+        balanceDefs,
+        client.chain.contracts.multicall3.address
+      );
+    } catch {
+    }
   }
-  return fetchWithoutMulticall(client, balanceDefs);
+  return fetchWithGetBalance(client, balanceDefs);
 };
-var fetchWithoutMulticall = async (client, balanceDefs) => {
+var fetchWithGetBalance = async (client, balanceDefs) => {
   if (balanceDefs.length === 0) return { success: [], errors: [] };
   const results = await Promise.allSettled(
     balanceDefs.map(async ({ token, address }) => {
       try {
-        const result = await client.getBalance({ address });
+        const result = await client.request({
+          method: "eth_getBalance",
+          params: [address, "latest"]
+        });
         const balance = {
           address,
           tokenId: token.id,
-          value: result.toString(),
+          value: BigInt(result).toString(),
           source: MODULE_TYPE2,
           networkId: parseTokenId2(token.id).networkId,
           status: "live"
@@ -1300,55 +1310,28 @@ var fetchWithoutMulticall = async (client, balanceDefs) => {
 };
 var fetchWithMulticall = async (client, balanceDefs, multicall3Address) => {
   if (balanceDefs.length === 0) return { success: [], errors: [] };
-  try {
-    const callResults = await client.multicall({
-      contracts: balanceDefs.map(({ address }) => ({
-        address: multicall3Address,
-        abi: abiMulticall,
-        functionName: "getEthBalance",
-        args: [address]
-      }))
-    });
-    return callResults.reduce(
-      (acc, result, index) => {
-        if (result.status === "success") {
-          acc.success.push({
-            address: balanceDefs[index].address,
-            tokenId: balanceDefs[index].token.id,
-            value: result.result.toString(),
-            source: MODULE_TYPE2,
-            networkId: parseTokenId2(balanceDefs[index].token.id).networkId,
-            status: "live"
-          });
-        }
-        if (result.status === "failure") {
-          acc.errors.push({
-            tokenId: balanceDefs[index].token.id,
-            address: balanceDefs[index].address,
-            error: new BalanceFetchError(
-              `Failed to get balance for token ${balanceDefs[index].token.id} and address ${balanceDefs[index].address} on chain ${client.chain?.id}`,
-              balanceDefs[index].token.id,
-              balanceDefs[index].address,
-              result.error
-            )
-          });
-        }
-        return acc;
-      },
-      { success: [], errors: [] }
-    );
-  } catch (err) {
-    const errors = balanceDefs.map((balanceDef) => ({
-      tokenId: balanceDef.token.id,
-      address: balanceDef.address,
-      error: new BalanceFetchNetworkError(
-        `Failed to get balances for evm-erc20 tokens on chain ${client.chain?.id}`,
-        String(client.chain?.id),
-        err
-      )
-    }));
-    return { success: [], errors };
-  }
+  const results = await client.multicall({
+    allowFailure: false,
+    contracts: balanceDefs.map(({ address }) => ({
+      address: multicall3Address,
+      abi: abiMulticall,
+      functionName: "getEthBalance",
+      args: [address]
+    }))
+  });
+  return {
+    success: results.map(
+      (value, index) => ({
+        address: balanceDefs[index].address,
+        tokenId: balanceDefs[index].token.id,
+        value: String(value),
+        source: MODULE_TYPE2,
+        networkId: parseTokenId2(balanceDefs[index].token.id).networkId,
+        status: "live"
+      })
+    ),
+    errors: []
+  };
 };
 
 // src/modules/evm-native/fetchTokens.ts
@@ -1469,7 +1452,6 @@ var PLATFORM3 = EvmUniswapV2TokenSchema.shape.platform.value;
 // src/modules/evm-uniswapv2/fetchBalances.ts
 import { parseTokenId as parseTokenId3 } from "@talismn/chaindata-provider";
 import { isEthereumAddress as isEthereumAddress5 } from "@talismn/crypto";
-import BigNumber from "bignumber.js";
 import { keyBy, uniq } from "lodash-es";
 import { getContract as getContract2 } from "viem";
 var fetchBalances3 = async ({
@@ -1561,7 +1543,7 @@ var fetchPoolBalances = async (client, balanceDefs) => {
         label,
         amount
       });
-      const ratio = BigNumber(String(balance)).div(totalSupply === 0n ? "1" : String(totalSupply));
+      const ratio = configureBigNumber_default(String(balance)).div(totalSupply === 0n ? "1" : String(totalSupply));
       acc.success.push({
         address,
         tokenId: token.id,
@@ -1593,13 +1575,8 @@ import { assign as assign3, omit as omit2 } from "lodash-es";
 import z4 from "zod/v4";
 
 // src/modules/evm-uniswapv2/utils.ts
-import {
-  ContractFunctionExecutionError as ContractFunctionExecutionError2,
-  erc20Abi as erc20Abi4,
-  erc20Abi_bytes32 as erc20Abi_bytes322,
-  getContract as getContract3,
-  hexToString as hexToString2
-} from "viem";
+import { isErrorOfName as isErrorOfName2 } from "@talismn/util";
+import { erc20Abi as erc20Abi4, erc20Abi_bytes32 as erc20Abi_bytes322, getContract as getContract3, hexToString as hexToString2 } from "viem";
 var getErc20ContractData2 = async (client, contractAddress) => {
   try {
     const contract = getTypedContract2(client, erc20Abi4, contractAddress);
@@ -1609,7 +1586,7 @@ var getErc20ContractData2 = async (client, contractAddress) => {
       contract.read.name()
     ]);
   } catch (e) {
-    if (e instanceof ContractFunctionExecutionError2) {
+    if (isErrorOfName2(e, "ContractFunctionExecutionError")) {
       const contract = getTypedContract2(client, erc20Abi_bytes322, contractAddress);
       var [bytesSymbol, decimals, nameSymbol] = await Promise.all([
         contract.read.symbol(),
@@ -2051,9 +2028,9 @@ var buildNetworkStorageCoders = (chainId, miniMetadata, coders) => {
 
 // src/modules/shared/fetchRuntimeCallResult.ts
 import { parseMetadataRpc, toHex } from "@talismn/scale";
-var fetchRuntimeCallResult = async (connector, networkId, metadataRpc, apiName, method, args) => {
+var fetchRuntimeCallResult = async (connector, networkId, metadataRpcOrBuilder, apiName, method, args) => {
   try {
-    const { builder } = parseMetadataRpc(metadataRpc);
+    const builder = typeof metadataRpcOrBuilder === "string" ? parseMetadataRpc(metadataRpcOrBuilder).builder : metadataRpcOrBuilder;
     const call = builder.buildRuntimeCall(apiName, method);
     const hex = await connector.send(networkId, "state_call", [
       `${apiName}_${method}`,
@@ -2124,17 +2101,17 @@ var decodeRpcQueryPack = (queries, result) => {
 import { parseMetadataRpc as parseMetadataRpc2 } from "@talismn/scale";
 var hasStorageItem = (metadata, palletName, itemName) => {
   const pallet = metadata.pallets.find((p) => p.name === palletName);
-  if (!pallet || !pallet.storage) return false;
+  if (!pallet?.storage) return false;
   return pallet.storage.items.some((item) => item.name === itemName);
 };
 var hasStorageItems = (metadata, palletName, itemNames) => {
   const pallet = metadata.pallets.find((p) => p.name === palletName);
-  if (!pallet || !pallet.storage) return false;
+  if (!pallet?.storage) return false;
   return itemNames.every((itemName) => pallet.storage?.items.some((item) => item.name === itemName));
 };
 var hasRuntimeApi = (metadata, apiName, method) => {
   const api = metadata.apis.find((api2) => api2.name === apiName);
-  if (!api || !api.methods) return false;
+  if (!api?.methods) return false;
   return api.methods.some((m) => m.name === method);
 };
 var getConstantValue = (metadataRpc, pallet, constant) => {
@@ -2300,7 +2277,7 @@ var fetchBalances5 = async ({
             cached = fetched;
           }
         }
-        if (!cached || !cached.isValid) return;
+        if (!cached?.isValid) return;
         const token = {
           id: tokenId,
           type: MODULE_TYPE5,
@@ -2691,7 +2668,7 @@ var fetchBalances6 = async ({
             cached = fetched;
           }
         }
-        if (!cached || !cached.isValid) return;
+        if (!cached?.isValid) return;
         const token = {
           id: tokenId,
           type: MODULE_TYPE6,
@@ -3122,6 +3099,7 @@ import {
 } from "@talismn/chaindata-provider";
 import { getStorageKeyPrefix, parseMetadataRpc as parseMetadataRpc3 } from "@talismn/scale";
 import { assign as assign7, keyBy as keyBy4, keys } from "lodash-es";
+import { Binary } from "polkadot-api";
 var fetchTokens7 = async ({
   networkId,
   tokens,
@@ -3163,8 +3141,8 @@ var fetchTokens7 = async ({
         assetId,
         decimals: metadata.decimals,
         isFrozen: metadata.is_frozen,
-        name: metadata.name?.asText(),
-        symbol: metadata.symbol?.asText()
+        name: metadata.name ? Binary.toText(metadata.name) : void 0,
+        symbol: metadata.symbol ? Binary.toText(metadata.symbol) : void 0
       };
     }),
     (a) => a.assetId
@@ -3202,7 +3180,7 @@ var fetchTokens7 = async ({
 
 // src/modules/substrate-assets/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION3 } from "@talismn/chaindata-provider";
-import { compactMetadata as compactMetadata2, encodeMetadata as encodeMetadata2, parseMetadataRpc as parseMetadataRpc8 } from "@talismn/scale";
+import { compactMetadata as compactMetadata2, encodeMetadata as encodeMetadata2, parseMetadataRpc as parseMetadataRpc9 } from "@talismn/scale";
 
 // src/types/balances.ts
 import { evmErc20TokenId as evmErc20TokenId2 } from "@talismn/chaindata-provider";
@@ -3215,7 +3193,6 @@ import {
   isBigInt,
   planckToTokens
 } from "@talismn/util";
-import BigNumber2 from "bignumber.js";
 
 // src/modules/substrate-dtao/alphaPrice.ts
 var TAO_DECIMALS = 9n;
@@ -3232,6 +3209,179 @@ var taoToAlpha = (tao, scaledAlphaPrice) => {
   if (!tao || !scaledAlphaPrice) return 0n;
   return tao * ALPHA_PRICE_SCALE / scaledAlphaPrice;
 };
+var taoToAlphaCeil = (tao, scaledAlphaPrice) => {
+  if (!tao || !scaledAlphaPrice) return 0n;
+  return (tao * ALPHA_PRICE_SCALE + scaledAlphaPrice - 1n) / scaledAlphaPrice;
+};
+
+// src/modules/substrate-dtao/convictionLocks.ts
+import {
+  decodeScale as decodeScale2,
+  parseMetadataRpc as parseMetadataRpc4
+} from "@talismn/scale";
+var convictionLockKey = (address, netuid) => `${address}:${netuid}`;
+var getConvictionLockLabel = (lockType) => lockType === "perpetual" ? "Perpetual Conviction Lock" : "Decaying Conviction Lock";
+var findDTaoConvictionLock = (locks) => {
+  for (const lock of locks ?? []) {
+    const meta = lock.meta;
+    if (meta?.convictionLock?.type !== "conviction-lock") continue;
+    const lockType = meta.convictionLock.lockType;
+    return {
+      amount: lock.amount.planck,
+      hotkey: meta.convictionLock.hotkey,
+      lockType,
+      label: getConvictionLockLabel(lockType)
+    };
+  }
+  return null;
+};
+var toBigIntValue = (value) => {
+  if (typeof value === "bigint") return value;
+  if (value && typeof value === "object" && "bits" in value) {
+    const bits = value.bits;
+    if (typeof bits === "bigint") return bits;
+  }
+  return 0n;
+};
+var fetchConvictionLocks = async (connector, networkId, metadataRpc, addresses) => {
+  if (!addresses.length) return [];
+  const { unifiedMetadata, builder } = parseMetadataRpc4(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
+    );
+    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)
+    ]);
+    return lockStates.flatMap(({ address, netuid, lockState }) => {
+      const amount = lockState?.locked_mass ?? 0n;
+      const convictionRaw = toBigIntValue(lockState?.conviction);
+      if (amount <= 0n && convictionRaw <= 0n) return [];
+      const hotkey = hotkeyByPair.get(convictionLockKey(address, netuid));
+      if (!hotkey) return [];
+      return [
+        {
+          address,
+          netuid,
+          lock: {
+            amount,
+            hotkey,
+            lockType: lockModesByPair.get(convictionLockKey(address, netuid)) ?? "decaying",
+            convictionRaw: convictionRaw.toString()
+          }
+        }
+      ];
+    });
+  } catch (cause) {
+    log_default.warn(`Failed to fetch Bittensor conviction locks on ${networkId}`, { cause });
+    return [];
+  }
+};
+var fetchConvictionLockStorageKeys = async (connector, networkId, addresses, storageCoder) => {
+  const keysPerAddress = await Promise.all(
+    addresses.map(async (address) => {
+      let keyPrefix;
+      try {
+        keyPrefix = storageCoder.keys.enc(address);
+      } catch (cause) {
+        log_default.warn(
+          `Failed to encode conviction Lock key prefix (address=${address}) on ${networkId}`,
+          { cause }
+        );
+        return [];
+      }
+      try {
+        const stateKeys = await connector.send(networkId, "state_getKeys", [
+          keyPrefix
+        ]);
+        return stateKeys.flatMap((stateKey) => {
+          try {
+            const [, netuid, hotkey] = storageCoder.keys.dec(stateKey);
+            return [{ address, netuid, hotkey }];
+          } catch (cause) {
+            log_default.warn(`Failed to decode conviction Lock key ${stateKey} on ${networkId}`, { cause });
+            return [];
+          }
+        });
+      } catch (cause) {
+        log_default.warn(`Failed to fetch conviction Lock keys (address=${address}) on ${networkId}`, {
+          cause
+        });
+        return [];
+      }
+    })
+  );
+  return keysPerAddress.flat();
+};
+var fetchConvictionLockModes = async (connector, networkId, pairs, storageCoder) => {
+  const queries = pairs.map(
+    ({ address, netuid }) => {
+      let stateKey = null;
+      try {
+        stateKey = storageCoder.keys.enc(address, netuid);
+      } catch (cause) {
+        log_default.warn(
+          `Failed to encode conviction DecayingLock key (netuid=${netuid}, address=${address}) on ${networkId}`,
+          { cause }
+        );
+      }
+      const key = convictionLockKey(address, netuid);
+      return {
+        stateKeys: [stateKey],
+        decodeResult: (changes) => {
+          const hexValue = changes[0];
+          if (!hexValue) return [key, "decaying"];
+          const decoded = decodeScale2(
+            storageCoder,
+            hexValue,
+            `Failed to decode DecayingLock for (netuid=${netuid}, address=${address}) on ${networkId}`
+          );
+          return [key, decoded === false ? "perpetual" : "decaying"];
+        }
+      };
+    }
+  );
+  return new Map(await fetchRpcQueryPack(connector, networkId, queries));
+};
+var fetchColdkeyLockStates = async (connector, networkId, builder, pairs) => {
+  return Promise.all(
+    pairs.map(async ({ address, netuid }) => {
+      try {
+        const lockState = await fetchRuntimeCallResult(
+          connector,
+          networkId,
+          builder,
+          "StakeInfoRuntimeApi",
+          "get_coldkey_lock",
+          [address, netuid]
+        );
+        return { address, netuid, lockState };
+      } catch (cause) {
+        log_default.warn(
+          `Failed to fetch get_coldkey_lock for (netuid=${netuid}, address=${address}) on ${networkId}`,
+          { cause }
+        );
+        return { address, netuid, lockState: null };
+      }
+    })
+  );
+};
 
 // src/modules/substrate-dtao/getDtaoTokenRates.ts
 import { subNativeTokenId } from "@talismn/chaindata-provider";
@@ -3239,7 +3389,14 @@ import {
   newTokenRates
 } from "@talismn/token-rates";
 var ONE_ALPHA = 10n ** TAO_DECIMALS;
-var getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice) => {
+var getAlphaChange24h = (currency, taoChange24h, alphaPriceChange24h) => {
+  if (typeof alphaPriceChange24h !== "number" || !Number.isFinite(alphaPriceChange24h))
+    return void 0;
+  if (currency === "tao") return alphaPriceChange24h;
+  if (typeof taoChange24h !== "number" || !Number.isFinite(taoChange24h)) return void 0;
+  return ((1 + alphaPriceChange24h / 100) * (1 + taoChange24h / 100) - 1) * 100;
+};
+var getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice, alphaPriceChange24h) => {
   try {
     const taoTokenId = subNativeTokenId(token.networkId);
     const taoTokenRates = tokenRates[taoTokenId];
@@ -3255,8 +3412,7 @@ var getDTaoTokenRates = (token, tokenRates, scaledAlphaPrice) => {
         alphaRates[currency] = {
           price: taoRate.price * priceRatio,
           marketCap: taoRate.marketCap ? taoRate.marketCap * priceRatio : void 0,
-          change24h: void 0
-          // cannot be determined from TAO rates alone
+          change24h: getAlphaChange24h(currency, taoRate.change24h, alphaPriceChange24h)
         };
       }
     }
@@ -3278,7 +3434,7 @@ import {
   subDTaoTokenId as subDTaoTokenId2,
   TokenSchema
 } from "@talismn/chaindata-provider";
-import { decodeScale as decodeScale2, parseMetadataRpc as parseMetadataRpc4 } from "@talismn/scale";
+import { decodeScale as decodeScale3, parseMetadataRpc as parseMetadataRpc5 } from "@talismn/scale";
 import { isNotNil as isNotNil5 } from "@talismn/util";
 import { keyBy as keyBy5, uniq as uniq4 } from "lodash-es";
 
@@ -3384,6 +3540,7 @@ var fetchBalances8 = async ({
         []
       )
     ]);
+    const dynamicInfoByNetuid = keyBy5(dynamicInfos.filter(isNotNil5), (info) => info.netuid);
     const rootHotkeys = uniq4(
       stakeInfos.flatMap(
         ([, stakes]) => stakes.filter((stake) => stake.netuid === ROOT_NETUID).map((stake) => stake.hotkey)
@@ -3403,13 +3560,10 @@ var fetchBalances8 = async ({
         }
       }
     }
-    const rootClaimedAmounts = addressHotkeyNetuidPairs.length && miniMetadata.data ? await fetchRootClaimedAmounts(
-      connector,
-      networkId,
-      miniMetadata.data,
-      addressHotkeyNetuidPairs
-    ) : /* @__PURE__ */ new Map();
-    const dynamicInfoByNetuid = keyBy5(dynamicInfos.filter(isNotNil5), (info) => info.netuid);
+    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 upsertBalance = (acc, address, tokenId, balance) => {
       const key = `${address}:${tokenId}`;
       const recordedBalance = acc[key];
@@ -3420,6 +3574,9 @@ var fetchBalances8 = async ({
           // If the new balance has pendingRootClaim, use it (it's calculated from current state)
           ...balance.pendingRootClaim !== void 0 && {
             pendingRootClaim: balance.pendingRootClaim
+          },
+          ...balance.convictionLock !== void 0 && {
+            convictionLock: balance.convictionLock
           }
         };
       } else {
@@ -3462,6 +3619,21 @@ var fetchBalances8 = async ({
       },
       {}
     );
+    for (const { address, netuid, lock } of convictionLocks) {
+      const dynamicInfo = dynamicInfoByNetuid[netuid];
+      const scaledAlphaPrice = dynamicInfo ? getScaledAlphaPrice(dynamicInfo.alpha_in, dynamicInfo.tao_in) : 0n;
+      const balance = {
+        address,
+        tokenId: subDTaoTokenId2(networkId, netuid),
+        baseTokenId: subDTaoTokenId2(networkId, netuid),
+        stake: 0n,
+        hotkey: lock.hotkey,
+        netuid,
+        scaledAlphaPrice,
+        convictionLock: lock
+      };
+      upsertBalance(balancesRaw, address, balance.tokenId, balance);
+    }
     const balances = Object.values(balancesRaw);
     const tokensById = keyBy5(
       tokensWithAddresses.map(([token]) => token),
@@ -3469,6 +3641,7 @@ var fetchBalances8 = async ({
     );
     const dynamicTokens = [];
     for (const bal of balances) {
+      if (bal.tokenId === bal.baseTokenId) continue;
       if (!balanceDefs.some((def) => def.token.id === bal.tokenId)) {
         const baseToken = tokensById[bal.baseTokenId];
         if (baseToken) {
@@ -3489,6 +3662,8 @@ var fetchBalances8 = async ({
       };
       const stakeAmount = BigInt(stake?.stake?.toString() ?? "0");
       const pendingRootClaimAmount = BigInt(stake?.pendingRootClaim?.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 balanceValue = {
@@ -3501,9 +3676,30 @@ var fetchBalances8 = async ({
         type: "locked",
         label: "Pending root claim",
         amount: pendingRootClaimAmount.toString(),
+        // The pending claim is not part of the stake (free amount): on-chain it only becomes
+        // stake once claimed (root_claim_on_subnet). Since it was never included in `free`,
+        // it must not be subtracted from it either: flag it so it does not reduce the staked
+        // position's transferable amount.
+        includeInTransferable: true,
         meta
       };
       const values3 = [balanceValue, pendingRootClaimValue];
+      if (stake?.convictionLock && (convictionLockAmount > 0n || convictionLockConviction > 0n)) {
+        const convictionLockMeta = {
+          ...meta,
+          convictionLock: {
+            type: "conviction-lock",
+            hotkey: stake.convictionLock.hotkey,
+            lockType: stake.convictionLock.lockType
+          }
+        };
+        values3.push({
+          type: "locked",
+          label: getConvictionLockLabel(stake.convictionLock.lockType),
+          amount: convictionLockAmount.toString(),
+          meta: convictionLockMeta
+        });
+      }
       if (hasZeroStake && hasPendingRootClaim) {
         values3.push({
           type: "extra",
@@ -3541,7 +3737,7 @@ var fetchBalances8 = async ({
   }
 };
 var buildStorageCoder = (metadataRpc, pallet, entry) => {
-  const { builder } = parseMetadataRpc4(metadataRpc);
+  const { builder } = parseMetadataRpc5(metadataRpc);
   return builder.buildStorage(pallet, entry);
 };
 var buildRootClaimableStorageCoder = async (_connector, networkId, metadataRpc) => {
@@ -3585,7 +3781,7 @@ var buildRootClaimableQueries = (networkId, hotkeys, storageCoder) => {
       if (!hexValue) {
         return [hotkey, /* @__PURE__ */ new Map()];
       }
-      const decoded = decodeScale2(
+      const decoded = decodeScale3(
         storageCoder,
         hexValue,
         `Failed to decode RootClaimable for hotkey ${hotkey} on ${networkId}`
@@ -3629,7 +3825,7 @@ var buildRootClaimedQueries = (networkId, addressHotkeyNetuidPairs, storageCoder
       if (!hexValue) {
         return [address, hotkey, netuid, 0n];
       }
-      const decoded = decodeScale2(
+      const decoded = decodeScale3(
         storageCoder,
         hexValue,
         `Failed to decode RootClaimed for (netuid=${netuid}, hotkey=${hotkey}, address=${address}) on ${networkId}`
@@ -3688,9 +3884,10 @@ import {
   SubDTaoTokenSchema as SubDTaoTokenSchema2,
   subDTaoTokenId as subDTaoTokenId3
 } from "@talismn/chaindata-provider";
-import { getStorageKeyPrefix as getStorageKeyPrefix2, parseMetadataRpc as parseMetadataRpc5 } from "@talismn/scale";
+import { getStorageKeyPrefix as getStorageKeyPrefix2, parseMetadataRpc as parseMetadataRpc6 } from "@talismn/scale";
 import { isNotNil as isNotNil6 } from "@talismn/util";
 import { fromPairs } from "lodash-es";
+import { Binary as Binary2 } from "polkadot-api";
 var NATIVE_TOKEN_SYMBOLS = {
   "bittensor": "TAO",
   "bittensor-testnet": "testTAO"
@@ -3717,7 +3914,7 @@ var fetchTokens8 = async ({
   return dynamicInfos.filter(isNotNil6).map((info) => {
     const config = tokens.find((t) => t.netuid === info.netuid);
     let symbol = new TextDecoder().decode(Uint8Array.from(info.token_symbol));
-    const subnetName = info.subnet_identity?.subnet_name?.asText() ?? (info.netuid === 0 ? "Root" : `Subnet ${info.netuid}`);
+    const subnetName = (info.subnet_identity?.subnet_name ? Binary2.toText(info.subnet_identity.subnet_name) : void 0) ?? (info.netuid === 0 ? "Root" : `Subnet ${info.netuid}`);
     const name = `SN${info.netuid} | ${subnetName} ${symbol}`;
     if (info.netuid === 0 && NATIVE_TOKEN_SYMBOLS[networkId])
       symbol = NATIVE_TOKEN_SYMBOLS[networkId];
@@ -3742,7 +3939,7 @@ var fetchTokens8 = async ({
   });
 };
 var fetchTransferableTokensMap = async (connector, metadata, networkId) => {
-  const { builder } = parseMetadataRpc5(metadata);
+  const { builder } = parseMetadataRpc6(metadata);
   const transferToggleCodec = builder.buildStorage("SubtensorModule", "TransferToggle");
   const transferToggleKeys = await connector.send(networkId, "state_getKeys", [
     getStorageKeyPrefix2("SubtensorModule", "TransferToggle")
@@ -3764,7 +3961,7 @@ var fetchTransferableTokensMap = async (connector, metadata, networkId) => {
 
 // src/modules/substrate-dtao/getMiniMetadata.ts
 import { MINIMETADATA_VERSION } from "@talismn/chaindata-provider";
-import { compactMetadata, encodeMetadata, parseMetadataRpc as parseMetadataRpc6 } from "@talismn/scale";
+import { compactMetadata, encodeMetadata, parseMetadataRpc as parseMetadataRpc7 } from "@talismn/scale";
 var getMiniMetadata7 = ({
   networkId,
   specVersion,
@@ -3778,7 +3975,7 @@ var getMiniMetadata7 = ({
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { unifiedMetadata } = parseMetadataRpc6(metadataRpc);
+  const { unifiedMetadata } = parseMetadataRpc7(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -3794,16 +3991,21 @@ var getMiniMetadata7 = ({
   };
 };
 var getData = (metadataRpc) => {
-  const { metadata, unifiedMetadata } = parseMetadataRpc6(metadataRpc);
+  const { metadata, unifiedMetadata } = parseMetadataRpc7(metadataRpc);
   const isBittensor = unifiedMetadata.pallets.some(({ name }) => name === "SubtensorModule");
   if (!isBittensor) return null;
   compactMetadata(
     metadata,
-    [{ pallet: "SubtensorModule", items: ["TransferToggle", "RootClaimable", "RootClaimed"] }],
+    [
+      {
+        pallet: "SubtensorModule",
+        items: ["TransferToggle", "RootClaimable", "RootClaimed", "Lock", "DecayingLock"]
+      }
+    ],
     [
       {
         runtimeApi: "StakeInfoRuntimeApi",
-        methods: ["get_stake_info_for_coldkeys"]
+        methods: ["get_stake_info_for_coldkeys", "get_coldkey_lock"]
       },
       {
         runtimeApi: "SubnetInfoRuntimeApi",
@@ -3817,8 +4019,8 @@ var getData = (metadataRpc) => {
 // src/modules/substrate-dtao/getTransferCallData.ts
 import { mergeUint8 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType7, parseSubDTaoTokenId } from "@talismn/chaindata-provider";
-import { parseMetadataRpc as parseMetadataRpc7 } from "@talismn/scale";
-import { Binary } from "polkadot-api";
+import { parseMetadataRpc as parseMetadataRpc8 } from "@talismn/scale";
+import { Binary as Binary3 } from "polkadot-api";
 var getTransferCallData7 = ({
   from: from2,
   to,
@@ -3830,7 +4032,7 @@ var getTransferCallData7 = ({
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE8}.`);
   const { netuid: subnetId, hotkey } = parseSubDTaoTokenId(token.id);
   if (!hotkey) throw new Error(`Missing hotkey`);
-  const { builder } = parseMetadataRpc7(metadataRpc);
+  const { builder } = parseMetadataRpc8(metadataRpc);
   const { codec, location } = builder.buildCall("SubtensorModule", "transfer_stake");
   const args = codec.enc({
     origin_netuid: subnetId,
@@ -3839,10 +4041,10 @@ var getTransferCallData7 = ({
     destination_netuid: subnetId,
     alpha_amount: value
   });
-  const callData = Binary.fromBytes(mergeUint8([new Uint8Array(location), args]));
+  const callData = mergeUint8([new Uint8Array(location), args]);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary3.toHex(callData)
   };
 };
 
@@ -3857,6 +4059,7 @@ var subscribeBalances7 = ({
   miniMetadata
 }) => {
   if (!tokensWithAddresses.length) return of8({ success: [], errors: [] });
+  const balanceDefs = getBalanceDefs(tokensWithAddresses);
   return new Observable8((subscriber) => {
     const abortController = new AbortController();
     const poll = async () => {
@@ -3870,8 +4073,8 @@ var subscribeBalances7 = ({
         });
         if (abortController.signal.aborted) return;
         subscriber.next(balances);
-        setTimeout(poll, SUBSCRIPTION_INTERVAL7);
       } catch (error) {
+        if (abortController.signal.aborted) return;
         log_default.error("Error", {
           module: MODULE_TYPE8,
           networkId,
@@ -3879,8 +4082,17 @@ var subscribeBalances7 = ({
           addressesByToken: tokensWithAddresses,
           error
         });
-        subscriber.error(error);
+        const fetchError = error instanceof Error ? error : new Error(String(error));
+        subscriber.next({
+          success: [],
+          errors: balanceDefs.map((def) => ({
+            tokenId: def.token.id,
+            address: def.address,
+            error: fetchError
+          }))
+        });
       }
+      if (!abortController.signal.aborted) setTimeout(poll, SUBSCRIPTION_INTERVAL7);
     };
     poll();
     return () => {
@@ -4183,9 +4395,9 @@ var Balance = class {
       const totalSupply = extras.find((extra2) => extra2.label === "totalSupply")?.amount ?? "0";
       const reserve0 = extras.find((extra2) => extra2.label === "reserve0")?.amount ?? "0";
       const reserve1 = extras.find((extra2) => extra2.label === "reserve1")?.amount ?? "0";
-      const totalSupplyTokens = BigNumber2(totalSupply).times(10 ** (-1 * decimals));
-      const reserve0Tokens = BigNumber2(reserve0).times(10 ** (-1 * decimals0));
-      const reserve1Tokens = BigNumber2(reserve1).times(10 ** (-1 * decimals1));
+      const totalSupplyTokens = configureBigNumber_default(totalSupply).times(10 ** (-1 * decimals));
+      const reserve0Tokens = configureBigNumber_default(reserve0).times(10 ** (-1 * decimals0));
+      const reserve1Tokens = configureBigNumber_default(reserve1).times(10 ** (-1 * decimals1));
       const rates0Currencies = new Set(Object.keys(rates0));
       const rates1Currencies = new Set(Object.keys(rates1));
       const currencies = [...rates0Currencies].filter((c) => rates1Currencies.has(c));
@@ -4193,7 +4405,7 @@ var Balance = class {
         (currency) => [
           currency,
           // tvl (in a given currency) == reserve0*currencyRate0 + reserve1*currencyRate1
-          BigNumber2.sum(
+          configureBigNumber_default.sum(
             reserve0Tokens.times(rates0[currency]?.price ?? 0),
             reserve1Tokens.times(rates1[currency]?.price ?? 0)
           )
@@ -4584,7 +4796,7 @@ var getMiniMetadata8 = ({
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { unifiedMetadata } = parseMetadataRpc8(metadataRpc);
+  const { unifiedMetadata } = parseMetadataRpc9(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -4600,7 +4812,7 @@ var getMiniMetadata8 = ({
   };
 };
 var getData2 = (metadataRpc) => {
-  const { metadata, unifiedMetadata } = parseMetadataRpc8(metadataRpc);
+  const { metadata, unifiedMetadata } = parseMetadataRpc9(metadataRpc);
   if (!hasStorageItems(unifiedMetadata, "Assets", ["Account", "Asset", "Metadata"])) return null;
   compactMetadata2(metadata, [{ pallet: "Assets", items: ["Account", "Asset", "Metadata"] }]);
   return encodeMetadata2(metadata);
@@ -4609,8 +4821,8 @@ var getData2 = (metadataRpc) => {
 // src/modules/substrate-assets/getTransferCallData.ts
 import { mergeUint8 as mergeUint82 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType8 } from "@talismn/chaindata-provider";
-import { parseMetadataRpc as parseMetadataRpc9 } from "@talismn/scale";
-import { Binary as Binary2, Enum } from "polkadot-api";
+import { parseMetadataRpc as parseMetadataRpc10 } from "@talismn/scale";
+import { Binary as Binary4, Enum } from "polkadot-api";
 var getTransferCallData8 = ({
   from: from2,
   to,
@@ -4621,14 +4833,14 @@ var getTransferCallData8 = ({
 }) => {
   if (!isTokenOfType8(token, MODULE_TYPE7))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE7}.`);
-  const { builder } = parseMetadataRpc9(metadataRpc);
+  const { builder } = parseMetadataRpc10(metadataRpc);
   const method = getTransferMethod(type);
   const { codec, location } = builder.buildCall("Assets", method);
   const args = getEncodedArgs(method, token.assetId, to, value, codec);
-  const callData = Binary2.fromBytes(mergeUint82([new Uint8Array(location), args]));
+  const callData = mergeUint82([new Uint8Array(location), args]);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary4.toHex(callData)
   };
 };
 var getTransferMethod = (type) => {
@@ -4752,7 +4964,7 @@ var MODULE_TYPE9 = SubForeignAssetsTokenSchema.shape.type.value;
 var PLATFORM9 = SubForeignAssetsTokenSchema.shape.platform.value;
 
 // src/modules/substrate-foreignassets/buildQueries.ts
-import { decodeScale as decodeScale3, papiParse } from "@talismn/scale";
+import { decodeScale as decodeScale4, papiParse } from "@talismn/scale";
 import { isNotNil as isNotNil7 } from "@talismn/util";
 var buildQueries2 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
@@ -4775,7 +4987,7 @@ var buildQueries2 = (networkId, balanceDefs, miniMetadata) => {
       return null;
     }
     const decodeResult = (changes) => {
-      const decoded = decodeScale3(
+      const decoded = decodeScale4(
         scaleCoder,
         changes[0],
         `Failed to decode substrate-assets balance on chain ${networkId}`
@@ -4886,8 +5098,9 @@ import {
   SubForeignAssetsTokenSchema as SubForeignAssetsTokenSchema2,
   subForeignAssetTokenId
 } from "@talismn/chaindata-provider";
-import { getStorageKeyPrefix as getStorageKeyPrefix3, papiStringify, parseMetadataRpc as parseMetadataRpc10 } from "@talismn/scale";
+import { getStorageKeyPrefix as getStorageKeyPrefix3, papiStringify, parseMetadataRpc as parseMetadataRpc11 } from "@talismn/scale";
 import { assign as assign8, keyBy as keyBy6, keys as keys2 } from "lodash-es";
+import { Binary as Binary5 } from "polkadot-api";
 var fetchTokens9 = async ({
   networkId,
   tokens,
@@ -4896,7 +5109,7 @@ var fetchTokens9 = async ({
 }) => {
   const anyMiniMetadata = miniMetadata;
   if (!anyMiniMetadata?.data) return [];
-  const { builder } = parseMetadataRpc10(anyMiniMetadata.data);
+  const { builder } = parseMetadataRpc11(anyMiniMetadata.data);
   const assetCodec = builder.buildStorage("ForeignAssets", "Asset");
   const metadataCodec = builder.buildStorage("ForeignAssets", "Metadata");
   const [allAssetStorageKeys, allMetadataStorageKeys] = await Promise.all([
@@ -4931,8 +5144,8 @@ var fetchTokens9 = async ({
         onChainId,
         decimals: metadata.decimals,
         isFrozen: metadata.is_frozen,
-        name: metadata.name?.asText(),
-        symbol: metadata.symbol?.asText()
+        name: metadata.name ? Binary5.toText(metadata.name) : void 0,
+        symbol: metadata.symbol ? Binary5.toText(metadata.symbol) : void 0
       };
     }),
     (a) => a.onChainId
@@ -4970,7 +5183,7 @@ var fetchTokens9 = async ({
 
 // src/modules/substrate-foreignassets/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION4 } from "@talismn/chaindata-provider";
-import { compactMetadata as compactMetadata3, encodeMetadata as encodeMetadata3, parseMetadataRpc as parseMetadataRpc11 } from "@talismn/scale";
+import { compactMetadata as compactMetadata3, encodeMetadata as encodeMetadata3, parseMetadataRpc as parseMetadataRpc12 } from "@talismn/scale";
 var getMiniMetadata9 = ({
   networkId,
   specVersion,
@@ -4984,7 +5197,7 @@ var getMiniMetadata9 = ({
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { unifiedMetadata } = parseMetadataRpc11(metadataRpc);
+  const { unifiedMetadata } = parseMetadataRpc12(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -5000,7 +5213,7 @@ var getMiniMetadata9 = ({
   };
 };
 var getData3 = (metadataRpc) => {
-  const { metadata, unifiedMetadata } = parseMetadataRpc11(metadataRpc);
+  const { metadata, unifiedMetadata } = parseMetadataRpc12(metadataRpc);
   if (!hasStorageItems(unifiedMetadata, "ForeignAssets", ["Account", "Asset", "Metadata"]))
     return null;
   compactMetadata3(metadata, [{ pallet: "ForeignAssets", items: ["Account", "Asset", "Metadata"] }]);
@@ -5010,8 +5223,8 @@ var getData3 = (metadataRpc) => {
 // src/modules/substrate-foreignassets/getTransferCallData.ts
 import { mergeUint8 as mergeUint83 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType9 } from "@talismn/chaindata-provider";
-import { papiParse as papiParse2, parseMetadataRpc as parseMetadataRpc12 } from "@talismn/scale";
-import { Binary as Binary3, Enum as Enum2 } from "polkadot-api";
+import { papiParse as papiParse2, parseMetadataRpc as parseMetadataRpc13 } from "@talismn/scale";
+import { Binary as Binary6, Enum as Enum2 } from "polkadot-api";
 var getTransferCallData9 = ({
   from: from2,
   to,
@@ -5022,14 +5235,14 @@ var getTransferCallData9 = ({
 }) => {
   if (!isTokenOfType9(token, MODULE_TYPE9))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE9}.`);
-  const { builder } = parseMetadataRpc12(metadataRpc);
+  const { builder } = parseMetadataRpc13(metadataRpc);
   const method = getTransferMethod2(type);
   const { codec, location } = builder.buildCall("ForeignAssets", method);
   const args = getEncodedArgs2(method, token.onChainId, to, value, codec);
-  const callData = Binary3.fromBytes(mergeUint83([new Uint8Array(location), args]));
+  const callData = mergeUint83([new Uint8Array(location), args]);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary6.toHex(callData)
   };
 };
 var getTransferMethod2 = (type) => {
@@ -5261,8 +5474,9 @@ import {
   SubHydrationTokenSchema as SubHydrationTokenSchema2,
   subHydrationTokenId
 } from "@talismn/chaindata-provider";
-import { getStorageKeyPrefix as getStorageKeyPrefix4, parseMetadataRpc as parseMetadataRpc13 } from "@talismn/scale";
+import { getStorageKeyPrefix as getStorageKeyPrefix4, parseMetadataRpc as parseMetadataRpc14 } from "@talismn/scale";
 import { assign as assign9, keyBy as keyBy8 } from "lodash-es";
+import { Binary as Binary7 } from "polkadot-api";
 var fetchTokens10 = async ({
   networkId,
   tokens,
@@ -5271,7 +5485,7 @@ var fetchTokens10 = async ({
 }) => {
   const anyMiniMetadata = miniMetadata;
   if (!anyMiniMetadata?.data) return [];
-  const { builder } = parseMetadataRpc13(anyMiniMetadata.data);
+  const { builder } = parseMetadataRpc14(anyMiniMetadata.data);
   const assetsCodec = builder.buildStorage("AssetRegistry", "Assets");
   const allAssetStorageKeys = await connector.send(networkId, "state_getKeys", [
     getStorageKeyPrefix4("AssetRegistry", "Assets")
@@ -5290,8 +5504,8 @@ var fetchTokens10 = async ({
       onChainId,
       assetType: asset.asset_type.type,
       isSufficient: asset.is_sufficient,
-      name: asset.name?.asText(),
-      symbol: asset.symbol?.asText(),
+      name: asset.name ? Binary7.toText(asset.name) : void 0,
+      symbol: asset.symbol ? Binary7.toText(asset.symbol) : void 0,
       decimals: asset.decimals,
       existentialDeposit: asset.existential_deposit.toString()
     };
@@ -5325,7 +5539,7 @@ var fetchTokens10 = async ({
 
 // src/modules/substrate-hydration/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION5 } from "@talismn/chaindata-provider";
-import { compactMetadata as compactMetadata4, encodeMetadata as encodeMetadata4, parseMetadataRpc as parseMetadataRpc14 } from "@talismn/scale";
+import { compactMetadata as compactMetadata4, encodeMetadata as encodeMetadata4, parseMetadataRpc as parseMetadataRpc15 } from "@talismn/scale";
 var getMiniMetadata10 = ({
   networkId,
   specVersion,
@@ -5339,7 +5553,7 @@ var getMiniMetadata10 = ({
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { unifiedMetadata } = parseMetadataRpc14(metadataRpc);
+  const { unifiedMetadata } = parseMetadataRpc15(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -5355,7 +5569,7 @@ var getMiniMetadata10 = ({
   };
 };
 var getData4 = (metadataRpc) => {
-  const { metadata, unifiedMetadata } = parseMetadataRpc14(metadataRpc);
+  const { metadata, unifiedMetadata } = parseMetadataRpc15(metadataRpc);
   if (!hasStorageItem(unifiedMetadata, "AssetRegistry", "Assets") || !hasStorageItem(unifiedMetadata, "Tokens", "Accounts") || !hasRuntimeApi(unifiedMetadata, "CurrenciesApi", "accounts"))
     return null;
   compactMetadata4(
@@ -5379,8 +5593,8 @@ var getData4 = (metadataRpc) => {
 // src/modules/substrate-hydration/getTransferCallData.ts
 import { mergeUint8 as mergeUint84 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType10 } from "@talismn/chaindata-provider";
-import { parseMetadataRpc as parseMetadataRpc15 } from "@talismn/scale";
-import { Binary as Binary4 } from "polkadot-api";
+import { parseMetadataRpc as parseMetadataRpc16 } from "@talismn/scale";
+import { Binary as Binary8 } from "polkadot-api";
 var getTransferCallData10 = ({
   from: from2,
   to,
@@ -5390,17 +5604,17 @@ var getTransferCallData10 = ({
 }) => {
   if (!isTokenOfType10(token, MODULE_TYPE10))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE10}.`);
-  const { builder } = parseMetadataRpc15(metadataRpc);
+  const { builder } = parseMetadataRpc16(metadataRpc);
   const { codec, location } = builder.buildCall("Currencies", "transfer");
   const args = {
     dest: to,
     currency_id: token.onChainId,
     amount: BigInt(value)
   };
-  const callData = Binary4.fromBytes(mergeUint84([new Uint8Array(location), codec.enc(args)]));
+  const callData = mergeUint84([new Uint8Array(location), codec.enc(args)]);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary8.toHex(callData)
   };
 };
 
@@ -5472,8 +5686,9 @@ var MODULE_TYPE11 = SubNativeTokenSchema.shape.type.value;
 var PLATFORM11 = SubNativeTokenSchema.shape.platform.value;
 
 // src/modules/substrate-native/queries/buildBaseQueries.ts
-import { decodeScale as decodeScale4 } from "@talismn/scale";
+import { decodeScale as decodeScale5 } from "@talismn/scale";
 import { isNotNil as isNotNil8 } from "@talismn/util";
+import { Binary as Binary9 } from "polkadot-api";
 
 // src/modules/substrate-native/util/lockTypes.ts
 import upperFirst from "lodash-es/upperFirst";
@@ -5637,7 +5852,7 @@ var buildBaseQueries = (networkId, balanceDefs, miniMetadata) => {
   }).filter(isNotNil8);
 };
 var decodeBaseResult = (coder, value, networkId) => {
-  const decoded = decodeScale4(
+  const decoded = decodeScale5(
     coder,
     value,
     `Failed to decode base native balance on chain ${networkId}`
@@ -5657,22 +5872,25 @@ var decodeBaseResult = (coder, value, networkId) => {
   return newValues;
 };
 var decodeLocksResult = (coder, value, networkId) => {
-  const decoded = decodeScale4(
+  const decoded = decodeScale5(
     coder,
     value,
     `Failed to decode lock on chain ${networkId}`
   );
-  const locksQueryLocks = decoded?.map?.((lock) => ({
-    type: "locked",
-    source: "substrate-native-locks",
-    label: getLockedType(lock?.id?.asText?.()),
-    meta: { id: lock?.id?.asText?.() },
-    amount: (lock?.amount ?? 0n).toString()
-  })) ?? [];
+  const locksQueryLocks = decoded?.map?.((lock) => {
+    const id = lock?.id ? Binary9.toText(Binary9.fromHex(lock.id)) : void 0;
+    return {
+      type: "locked",
+      source: "substrate-native-locks",
+      label: getLockedType(id),
+      meta: { id },
+      amount: (lock?.amount ?? 0n).toString()
+    };
+  }) ?? [];
   return locksQueryLocks;
 };
 var decodeFreezesResult = (coder, value, networkId) => {
-  const decoded = decodeScale4(
+  const decoded = decodeScale5(
     coder,
     value,
     `Failed to decode freeze on chain ${networkId}`
@@ -5686,7 +5904,7 @@ var decodeFreezesResult = (coder, value, networkId) => {
   return freezesValues;
 };
 var decodeHoldsResult = (coder, value, networkId) => {
-  const decoded = decodeScale4(
+  const decoded = decodeScale5(
     coder,
     value,
     `Failed to decode holds on chain ${networkId}`
@@ -5702,7 +5920,7 @@ var decodeHoldsResult = (coder, value, networkId) => {
   return holdsValues;
 };
 var decodeStakingLedgerResult = (coder, value, networkId) => {
-  const decoded = decodeScale4(
+  const decoded = decodeScale5(
     coder,
     value,
     `Failed to decode unbonding query on chain ${networkId}`
@@ -5719,7 +5937,7 @@ var decodeStakingLedgerResult = (coder, value, networkId) => {
   return stakingLedgerResults;
 };
 var decodePoolMemberResult = (coder, value, networkId) => {
-  const decoded = decodeScale4(
+  const decoded = decodeScale5(
     coder,
     value,
     `Failed to decode poolMembers on chain ${networkId}`
@@ -5741,7 +5959,8 @@ var decodePoolMemberResult = (coder, value, networkId) => {
 };
 
 // src/modules/substrate-native/queries/buildNomPoolQueries.ts
-import { decodeScale as decodeScale5 } from "@talismn/scale";
+import { decodeScale as decodeScale6 } from "@talismn/scale";
+import { Binary as Binary10 } from "polkadot-api";
 
 // src/modules/substrate-native/util/nompoolAccountId.ts
 import { mergeUint8 as mergeUint85 } from "@polkadot-api/utils";
@@ -5834,7 +6053,7 @@ var getNomPoolCoders = (networkId, miniMetadata) => {
   });
 };
 var decodePoolPoints = (coder, value, networkId) => {
-  const decoded = decodeScale5(
+  const decoded = decodeScale6(
     coder,
     value,
     `Failed to decode bondedPools on chain ${networkId}`
@@ -5842,7 +6061,7 @@ var decodePoolPoints = (coder, value, networkId) => {
   return { poolPoints: decoded?.points.toString() };
 };
 var decodePoolStake = (coder, value, networkId) => {
-  const decoded = decodeScale5(
+  const decoded = decodeScale6(
     coder,
     value,
     `Failed to decode ledger on chain ${networkId}`
@@ -5850,12 +6069,12 @@ var decodePoolStake = (coder, value, networkId) => {
   return { poolTotalActiveStake: decoded?.active.toString() };
 };
 var decodePoolMeta = (coder, value, networkId) => {
-  const decoded = decodeScale5(
+  const decoded = decodeScale6(
     coder,
     value,
     `Failed to decode metadata on chain ${networkId}`
   );
-  const metadata = decoded?.asText();
+  const metadata = decoded ? Binary10.toText(decoded) : void 0;
   return { metadata };
 };
 var getNomPoolStateKeys = (coders, nomPoolMemberInfo, extra) => {
@@ -5972,7 +6191,8 @@ var getChainProperties = async (connector, networkId) => {
 
 // src/modules/substrate-native/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION6 } from "@talismn/chaindata-provider";
-import { compactMetadata as compactMetadata5, encodeMetadata as encodeMetadata5, parseMetadataRpc as parseMetadataRpc16 } from "@talismn/scale";
+import { compactMetadata as compactMetadata5, encodeMetadata as encodeMetadata5, parseMetadataRpc as parseMetadataRpc17 } from "@talismn/scale";
+import { Binary as Binary11 } from "polkadot-api";
 var getMiniMetadata11 = ({ networkId, specVersion, metadataRpc, config }) => {
   const source = MODULE_TYPE11;
   const chainId = networkId;
@@ -5982,7 +6202,7 @@ var getMiniMetadata11 = ({ networkId, specVersion, metadataRpc, config }) => {
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { metadata, unifiedMetadata } = parseMetadataRpc16(metadataRpc);
+  const { metadata, unifiedMetadata } = parseMetadataRpc17(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -6002,11 +6222,12 @@ var getMiniMetadata11 = ({ networkId, specVersion, metadataRpc, config }) => {
     "Balances",
     "ExistentialDeposit"
   )?.toString();
-  const nominationPoolsPalletId = tryGetConstantValue(
+  const nominationPoolsPalletIdHex = tryGetConstantValue(
     metadataRpc,
     "NominationPools",
     "PalletId"
-  )?.asText();
+  );
+  const nominationPoolsPalletId = nominationPoolsPalletIdHex ? Binary11.toText(Binary11.fromHex(nominationPoolsPalletIdHex)) : void 0;
   const hasFreezesItem = Boolean(
     unifiedMetadata.pallets.find(({ name }) => name === "Balances")?.storage?.items.find(({ name }) => name === "Freezes")
   );
@@ -6036,9 +6257,9 @@ var getMiniMetadata11 = ({ networkId, specVersion, metadataRpc, config }) => {
 import { mergeUint8 as mergeUint86 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType11 } from "@talismn/chaindata-provider";
 import {
-  parseMetadataRpc as parseMetadataRpc17
+  parseMetadataRpc as parseMetadataRpc18
 } from "@talismn/scale";
-import { Binary as Binary5, Enum as Enum3 } from "polkadot-api";
+import { Binary as Binary12, Enum as Enum3 } from "polkadot-api";
 var getTransferCallData11 = ({
   from: from2,
   to,
@@ -6049,14 +6270,14 @@ var getTransferCallData11 = ({
 }) => {
   if (!isTokenOfType11(token, MODULE_TYPE11))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE11}.`);
-  const { unifiedMetadata, lookupFn, builder } = parseMetadataRpc17(metadataRpc);
+  const { unifiedMetadata, lookupFn, builder } = parseMetadataRpc18(metadataRpc);
   const method = getTransferMethod3(type, unifiedMetadata, lookupFn);
   const { codec, location } = builder.buildCall("Balances", method);
   const args = getEncodedArgs3(method, to, value, codec);
-  const callData = Binary5.fromBytes(mergeUint86([new Uint8Array(location), args]));
+  const callData = mergeUint86([new Uint8Array(location), args]);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary12.toHex(callData)
   };
 };
 var getTransferMethod3 = (type, unifiedMetadata, lookupFn) => {
@@ -7352,7 +7573,7 @@ var fetchTokens12 = async ({
 
 // src/modules/substrate-psp22/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION7 } from "@talismn/chaindata-provider";
-import { parseMetadataRpc as parseMetadataRpc18 } from "@talismn/scale";
+import { parseMetadataRpc as parseMetadataRpc19 } from "@talismn/scale";
 var getMiniMetadata12 = ({
   networkId,
   specVersion,
@@ -7366,7 +7587,7 @@ var getMiniMetadata12 = ({
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { unifiedMetadata } = parseMetadataRpc18(metadataRpc);
+  const { unifiedMetadata } = parseMetadataRpc19(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -7387,13 +7608,13 @@ import { Abi as Abi3 } from "@polkadot/api-contract";
 import { TypeRegistry as TypeRegistry3 } from "@polkadot/types";
 import { mergeUint8 as mergeUint87 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType12, parseTokenId as parseTokenId5 } from "@talismn/chaindata-provider";
-import { parseMetadataRpc as parseMetadataRpc19 } from "@talismn/scale";
-import { Binary as Binary6, Enum as Enum4 } from "polkadot-api";
+import { parseMetadataRpc as parseMetadataRpc20 } from "@talismn/scale";
+import { Binary as Binary13, Enum as Enum4 } from "polkadot-api";
 var getTransferCallData12 = async ({ from: from2, to, value, token, metadataRpc, connector }) => {
   if (!isTokenOfType12(token, MODULE_TYPE12))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE12}.`);
   const networkId = parseTokenId5(token.id).networkId;
-  const { builder } = parseMetadataRpc19(metadataRpc);
+  const { builder } = parseMetadataRpc20(metadataRpc);
   const { codec, location } = builder.buildCall("Contracts", "call");
   const Psp22Abi = new Abi3(psp22_default);
   const registry = new TypeRegistry3();
@@ -7413,12 +7634,12 @@ var getTransferCallData12 = async ({ from: from2, to, value, token, metadataRpc,
       proof_size: dryRunResult.gasRequired.proofSize.toBigInt()
     },
     storage_deposit_limit: dryRunResult.storageDeposit.isCharge ? dryRunResult.storageDeposit.asCharge.toBigInt() : null,
-    data: Binary6.fromHex(hexData)
+    data: Binary13.fromHex(hexData)
   });
-  const callData = Binary6.fromBytes(mergeUint87([new Uint8Array(location), args]));
+  const callData = mergeUint87([new Uint8Array(location), args]);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary13.toHex(callData)
   };
 };
 
@@ -7490,7 +7711,7 @@ var MODULE_TYPE13 = SubTokensTokenSchema.shape.type.value;
 var PLATFORM13 = SubTokensTokenSchema.shape.platform.value;
 
 // src/modules/substrate-tokens/buildQueries.ts
-import { decodeScale as decodeScale6, papiParse as papiParse3 } from "@talismn/scale";
+import { decodeScale as decodeScale7, papiParse as papiParse3 } from "@talismn/scale";
 import { isNotNil as isNotNil9 } from "@talismn/util";
 var buildQueries3 = (networkId, balanceDefs, miniMetadata) => {
   const networkStorageCoders = buildNetworkStorageCoders(networkId, miniMetadata, {
@@ -7513,7 +7734,7 @@ var buildQueries3 = (networkId, balanceDefs, miniMetadata) => {
       return null;
     }
     const decodeResult = (changes) => {
-      const decoded = decodeScale6(
+      const decoded = decodeScale7(
         scaleCoder,
         changes[0],
         `Failed to decode substrate-tokens balance on chain ${networkId}`
@@ -7637,7 +7858,7 @@ var fetchTokens13 = async ({
 
 // src/modules/substrate-tokens/getMiniMetadata.ts
 import { MINIMETADATA_VERSION as MINIMETADATA_VERSION8 } from "@talismn/chaindata-provider";
-import { compactMetadata as compactMetadata6, encodeMetadata as encodeMetadata6, parseMetadataRpc as parseMetadataRpc20 } from "@talismn/scale";
+import { compactMetadata as compactMetadata6, encodeMetadata as encodeMetadata6, parseMetadataRpc as parseMetadataRpc21 } from "@talismn/scale";
 var getMiniMetadata13 = ({ networkId, specVersion, metadataRpc, config }) => {
   const source = MODULE_TYPE13;
   const chainId = networkId;
@@ -7647,7 +7868,7 @@ var getMiniMetadata13 = ({ networkId, specVersion, metadataRpc, config }) => {
       `specVersion mismatch: expected ${specVersion}, metadata got ${systemVersion.spec_version}`
     );
   const id = deriveMiniMetadataId({ source, chainId, specVersion });
-  const { unifiedMetadata } = parseMetadataRpc20(metadataRpc);
+  const { unifiedMetadata } = parseMetadataRpc21(metadataRpc);
   if (unifiedMetadata.version < 14)
     throw new Error(
       `Unsupported metadata version: ${unifiedMetadata.version}. Minimum required is 14.`
@@ -7664,7 +7885,7 @@ var getMiniMetadata13 = ({ networkId, specVersion, metadataRpc, config }) => {
   };
 };
 var getData5 = (metadataRpc, pallet) => {
-  const { metadata, unifiedMetadata } = parseMetadataRpc20(metadataRpc);
+  const { metadata, unifiedMetadata } = parseMetadataRpc21(metadataRpc);
   if (!hasStorageItems(unifiedMetadata, pallet, ["Accounts"])) return null;
   compactMetadata6(metadata, [{ pallet, items: ["Accounts"] }]);
   return encodeMetadata6(metadata);
@@ -7673,17 +7894,17 @@ var getData5 = (metadataRpc, pallet) => {
 // src/modules/substrate-tokens/getTransferCallData.ts
 import { mergeUint8 as mergeUint88 } from "@polkadot-api/utils";
 import { isTokenOfType as isTokenOfType13 } from "@talismn/chaindata-provider";
-import { papiParse as papiParse4, parseMetadataRpc as parseMetadataRpc21 } from "@talismn/scale";
-import { Binary as Binary7, Enum as Enum5 } from "polkadot-api";
+import { papiParse as papiParse4, parseMetadataRpc as parseMetadataRpc22 } from "@talismn/scale";
+import { Binary as Binary14, Enum as Enum5 } from "polkadot-api";
 var getTransferCallData13 = ({ from: from2, to, value, token, type, metadataRpc, config }) => {
   if (!isTokenOfType13(token, MODULE_TYPE13))
     throw new Error(`Token type ${token.type} is not ${MODULE_TYPE13}.`);
-  const { builder } = parseMetadataRpc21(metadataRpc);
+  const { builder } = parseMetadataRpc22(metadataRpc);
   const options = getCallDataOptions(to, token, value, type, config);
   const callData = getCallDataFromOptions(builder, options);
   return {
     address: from2,
-    method: callData.asHex()
+    method: Binary14.toHex(callData)
   };
 };
 var getTransferMethod4 = (type) => {
@@ -7707,7 +7928,7 @@ var getCallDataFromOptions = (builder, options) => {
 };
 var buildCallData = (builder, pallet, method, args) => {
   const { location, codec } = builder.buildCall(pallet, method);
-  return Binary7.fromBytes(mergeUint88([new Uint8Array(location), codec.enc(args)]));
+  return mergeUint88([new Uint8Array(location), codec.enc(args)]);
 };
 var getCallDataOptions = (to, token, value, type, config) => {
   const onChainId = papiParse4(token.onChainId);
@@ -8117,8 +8338,14 @@ var BalancesProvider = class {
           map6(
             (results) => ({
               status: "live",
-              // exclude zero balances
-              balances: results.success.filter((b) => new Balance(b).total.planck > 0n),
+              // exclude zero balances, but keep balances that only hold a lock
+              // (eg dtao conviction locks, reported on the subnet's base token — including
+              // zero-mass "ghost" locks with residual conviction, which still pin the hotkey
+              // of future lock_stake calls)
+              balances: results.success.filter((b) => {
+                const balance = new Balance(b);
+                return balance.total.planck > 0n || balance.locks.some((lock) => lock.amount.planck > 0n) || !!findDTaoConvictionLock(balance.locks);
+              }),
               failedBalanceIds: results.errors.map(
                 ({ tokenId, address }) => getBalanceId({ tokenId, address })
               )
@@ -8505,7 +8732,9 @@ export {
   excludeFromTransferableAmount,
   filterBaseLocks,
   filterMirrorTokens,
+  findDTaoConvictionLock,
   getBalanceId,
+  getConvictionLockLabel,
   getDTaoTokenRates,
   getLockTitle,
   getLockedType,
@@ -8513,6 +8742,7 @@ export {
   getValueId,
   includeInTotalExtraAmount,
   taoToAlpha,
+  taoToAlphaCeil,
   uniswapV2PairAbi
 };
 //# sourceMappingURL=index.mjs.map