@talismn/balances 0.8.1 → 0.9.0

package/dist/declarations/src/BalanceModule.d.ts

@@ -37,7 +37,7 @@ export type Hydrate = {
 export type NewBalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> = (hydrate: Hydrate) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
 export interface BalanceModule<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams> {
 }
-export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = undefined, TModuleConfig extends ExtendableModuleConfig = undefined, TTransferParams extends ExtendableTransferParams = undefined>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
+export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig, TTransferParams>;
 interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends SelectableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig, TTransferParams extends ExtendableTransferParams = DefaultTransferParams> extends BalanceModuleCommon<TModuleType, TTokenType, TTransferParams> {
     /** Pre-processes any substrate chain metadata required by this module ahead of time */
     fetchSubstrateChainMeta(chainId: ChainId, moduleConfig?: TModuleConfig, metadataRpc?: `0x${string}`, systemProperties?: Record<string, any>): Promise<TChainMeta | null>;

package/dist/declarations/src/modules/SubstrateNativeModule/util/subtensor.d.ts

@@ -1,56 +1,20 @@
+import type { bittensor } from "@polkadot-api/descriptors";
+export type GetStakeInfoForColdkeyParams = (typeof bittensor)["descriptors"]["apis"]["StakeInfoRuntimeApi"]["get_stake_info_for_coldkey"][0];
+export type GetStakeInfoForColdkeyResult = (typeof bittensor)["descriptors"]["apis"]["StakeInfoRuntimeApi"]["get_stake_info_for_coldkey"][1];
+export type GetDynamicInfoParams = (typeof bittensor)["descriptors"]["apis"]["SubnetInfoRuntimeApi"]["get_dynamic_info"][0];
+export type GetDynamicInfoResult = (typeof bittensor)["descriptors"]["apis"]["SubnetInfoRuntimeApi"]["get_dynamic_info"][1];
 export declare const SUBTENSOR_ROOT_NETUID = 0;
 export declare const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = 1000000n;
 export declare const SCALE_FACTOR: bigint;
 export declare const ONE_ALPHA_TOKEN: bigint;
-export declare const BITTENSOR_TESTNET_CHAIN_ID = "bittensor-testnet";
-export declare const EncodeParams_GetStakeInfoForColdkey: (address: string) => string;
-export declare const DecodeResult_GetStakeInfoForColdkey: (result: string) => {
-    hotkey: import("polkadot-api").SS58String;
-    coldkey: import("polkadot-api").SS58String;
-    netuid: number | bigint;
-    stake: number | bigint;
-    locked: number | bigint;
-    emission: number | bigint;
-    tao_emission: number | bigint;
-    drain: number | bigint;
-    isRegistered: boolean;
-}[];
-/** Encoding/decoding for GetStakeDynamicInfo */
-export declare const EncodeParams_GetDynamicInfo: (netuid: number) => string;
-export type DynamicInfoType = ReturnType<typeof DecodeResult_GetDynamicInfo>;
-export declare const DecodeResult_GetDynamicInfo: (result: string) => {
-    netuid: number;
-    tokenSymbol: string;
-    subnetIdentity: Record<string, string>;
-    taoIn: bigint;
-    alphaIn: bigint;
-    subnetName: string;
-    ownerHotkey: import("polkadot-api").SS58String;
-    ownerColdkey: import("polkadot-api").SS58String;
-    tempo: number | bigint;
-    lastStep: number | bigint;
-    blocksSinceLastStep: number | bigint;
-    emission: number | bigint;
-    alphaOut: number | bigint;
-    alphaOutEmission: number | bigint;
-    alphaInEmission: number | bigint;
-    taoInEmission: number | bigint;
-    pendingAlphaEmission: number | bigint;
-    pendingRootEmission: number | bigint;
-    subnetVolume: number | bigint;
-    networkRegisteredAt: number | bigint;
-    movingPrice: {
-        bits: number | bigint;
-    };
-};
 export declare const calculateAlphaPrice: ({ dynamicInfo, }: {
-    dynamicInfo: DynamicInfoType | void | null;
+    dynamicInfo: GetDynamicInfoResult | null | undefined;
 }) => bigint;
 export declare const calculateTaoAmountFromAlpha: ({ alphaPrice, alphaStaked, }: {
     alphaPrice: bigint;
     alphaStaked: bigint;
 }) => bigint;
 export declare const calculateTaoFromDynamicInfo: ({ dynamicInfo, alphaStaked, }: {
-    dynamicInfo: DynamicInfoType | void | null;
+    dynamicInfo: GetDynamicInfoResult | null | undefined;
     alphaStaked: bigint;
 }) => bigint;

package/dist/declarations/src/modules/util/buildStorageCoders.d.ts

@@ -18,9 +18,11 @@ export declare const buildStorageCoders: <TBalanceModule extends AnyNewBalanceMo
     moduleType: InferModuleType<TBalanceModule>;
     coders: TCoders;
 }) => Map<string, { [Property in keyof TCoders]: {
+    keys: {
+        enc: (...args: any[]) => string;
+        dec: (value: string) => any[];
+    };
+    value: import("@talismn/scale").Codec<any>;
     len: number;
-    fallback: unknown;
-    enc: (...args: any[]) => string;
-    dec: import("scale-ts").Decoder<unknown>;
-    keyDecoder: (value: string) => any[];
+    fallback: any;
 } | undefined; }>;

