@talismn/balances 0.0.0-pr2043-20250618043535 → 0.0.0-pr2043-20250618082459

package/dist/talismn-balances.esm.js

@@ -1,4 +1,4 @@
-import { fetchInitMiniMetadatas, evmErc20TokenId as evmErc20TokenId$1, EvmErc20TokenSchema, evmNativeTokenId, evmUniswapV2TokenId, githubTokenLogoUrl, subAssetTokenId, subForeignAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId } from '@talismn/chaindata-provider';
+import { fetchInitMiniMetadatas, evmErc20TokenId as evmErc20TokenId$1, EvmErc20TokenSchema, evmNativeTokenId, evmUniswapV2TokenId, githubTokenLogoUrl, parseSubAssetTokenId, subAssetTokenId, subForeignAssetTokenId, subNativeTokenId, subPsp22TokenId, subTokensTokenId } from '@talismn/chaindata-provider';
 import { Dexie, liveQuery } from 'dexie';
 import { from, Observable, scan, share, map, switchAll, combineLatest, mergeMap, toArray, interval, startWith, exhaustMap, pipe, filter, shareReplay, combineLatestWith, distinctUntilChanged, firstValueFrom, BehaviorSubject, debounceTime, takeUntil, switchMap, withLatestFrom, concatMap } from 'rxjs';
 import anylogger from 'anylogger';
@@ -12,7 +12,9 @@ import { parseAbi, isHex, hexToBigInt } from 'viem';
 import isEqual from 'lodash/isEqual';
 import { defineMethod } from '@substrate/txwrapper-core';
 import { unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, getMetadataVersion, compactMetadata, encodeMetadata, decodeScale, papiParse, encodeStateKey } from '@talismn/scale';
+import { keys, toPairs } from 'lodash';
 import camelCase from 'lodash/camelCase';
+import { fetchBestMetadata, getScaleApi } from '@talismn/sapi';
 import { Metadata, TypeRegistry } from '@polkadot/types';
 import groupBy from 'lodash/groupBy';
 import { mergeUint8, toHex } from '@polkadot-api/utils';
@@ -20,7 +22,6 @@ import { Binary, AccountId } from 'polkadot-api';
 import PromisePool from '@supercharge/promise-pool';
 import { ChainConnectionError } from '@talismn/chain-connector';
 import { u32, u128, Struct } from 'scale-ts';
-import { getScaleApi } from '@talismn/sapi';
 import upperFirst from 'lodash/upperFirst';
 import { Abi } from '@polkadot/api-contract';
 
@@ -108,7 +109,7 @@ class EvmTokenFetcher {
 
 var packageJson = {
 	name: "@talismn/balances",
-	version: "0.0.0-pr2043-20250618043535"};
+	version: "0.0.0-pr2043-20250618082459"};
 
 const libVersion = packageJson.version;
 
@@ -2939,6 +2940,139 @@ async function getPoolBalance(publicClient, contractAddress, accountAddress) {
   }
 }
 