package/dist/declarations/src/modules/util/storageCompression.d.ts

@@ -5,5 +5,5 @@ export declare const configureStore: (dbTable?: Table) => {
     persistData: (balances: StoredBalanceJson[]) => Promise<void>;
     retrieveData: () => Promise<StoredBalanceJson[]>;
 };
-export declare const compress: (balances: StoredBalanceJson[]) => Uint8Array;
+export declare const compress: (balances: StoredBalanceJson[]) => Uint8Array<ArrayBufferLike>;
 export declare const decompress: (data: Uint8Array | ArrayBuffer) => StoredBalanceJson[];

package/dist/declarations/src/types/balances.d.ts

@@ -96,11 +96,7 @@ export declare class Balances {
      */
     remove: (ids: string[] | string) => Balances;
     get each(): Balance[];
-    /**
-     * Get an array of balances in this collection, sorted by chain sortIndex.
-     *
-     * @returns A sorted array of the balances in this collection.
-     */
+    /** @deprecated use each instead */
     get sorted(): Balance[];
     /**
      * Get the number of balances in this collection.

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

@@ -22,6 +22,7 @@ var groupBy = require('lodash/groupBy');
 var utils = require('@polkadot-api/utils');
 var polkadotApi = require('polkadot-api');
 var chainConnector = require('@talismn/chain-connector');
+var sapi = require('@talismn/sapi');
 var upperFirst = require('lodash/upperFirst');
 var apiContract = require('@polkadot/api-contract');
 
@@ -108,88 +109,7 @@ class EvmTokenFetcher {
 }
 
 var packageJson = {
-	name: "@talismn/balances",
-	version: "0.8.1",
-	author: "Talisman",
-	homepage: "https://talisman.xyz",
-	license: "GPL-3.0-or-later",
-	publishConfig: {
-		access: "public"
-	},
-	repository: {
-		directory: "packages/balances",
-		type: "git",
-		url: "https://github.com/talismansociety/talisman.git"
-	},
-	main: "dist/talismn-balances.cjs.js",
-	module: "dist/talismn-balances.esm.js",
-	files: [
-		"/dist",
-		"/plugins"
-	],
-	engines: {
-		node: ">=18"
-	},
-	scripts: {
-		test: "jest",
-		lint: "eslint src --max-warnings 0",
-		clean: "rm -rf dist plugins/dist .turbo node_modules"
-	},
-	dependencies: {
-		"@polkadot-api/utils": "^0.1.2",
-		"@supercharge/promise-pool": "^3.2.0",
-		"@talismn/chain-connector": "workspace:*",
-		"@talismn/chain-connector-evm": "workspace:*",
-		"@talismn/chaindata-provider": "workspace:*",
-		"@talismn/scale": "workspace:*",
-		"@talismn/token-rates": "workspace:*",
-		"@talismn/util": "workspace:*",
-		anylogger: "^1.0.11",
-		"bignumber.js": "^9.1.2",
-		dexie: "^4.0.9",
-		lodash: "4.17.21",
-		pako: "^2.1.0",
-		"polkadot-api": "1.7.6",
-		rxjs: "^7.8.1",
-		"scale-ts": "^1.6.1",
-		viem: "^2.21.34"
-	},
-	devDependencies: {
-		"@polkadot/api-contract": "15.8.1",
-		"@polkadot/types": "15.8.1",
-		"@polkadot/util": "13.4.3",
-		"@polkadot/util-crypto": "13.4.3",
-		"@substrate/txwrapper-core": "7.5.3",
-		"@talismn/eslint-config": "workspace:*",
-		"@talismn/tsconfig": "workspace:*",
-		"@types/jest": "^29.5.14",
-		"@types/lodash": "^4.17.12",
-		"@types/pako": "^2.0.3",
-		eslint: "^8.57.1",
-		jest: "^29.7.0",
-		"ts-jest": "^29.2.5",
-		typescript: "^5.6.3"
-	},
-	peerDependencies: {
-		"@polkadot/api-contract": "*",
-		"@polkadot/types": "*",
-		"@polkadot/util": "*",
-		"@polkadot/util-crypto": "*",
-		"@substrate/txwrapper-core": "*"
-	},
-	preconstruct: {
-		entrypoints: [
-			"index.ts",
-			"plugins.ts"
-		]
-	},
-	eslintConfig: {
-		root: true,
-		"extends": [
-			"@talismn/eslint-config/base"
-		]
-	}
-};
+	name: "@talismn/balances"};
 
 var log = anylogger__default.default(packageJson.name);
 
@@ -375,13 +295,9 @@ class Balances {
     return [...this];
   }
 
-  /**
-   * Get an array of balances in this collection, sorted by chain sortIndex.
-   *
-   * @returns A sorted array of the balances in this collection.
-   */
+  /** @deprecated use each instead */
   get sorted() {
-    return [...this].sort((a, b) => ((a.chain || a.evmNetwork)?.sortIndex ?? Number.MAX_SAFE_INTEGER) - ((b.chain || b.evmNetwork)?.sortIndex ?? Number.MAX_SAFE_INTEGER));
+    return this.each;
   }
 
   /**
@@ -413,7 +329,7 @@ const getBalanceId = balance => {
     tokenId
   } = balance;
   const locationId = isBalanceEvm(balance) ? balance.evmNetworkId : balance.chainId;
-  return [source, address, locationId, tokenId].filter(Boolean).join("::");
+  return [source, address, locationId, tokenId].filter(util.isTruthy).join("::");
 };
 
 /**
@@ -1055,7 +971,7 @@ const upgradeBalancesDataBlob = async tx => {
       ...stuffToKeep
     } = balance;
     return stuffToKeep;
-  }).filter(Boolean);
+  }).filter(util.isTruthy);
   const output = pako__default.default.deflate(JSON.stringify(migratedData));
   // now write the compressed data back to the db and clear the old one
   await tx.table("balancesBlob").put({
@@ -1796,7 +1712,7 @@ const fetchBalances$3 = async (evmChainConnector, tokenAddressesByNetwork, erc20
     const balances = await getEvmTokenBalances(publicClient, networkParams, result.errors, erc20Aggregators[evmNetworkId]);
 
     // consider only non null balances in the results
-    result.results.push(...balances.filter(Boolean).map((free, i) => ({
+    result.results.push(...balances.filter(util.isTruthy).map((free, i) => ({
       source: "evm-erc20",
       status: "live",
       address: networkParams[i].address,
@@ -3309,7 +3225,7 @@ const SubAssetsModule = hydrate => {
           const assetStateKey = tryEncode(assetCoder, BigInt(assetId)) ?? tryEncode(assetCoder, assetId);
           const metadataStateKey = tryEncode(metadataCoder, BigInt(assetId)) ?? tryEncode(metadataCoder, assetId);
           if (assetStateKey === null || metadataStateKey === null) throw new Error(`Failed to encode stateKey for asset ${assetId} on chain ${chainId}`);
-          const [assetsAsset, assetsMetadata] = await Promise.all([chainConnector.send(chainId, "state_getStorage", [assetStateKey]).then(result => assetCoder.dec(result) ?? null), chainConnector.send(chainId, "state_getStorage", [metadataStateKey]).then(result => metadataCoder.dec(result) ?? null)]);
+          const [assetsAsset, assetsMetadata] = await Promise.all([chainConnector.send(chainId, "state_getStorage", [assetStateKey]).then(result => assetCoder.value.dec(result) ?? null), chainConnector.send(chainId, "state_getStorage", [metadataStateKey]).then(result => metadataCoder.value.dec(result) ?? null)]);
           const existentialDeposit = assetsAsset?.min_balance?.toString?.() ?? "0";
           const symbol = assetsMetadata?.symbol?.asText?.() ?? "Unit";
           const decimals = assetsMetadata?.decimals ?? 0;
@@ -3476,15 +3392,9 @@ async function buildQueries$4(chaindataProvider, addressesByToken) {
 
         const decoded = scale.decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${chainId}`) ?? {
           balance: 0n,
-          is_frozen: false,
-          reason: {
-            type: "Sufficient"
-          },
           status: {
             type: "Liquid"
-          },
-          extra: undefined
-        };
+          }};
         const isFrozen = decoded?.status?.type === "Frozen";
         const amount = (decoded?.balance ?? 0n).toString();
 
@@ -3536,7 +3446,7 @@ async function buildQueries$4(chaindataProvider, addressesByToken) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const tryEncode = (scaleCoder, ...args) => {
   try {
-    return scaleCoder?.enc?.(...args);
+    return scaleCoder?.keys?.enc?.(...args);
   } catch {
     return null;
   }
@@ -3607,11 +3517,11 @@ const SubEquilibriumModule = hydrate => {
       try {
         const scaleBuilder = scale.getDynamicBuilder(scale.getLookupFn(metadata));
         const assetsCoder = scaleBuilder.buildStorage("EqAssets", "Assets");
-        const stateKey = assetsCoder.enc();
+        const stateKey = assetsCoder.keys.enc();
 
         /** NOTE: Just a guideline, the RPC can return whatever it wants */
 
-        const assetsResult = await chainConnector.send(chainId, "state_getStorage", [stateKey]).then(result => assetsCoder.dec(result) ?? null);
+        const assetsResult = await chainConnector.send(chainId, "state_getStorage", [stateKey]).then(result => assetsCoder.value.dec(result) ?? null);
         const tokens = (Array.isArray(assetsResult) ? assetsResult : []).flatMap(asset => {
           if (!asset) return [];
           if (!asset?.id) return [];
@@ -3896,9 +3806,9 @@ const SubForeignAssetsModule = hydrate => {
             }
           })();
           if (onChainId === undefined) continue;
-          const assetStateKey = assetCoder.enc(onChainId);
-          const metadataStateKey = metadataCoder.enc(onChainId);
-          const [assetsAsset, assetsMetadata] = await Promise.all([chainConnector.send(chainId, "state_getStorage", [assetStateKey]).then(result => assetCoder.dec(result) ?? null), chainConnector.send(chainId, "state_getStorage", [metadataStateKey]).then(result => metadataCoder.dec(result) ?? null)]);
+          const assetStateKey = assetCoder.keys.enc(onChainId);
+          const metadataStateKey = metadataCoder.keys.enc(onChainId);
+          const [assetsAsset, assetsMetadata] = await Promise.all([chainConnector.send(chainId, "state_getStorage", [assetStateKey]).then(result => assetCoder.value.dec(result) ?? null), chainConnector.send(chainId, "state_getStorage", [metadataStateKey]).then(result => metadataCoder.value.dec(result) ?? null)]);
           const existentialDeposit = assetsAsset?.min_balance?.toString?.() ?? "0";
           const symbol = assetsMetadata?.symbol?.asText?.() ?? "Unit";
           const decimals = assetsMetadata?.decimals ?? 0;
@@ -4058,15 +3968,9 @@ async function buildQueries$2(chaindataProvider, addressesByToken) {
 
         const decoded = scale.decodeScale(scaleCoder, change, `Failed to decode substrate-foreignassets balance on chain ${chainId}`) ?? {
           balance: 0n,
-          is_frozen: false,
-          reason: {
-            type: "Sufficient"
-          },
           status: {
             type: "Liquid"
-          },
-          extra: undefined
-        };
+          }};
         const isFrozen = decoded?.status?.type === "Frozen";
         const amount = (decoded?.balance ?? 0n).toString();
 