+// cache the promise so it can be shared across multiple calls
+const CACHE_GET_SPEC_VERSION = new Map();
+const fetchSpecVersion = async (chainConnector, networkId) => {
+  const {
+    specVersion
+  } = await chainConnector.send(networkId, "state_getRuntimeVersion", [true]);
+  return specVersion;
+};
+
+/**
+ * fetches the spec version of a network. current request is cached in case of multiple calls (all balance subs kick in at once)
+ */
+const getSpecVersion = async (chainConnector, networkId) => {
+  if (CACHE_GET_SPEC_VERSION.has(networkId)) return CACHE_GET_SPEC_VERSION.get(networkId);
+  const pResult = fetchSpecVersion(chainConnector, networkId);
+  CACHE_GET_SPEC_VERSION.set(networkId, pResult);
+  try {
+    return await pResult;
+  } catch (cause) {
+    throw new Error(`Failed to fetch specVersion for network ${networkId}`, {
+      cause
+    });
+  } finally {
+    CACHE_GET_SPEC_VERSION.delete(networkId);
+  }
+};
+
+// share requests as all modules will call this at once
+const CACHE$1 = new Map();
+const getMetadataRpc = async (chainConnector, networkId) => {
+  if (CACHE$1.has(networkId)) return CACHE$1.get(networkId);
+  const pResult = fetchBestMetadata((...args) => chainConnector.send(networkId, ...args), true // allow fallback to 14 as modules dont use any v15 or v16 specifics yet
+  );
+  CACHE$1.set(networkId, pResult);
+  try {
+    return await pResult;
+  } catch (cause) {
+    throw new Error(`Failed to fetch metadataRpc for network ${networkId}`, {
+      cause
+    });
+  } finally {
+    CACHE$1.delete(networkId);
+  }
+};
+
+// share requests as all modules will call this at once
+const CACHE = new Map();
+const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion) => {
+  if (CACHE.has(networkId)) return CACHE.get(networkId);
+  const pResult = fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion);
+  CACHE.set(networkId, pResult);
+  try {
+    return await pResult;
+  } catch (cause) {
+    throw new Error(`Failed to fetch metadataRpc for network ${networkId}`, {
+      cause
+    });
+  } finally {
+    CACHE.delete(networkId);
+  }
+};
+const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion) => {
+  const metadataRpc = await getMetadataRpc(chainConnector, chainId);
+  const chainConnectors = {
+    substrate: chainConnector
+  };
+  const modules = defaultBalanceModules.map(mod => mod({
+    chainConnectors,
+    chaindataProvider
+  })).filter(mod => mod.type.startsWith("substrate-"));
+  return Promise.all(modules.map(async mod => {
+    const source = mod.type;
+    const chainMeta = await mod.fetchSubstrateChainMeta(chainId, {}, metadataRpc, {});
+    return {
+      id: deriveMiniMetadataId({
+        source,
+        chainId,
+        specVersion,
+        libVersion
+      }),
+      source,
+      chainId,
+      specVersion,
+      libVersion,
+      data: chainMeta?.miniMetadata ?? null
+    };
+  }));
+};
+
+const getUpdatedMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion) => {
+  const miniMetadatas = await getMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion);
+  await db.transaction("readwrite", "miniMetadatas", async tx => {
+    await tx.miniMetadatas.where({
+      networkId
+    }).delete();
+    await tx.miniMetadatas.bulkPut(miniMetadatas);
+  });
+  return miniMetadatas;
+};
+
+const getMiniMetadata = async (chaindataProvider, chainConnector, chainId, source) => {
+  const specVersion = await getSpecVersion(chainConnector, chainId);
+
+  // TODO when working a chaindata branch, need a way to pass the libVersion used to derive the miniMetadataId got github
+  const miniMetadataId = deriveMiniMetadataId({
+    source,
+    chainId,
+    specVersion,
+    libVersion
+  });
+
+  // lookup local ones
+  const [dbMiniMetadata, ghMiniMetadata] = await Promise.all([db.miniMetadatas.get(miniMetadataId), chaindataProvider.miniMetadataById(miniMetadataId)]);
+  const miniMetadata = dbMiniMetadata ?? ghMiniMetadata;
+  if (miniMetadata) return miniMetadata;
+
+  // update from live chain metadata and persist locally
+  const miniMetadatas = await getUpdatedMiniMetadatas(chainConnector, chaindataProvider, chainId, specVersion);
+  const found = miniMetadatas.find(m => m.id === miniMetadataId);
+  if (!found) {
+    log.warn("MiniMetadata not found in updated miniMetadatas", {
+      source,
+      chainId,
+      specVersion,
+      libVersion,
+      miniMetadataId,
+      miniMetadatas
+    });
+    throw new Error(`MiniMetadata not found for ${source} on ${chainId}`);
+  }
+  return found;
+};
+
 /**
  * Wraps a BalanceModule's fetch/subscribe methods with a single `balances` method.
  * This `balances` method will subscribe if a callback parameter is provided, or otherwise fetch.
@@ -3244,7 +3378,7 @@ const SubAssetsModule = hydrate => {
       const tokens = {};
       for (const tokenConfig of moduleConfig?.tokens ?? []) {
         try {
-          const assetId = typeof tokenConfig.assetId === "number" ? tokenConfig.assetId.toString() : tokenConfig.assetId;
+          const assetId = tokenConfig.assetId;
           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}`);
@@ -3286,13 +3420,47 @@ const SubAssetsModule = hydrate => {
     async subscribeBalances({
       addressesByToken
     }, callback) {
-      const queries = await buildQueries$3(chaindataProvider, addressesByToken);
-      const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe((error, result) => {
-        if (error) return callback(error);
-        const balances = result?.filter(b => b !== null) ?? [];
-        if (balances.length > 0) callback(null, new Balances(balances));
-      });
-      return unsubscribe;
+      const byNetwork = keys(addressesByToken).reduce((acc, tokenId) => {
+        const networkId = parseSubAssetTokenId(tokenId).networkId;
+        if (!acc[networkId]) acc[networkId] = {};
+        acc[networkId][tokenId] = addressesByToken[tokenId];
+        return acc;
+      }, {});
+      const controller = new AbortController();
+      await Promise.all(toPairs(byNetwork).map(async ([networkId, addressesByToken]) => {
+        const queries = await buildNetworkQueries(networkId, chainConnector, chaindataProvider, addressesByToken);
+        if (controller.signal.aborted) return;
+        const stateHelper = new RpcStateQueryHelper(chainConnector, queries);
+        const unsubscribe = await stateHelper.subscribe((error, result) => {
+          //  console.log("SubstrateAssetsModule.callback", { error, result })
+          if (error) return callback(error);
+          const balances = result?.filter(b => b !== null) ?? [];
+          if (balances.length > 0) callback(null, new Balances(balances));
+        });
+        controller.signal.addEventListener("abort", () => {
+          log.debug("TMP subscribeBalances aborted, unsubscribing from network", networkId);
+          unsubscribe();
+        });
+      }));
+
+      // const networkIds = uniq(uniq(keys(addressesByToken)).map((tokenId) => parseSubAssetTokenId(tokenId).networkId))
+      // const
+
+      //console.log("SubstrateAssetsModule.subscribeBalances 1", { addressesByToken })
+      // const queries = await buildQueries(chaindataProvider, addressesByToken)
+      // //console.log("SubstrateAssetsModule.subscribeBalances 2", { queries, addressesByToken })
+      // const unsubscribe = await new RpcStateQueryHelper(chainConnector, queries).subscribe(
+      //   (error, result) => {
+      //     //  console.log("SubstrateAssetsModule.callback", { error, result })
+      //     if (error) return callback(error)
+      //     const balances = result?.filter((b): b is SubAssetsBalance => b !== null) ?? []
+      //     if (balances.length > 0) callback(null, new Balances(balances))
+      //   },
+      // )
+
+      return () => {
+        controller.abort();
+      };
     },
     async fetchBalances(addressesByToken) {
       assert(chainConnectors.substrate, "This module requires a substrate chain connector");
@@ -3366,9 +3534,109 @@ const SubAssetsModule = hydrate => {
     }
   };
 };
+async function buildNetworkQueries(networkId, chainConnector, chaindataProvider, addressesByToken) {
+  const miniMetadata = await getMiniMetadata(chaindataProvider, chainConnector, networkId, moduleType$4);
+  const network = await chaindataProvider.chainById(networkId);
+  const tokensById = await chaindataProvider.tokensById();
+  const chainIds = [networkId];
+  const chains = network ? {
+    [networkId]: network
+  } : {};
+  const miniMetadatas = new Map([[miniMetadata.id, miniMetadata]]);
+  const chainStorageCoders = buildStorageCoders({
+    chainIds,
+    chains,
+    miniMetadatas,
+    moduleType: moduleType$4,
+    coders: {
+      storage: ["Assets", "Account"]
+    }
+  });
+  return Object.entries(addressesByToken).flatMap(([tokenId, addresses]) => {
+    const token = tokensById[tokenId];
+    if (!token) {
+      log.warn(`Token ${tokenId} not found`);
+      return [];
+    }
+    if (token.type !== "substrate-assets") {
+      log.debug(`This module doesn't handle tokens of type ${token.type}`);
+      return [];
+    }
+    const networkId = token.networkId;
+    if (!networkId) {
+      log.warn(`Token ${tokenId} has no chain`);
+      return [];
+    }
+    const chain = chains[networkId];
+    if (!chain) {
+      log.warn(`Chain ${networkId} for token ${tokenId} not found`);
+      return [];
+    }
+    return addresses.flatMap(address => {
+      const scaleCoder = chainStorageCoders.get(networkId)?.storage;
+      const stateKey = tryEncode(scaleCoder, BigInt(token.assetId), address) ?? tryEncode(scaleCoder, token.assetId, address);
+      if (!stateKey) {
+        log.warn(`Invalid assetId / address in ${networkId} storage query ${token.assetId} / ${address}`);
+        return [];
+      }
+      const decodeResult = change => {
+        /** NOTE: This type is only a hint for typescript, the chain can actually return whatever it wants to */
+
+        const decoded = decodeScale(scaleCoder, change, `Failed to decode substrate-assets balance on chain ${networkId}`) ?? {
+          balance: 0n,
+          status: {
+            type: "Liquid"
+          }};
+        const isFrozen = decoded?.status?.type === "Frozen";
+        const amount = (decoded?.balance ?? 0n).toString();
+
+        // due to the following balance calculations, which are made in the `Balance` type:
+        //
+        // total balance        = (free balance) + (reserved balance)
+        // transferable balance = (free balance) - (frozen balance)
+        //
+        // when `isFrozen` is true we need to set **both** the `free` and `frozen` amounts
+        // of this balance to the value we received from the RPC.
+        //
+        // if we only set the `frozen` amount, then the `total` calculation will be incorrect!
+        const free = amount;
+        const frozen = token.isFrozen || isFrozen ? amount : "0";
+
+        // include balance values even if zero, so that newly-zero values overwrite old values
+        const balanceValues = [{
+          type: "free",
+          label: "free",
+          amount: free.toString()
+        }, {
+          type: "locked",
+          label: "frozen",
+          amount: frozen.toString()
+        }];
+        return {
+          source: "substrate-assets",
+          status: "live",
+          address,
+          networkId,
+          tokenId: token.id,
+          values: balanceValues
+        };
+      };
+      return {
+        chainId: networkId,
+        stateKey,
+        decodeResult
+      };
+    });
+  });
+}
 async function buildQueries$3(chaindataProvider, addressesByToken) {
   const allChains = await chaindataProvider.chainsById();
   const tokens = await chaindataProvider.tokensById();
+
+  // const networkIds = Object.keys(addressesByToken)
+
+  // const
+  // const miniMetadatas = await getMiniMetadatas(chainConnector, chaindataProvider, network)
   const miniMetadatas = new Map((await db.miniMetadatas.toArray()).map(miniMetadata => [miniMetadata.id, miniMetadata]));
   const uniqueChainIds = getUniqueChainIds(addressesByToken, tokens);
   const chains = Object.fromEntries(uniqueChainIds.map(chainId => [chainId, allChains[chainId]]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances",
-  "version": "0.0.0-pr2043-20250618043535",
+  "version": "0.0.0-pr2043-20250618082459",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -33,12 +33,12 @@
     "rxjs": "^7.8.1",
     "scale-ts": "^1.6.1",
     "viem": "^2.27.3",
-    "@talismn/chain-connector": "0.0.0-pr2043-20250618043535",
-    "@talismn/chain-connector-evm": "0.0.0-pr2043-20250618043535",
-    "@talismn/chaindata-provider": "0.0.0-pr2043-20250618043535",
-    "@talismn/sapi": "0.0.0-pr2043-20250618043535",
+    "@talismn/chain-connector": "0.0.0-pr2043-20250618082459",
+    "@talismn/chaindata-provider": "0.0.0-pr2043-20250618082459",
+    "@talismn/sapi": "0.0.0-pr2043-20250618082459",
+    "@talismn/token-rates": "0.0.0-pr2043-20250618082459",
+    "@talismn/chain-connector-evm": "0.0.0-pr2043-20250618082459",
     "@talismn/scale": "0.1.2",
-    "@talismn/token-rates": "0.0.0-pr2043-20250618043535",
     "@talismn/util": "0.4.2"
   },
   "devDependencies": {
@@ -54,8 +54,8 @@
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/eslint-config": "0.0.3",
-    "@talismn/tsconfig": "0.0.2"
+    "@talismn/tsconfig": "0.0.2",
+    "@talismn/eslint-config": "0.0.3"
   },
   "peerDependencies": {
     "@polkadot/api-contract": "*",