@@ -4129,7 +4033,7 @@ async function subscribeBase(queries, chainConnector, callback) {
  *     <TArgs, TResult>(...arguments: TArgs, callback: SubscriptionCallback<TResult>) => UnsubscribeFn
  */
 const asObservable = handler => (...args) => new rxjs.Observable(subscriber => {
-  const callback = (error, result) => error ? subscriber.error(error) : subscriber.next(result);
+  const callback = (error, result) => error || result === undefined ? subscriber.error(error) : subscriber.next(result);
   const unsubscribe = handler(...args, callback);
   return unsubscribe;
 });
@@ -4675,7 +4579,7 @@ async function subscribeNompoolStaking(chaindataProvider, chainConnector, addres
               }
             }]
           };
-        }).filter(Boolean);
+        }).filter(util.isNotNil);
         if (balances.length > 0) callback(null, balances);
       },
       error: error => callback(error)
@@ -4690,113 +4594,17 @@ const SUBTENSOR_MIN_STAKE_AMOUNT_PLANK = 1000000n;
 const TAO_DECIMALS = 9n;
 const SCALE_FACTOR = 10n ** TAO_DECIMALS; // Equivalent to 10e9 for precision
 const ONE_ALPHA_TOKEN = SCALE_FACTOR;
-const BITTENSOR_TESTNET_CHAIN_ID = "bittensor-testnet";
-const BittensorAccountPrefix = 42;
-const BittensorAccountId = polkadotApi.AccountId(BittensorAccountPrefix);
-
-/** For encoding/decoding the GetStakeInfoForColdkey runtime api *after* they added the netuid parameter */
-const StakeInfo = scaleTs.Struct({
-  hotkey: BittensorAccountId,
-  coldkey: BittensorAccountId,
-  netuid: scaleTs.compact,
-  stake: scaleTs.compact,
-  locked: scaleTs.compact,
-  emission: scaleTs.compact,
-  tao_emission: scaleTs.compact,
-  drain: scaleTs.compact,
-  isRegistered: scaleTs.bool
-});
-const EncodeParams_GetStakeInfoForColdkey = address => utils.toHex(BittensorAccountId.enc(address));
-const DecodeResult_GetStakeInfoForColdkey = result => scaleTs.Vector(StakeInfo).dec(result);
-/** Encoding/decoding for GetStakeDynamicInfo */
-const EncodeParams_GetDynamicInfo = netuid => {
-  if (netuid < 0 || netuid > 65535) {
-    throw new Error("netuid must be a valid u16 (0-65535)");
-  }
-
-  // Convert the number to a Uint8Array (LE encoding)
-  const encoded = new Uint8Array(2);
-  encoded[0] = netuid & 0xff; // Lower byte
-  encoded[1] = netuid >> 8 & 0xff; // Upper byte
-
-  // Convert to hex string
-  return utils.toHex(encoded);
-};
-/** I96F32 representation (Fixed-Point) */
-const I96F32 = scaleTs.Struct({
-  bits: scaleTs.compact
-});
-const SubnetIdentityV2 = scaleTs.Struct({
-  subnetName: scaleTs.Bytes(),
-  githubRepo: scaleTs.Bytes(),
-  subnetContact: scaleTs.Bytes(),
-  subnetUrl: scaleTs.Bytes(),
-  discord: scaleTs.Bytes(),
-  description: scaleTs.Bytes()
-});
-const DynamicInfo = scaleTs.Struct({
-  netuid: scaleTs.compact,
-  ownerHotkey: BittensorAccountId,
-  ownerColdkey: BittensorAccountId,
-  subnetName: scaleTs.Vector(scaleTs.compact),
-  tokenSymbol: scaleTs.Vector(scaleTs.compact),
-  tempo: scaleTs.compact,
-  lastStep: scaleTs.compact,
-  blocksSinceLastStep: scaleTs.compact,
-  emission: scaleTs.compact,
-  alphaIn: scaleTs.compact,
-  alphaOut: scaleTs.compact,
-  taoIn: scaleTs.compact,
-  alphaOutEmission: scaleTs.compact,
-  alphaInEmission: scaleTs.compact,
-  taoInEmission: scaleTs.compact,
-  pendingAlphaEmission: scaleTs.compact,
-  pendingRootEmission: scaleTs.compact,
-  subnetVolume: scaleTs.compact,
-  networkRegisteredAt: scaleTs.compact,
-  subnetIdentity: scaleTs.Option(SubnetIdentityV2),
-  movingPrice: I96F32
-});
-const DecodeResult_GetDynamicInfo = result => {
-  const LITTLE_ENDIAN_OFFSET = 256;
-  const decoded = DynamicInfo.dec(result);
-  const {
-    netuid: netuidLittleEndian,
-    subnetIdentity: subnetIdentityScaleOption = {},
-    tokenSymbol: tokenSymbolU8Arr,
-    taoIn,
-    alphaIn,
-    subnetName: subnetNameVector
-  } = decoded;
-  const netuid = Number(netuidLittleEndian) / LITTLE_ENDIAN_OFFSET;
-  const tokenSymbol = new TextDecoder().decode(Uint8Array.from(tokenSymbolU8Arr.map(val => Number(val))));
-  const subnetName = new TextDecoder().decode(Uint8Array.from(subnetNameVector.map(val => Number(val))));
-  const subnetIdentity = Object.keys(subnetIdentityScaleOption).reduce((acc, key) => {
-    const value = subnetIdentityScaleOption[key];
-    acc[key] = new TextDecoder().decode(value);
-    return acc;
-  }, {});
-  return {
-    ...decoded,
-    netuid,
-    tokenSymbol,
-    subnetIdentity,
-    taoIn: BigInt(taoIn),
-    alphaIn: BigInt(alphaIn),
-    subnetName
-  };
-};
 const calculateAlphaPrice = ({
   dynamicInfo
 }) => {
   if (!dynamicInfo) return 0n;
   const {
-    alphaIn,
-    taoIn
+    alpha_in,
+    tao_in
   } = dynamicInfo;
 
   // Scale taoIn before division to preserve precision
-  const result = taoIn * SCALE_FACTOR / alphaIn;
+  const result = tao_in * SCALE_FACTOR / alpha_in;
   return result; // Scaled price as bigint
 };
 const calculateTaoAmountFromAlpha = ({
@@ -4861,13 +4669,24 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
       log.warn(`Chain ${chainId} for token ${tokenId} not found`);
       continue;
     }
+    const [chainMeta] = findChainMeta(miniMetadatas, "substrate-native", chain);
+    if (!chainMeta?.miniMetadata) {
+      log.warn(`MiniMetadata for chain ${chainId} not found`);
+      continue;
+    }
+    const scaleApi = sapi.getScaleApi({
+      chainId,
+      send: (...args) => chainConnector.send(chainId, ...args, {
+        expectErrors: true
+      } // don't pollute the wallet logs when this request fails
+      )
+    }, chainMeta.miniMetadata, token, chain.hasCheckMetadataHash, chain.signedExtensions, chain.registryTypes);
 
     // sets the number of addresses to query in parallel (per chain, since each chain runs in parallel to the others)
     const concurrency = 4;
     // In-memory cache for successful dynamic info results
     const dynamicInfoCache = new Map();
     const fetchDynamicInfoForNetuids = async uniqueNetuids => {
-      const DYNAMIC_INFO_METHOD = "SubnetInfoRuntimeApi_get_dynamic_info";
       const MAX_RETRIES = 3;
       const RETRY_DELAY_MS = 500;
       const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
@@ -4875,12 +4694,10 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
         if (netuid === 0) return null;
         for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
           try {
-            const response = await chainConnector.send(chainId, "state_call", [DYNAMIC_INFO_METHOD, EncodeParams_GetDynamicInfo(netuid)], undefined, {
-              expectErrors: true
-            });
-            const decodedResult = DecodeResult_GetDynamicInfo(response);
-            dynamicInfoCache.set(netuid, decodedResult); // Cache successful response
-            return decodedResult;
+            const params = [netuid];
+            const result = await scaleApi.getRuntimeCallValue("SubnetInfoRuntimeApi", "get_dynamic_info", params);
+            dynamicInfoCache.set(netuid, result); // Cache successful response
+            return result;
           } catch (error) {
             log.trace(`Attempt ${attempt} failed for netuid ${netuid}:`, error);
             if (attempt < MAX_RETRIES) {
@@ -4902,14 +4719,9 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
     // mergeMap lets us run N concurrent queries, where N is the value of `concurrency`
     rxjs.mergeMap(async address => {
       const queryMethods = [async () => {
-        if (chainId === BITTENSOR_TESTNET_CHAIN_ID) return [];
-        const method = "StakeInfoRuntimeApi_get_stake_info_for_coldkey";
-        const params = EncodeParams_GetStakeInfoForColdkey(address);
-        const response = await chainConnector.send(chainId, "state_call", [method, params], undefined, {
-          expectErrors: true
-        } // don't pollute the wallet logs when this request fails
-        );
-        const result = DecodeResult_GetStakeInfoForColdkey(response);
+        if (chain.isTestnet) return [];
+        const params = [address];
+        const result = await scaleApi.getRuntimeCallValue("StakeInfoRuntimeApi", "get_stake_info_for_coldkey", params);
         if (!Array.isArray(result)) return [];
         const uniqueNetuids = Array.from(new Set(result.map(item => Number(item.netuid)).filter(netuid => netuid !== SUBTENSOR_ROOT_NETUID)));
         await fetchDynamicInfoForNetuids(uniqueNetuids);
@@ -4959,10 +4771,19 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
       dynamicInfo
     }) => {
       const {
-        tokenSymbol,
-        subnetName,
-        subnetIdentity
+        token_symbol,
+        subnet_name,
+        subnet_identity
       } = dynamicInfo ?? {};
+      const tokenSymbol = new TextDecoder().decode(Uint8Array.from(token_symbol ?? []));
+      const subnetName = new TextDecoder().decode(Uint8Array.from(subnet_name ?? []));
+
+      /** Map from Record<string, Binary> to Record<string, string> */
+      const binaryToText = input => Object.entries(input).reduce((acc, [key, value]) => {
+        acc[key] = value.asText();
+        return acc;
+      }, {});
+      const subnetIdentity = subnet_identity ? binaryToText(subnet_identity) : undefined;
 
       // Add 1n balance if failed to fetch dynamic info, so the position is not ignored by Balance lib and is displayed in the UI.
       const alphaStakedInTao = dynamicInfo ? calculateTaoFromDynamicInfo({
@@ -4970,7 +4791,7 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
         alphaStaked: stake
       }) : 1n;
       const alphaToTaoRate = calculateTaoFromDynamicInfo({
-        dynamicInfo,
+        dynamicInfo: dynamicInfo ?? null,
         alphaStaked: ONE_ALPHA_TOKEN
       }).toString();
       const stakeByNetuid = Number(netuid) === SUBTENSOR_ROOT_NETUID ? stake : alphaStakedInTao;
@@ -4999,7 +4820,7 @@ async function subscribeSubtensorStaking(chaindataProvider, chainConnector, addr
               subnetName,
               subnetIdentity: {
                 ...subnetIdentity,
-                subnetName: subnetIdentity?.subnetName || subnetName
+                subnetName: subnetIdentity?.subnet_name || subnetName
               }
             }
           }
@@ -5686,6 +5507,7 @@ const SubNativeModule = hydrate => {
 
       scale.compactMetadata(metadata, [{
         pallet: "System",
+        constants: ["Version", "SS58Prefix"],
         items: ["Account"]
       }, {
         pallet: "Balances",
@@ -5708,6 +5530,12 @@ const SubNativeModule = hydrate => {
       {
         pallet: "SubtensorModule",
         items: ["TotalColdkeyStake", "StakingHotkeys", "Stake"]
+      }], [{
+        runtimeApi: "StakeInfoRuntimeApi",
+        methods: ["get_stake_info_for_coldkey"]
+      }, {
+        runtimeApi: "SubnetInfoRuntimeApi",
+        methods: ["get_dynamic_info"]
       }]);
       const miniMetadata = scale.encodeMetadata(tag === "v15" ? {
         tag,