@talismn/balances 0.0.0-pr2075-20250710091134 → 0.0.0-pr2075-20250710124714

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

@@ -24,7 +24,7 @@ export declare class BalancesProvider {
     private getStoredMiniMetadatas$;
     private getDefaultMiniMetadatas$;
     private getStoredBalances;
-    private cleanupAddressesByTokenId;
+    private cleanupAddressesByTokenId$;
 }
 export declare const isAddressCompatibleWithNetwork: (network: Network, address: Address) => boolean;
 export {};

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

@@ -6202,6 +6202,7 @@ const POOL = new PQueue__default.default({
 const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion) => {
   if (specVersion === undefined) specVersion = await getSpecVersion(chainConnector, networkId);
   const cacheKey = getCacheKey(networkId, specVersion);
+  if (CACHE.has(cacheKey)) return CACHE.get(cacheKey);
   const pResult = POOL.add(() => fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion));
 
   // keep the results in cache (unless call fails) as observables call this function a lot of times
@@ -6215,15 +6216,13 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
     });
   }
 };
-const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
+const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion) => {
   const start = performance.now();
   log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
   try {
     const network = await chaindataProvider.getNetworkById(chainId, "polkadot");
     if (!network) throw new Error(`Network ${chainId} not found in chaindataProvider`);
-    signal?.throwIfAborted();
     const metadataRpc = await getMetadataRpc(chainConnector, chainId);
-    signal?.throwIfAborted();
     return Promise.all(BALANCE_MODULES.filter(m => m.platform === "polkadot").map(mod => mod.getMiniMetadata({
       networkId: chainId,
       metadataRpc,
@@ -6256,9 +6255,9 @@ class BalancesProvider {
       balances,
       miniMetadatas
     }) => ({
-      balances: lodashEs.values(balances).filter(util.isNotNil),
-      miniMetadatas: lodashEs.values(miniMetadatas).filter(util.isNotNil)
-    })));
+      balances: lodashEs.values(balances).filter(util.isNotNil).sort(sortByBalanceId),
+      miniMetadatas: lodashEs.values(miniMetadatas).filter(util.isNotNil).sort(sortByMiniMetadataId)
+    }), rxjs.shareReplay(1)));
   }
   get storedMiniMetadataMapById$() {
     return this.#storage.pipe(rxjs.map(storage => lodashEs.keyBy(storage.miniMetadatas, m => m.id)), rxjs.distinctUntilChanged(lodashEs.isEqual), rxjs.shareReplay(1));
@@ -6266,39 +6265,35 @@ class BalancesProvider {
 
   // this is the only public method
   getBalances$(addressesByTokenId) {
-    // TODO move the getSharedObservable caching down to this.getNetworkBalances$ to prevent network-level subscriptions to restart when enabling/disabling other networks
-    // this will require addressesByTokenId arg to be normalized/sorted so the cache key can be compared properly, seems a bit random atm
-    return util.getSharedObservable("BalancesProvider.getBalances$", addressesByTokenId, () => {
-      return this.cleanupAddressesByTokenId(addressesByTokenId).pipe(rxjs.map(
-      // split by network
-      addressesByTokenId => lodashEs.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
-        const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
-        if (!acc[networkId]) acc[networkId] = {};
-        acc[networkId][tokenId] = addresses;
-        return acc;
-      }, {})), rxjs.switchMap(addressesByTokenIdByNetworkId =>
-      // fetch balances and start a 30s timer to mark the whole subscription live after 30s
-      rxjs.combineLatest({
-        isStale: rxjs.timer(30_000).pipe(rxjs.map(() => true), rxjs.startWith(false)),
-        results: rxjs.combineLatest(lodashEs.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
-      })), rxjs.map(
-      // combine
-      ({
-        isStale,
-        results
-      }) => ({
-        status: !isStale && results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
-          ...b,
-          status: "stale"
-        } : b)).sort((a, b) => getBalanceId(a).localeCompare(getBalanceId(b)))
-      })), rxjs.startWith({
-        status: "initialising",
-        balances: this.getStoredBalances(addressesByTokenId)
-      }), rxjs.distinctUntilChanged(lodashEs.isEqual));
-    });
+    return this.cleanupAddressesByTokenId$(addressesByTokenId).pipe(rxjs.map(
+    // split by network
+    addressesByTokenId => lodashEs.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
+      const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
+      if (!acc[networkId]) acc[networkId] = {};
+      acc[networkId][tokenId] = addresses;
+      return acc;
+    }, {})), rxjs.switchMap(addressesByTokenIdByNetworkId =>
+    // fetch balances and start a 30s timer to mark the whole subscription live after 30s
+    rxjs.combineLatest({
+      isStale: rxjs.timer(30_000).pipe(rxjs.map(() => true), rxjs.startWith(false)),
+      results: rxjs.combineLatest(lodashEs.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
+    })), rxjs.map(
+    // combine
+    ({
+      isStale,
+      results
+    }) => ({
+      status: !isStale && results.some(({
+        status
+      }) => status === "initialising") ? "initialising" : "live",
+      balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
+        ...b,
+        status: "stale"
+      } : b)).sort(sortByBalanceId)
+    })), rxjs.startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByTokenId)
+    }), rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   fetchBalances(addressesByTokenId) {
     // TODO: better
@@ -6309,84 +6304,95 @@ class BalancesProvider {
     }) => balances)));
   }
   getNetworkBalances$(networkId, addressesByTokenId) {
-    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
-    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
-    const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
-    return rxjs.combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(rxjs.switchMap(([network, miniMetadatas, tokensMapById]) => {
-      const tokensAndAddresses = lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
-      return rxjs.combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
-        const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
-        const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
-        const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
-
-        // all balance ids expected in result set
-        const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
-          tokenId,
-          address
-        })));
-        const initValue = {
-          status: "initialising",
-          balances: this.getStoredBalances(moduleAddressesByTokenId)
-        };
+    return util.getSharedObservable(`BalancesProvider.getNetorkBalances$`, {
+      networkId,
+      addressesByTokenId
+    }, () => {
+      const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+      const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+      const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
+      return rxjs.combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(rxjs.switchMap(([network, miniMetadatas, tokensMapById]) => {
+        const tokensAndAddresses = lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
+        return rxjs.combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
+          const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
+          const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+          const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
+
+          // all balance ids expected in result set
+          const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+            tokenId,
+            address
+          })));
+          const initValue = {
+            status: "initialising",
+            balances: this.getStoredBalances(moduleAddressesByTokenId)
+          };
 
-        // updating storage has to be done on a per-module basis, so we know which balances can be deleted
-        const updateStorage = results => {
-          if (results.status !== "live") return;
-          const storage = this.#storage.getValue();
-          const balances = lodashEs.assign({}, storage.balances,
-          // delete all balances expected in the result set. because if they are not present it means they are empty.
-          lodashEs.fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), lodashEs.keyBy(
-          // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
-          results.balances.map(b => ({
-            ...b,
-            status: "cache"
-          })), b => getBalanceId(b)));
-          this.#storage.next(lodashEs.assign({}, storage, {
-            balances
-          }));
-        };
-        switch (mod.platform) {
-          case "ethereum":
-            {
-              if (!this.#chainConnectors.evm) return rxjs.of(initValue);
+          // updating storage has to be done on a per-module basis, so we know which balances can be deleted
+          const updateStorage = results => {
+            if (results.status !== "live") return;
+            const storage = this.#storage.getValue();
+            const balances = lodashEs.assign({}, storage.balances,
+            // delete all balances expected in the result set. because if they are not present it means they are empty.
+            lodashEs.fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), lodashEs.keyBy(
+            // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
+            results.balances.map(b => ({
+              ...b,
+              status: "cache"
+            })), b => getBalanceId(b)));
+            this.#storage.next(lodashEs.assign({}, storage, {
+              balances
+            }));
+          };
+          switch (mod.platform) {
+            case "ethereum":
+              {
+                if (!this.#chainConnectors.evm) return rxjs.of(initValue);
+                return mod.subscribeBalances({
+                  networkId,
+                  tokensWithAddresses,
+                  connector: this.#chainConnectors.evm
+                }).pipe(rxjs.map(results => ({
+                  status: "live",
+                  // exclude zero balances
+                  balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+                })), rxjs.tap(updateStorage), rxjs.startWith(initValue));
+              }
+            case "polkadot":
+              if (!this.#chainConnectors.substrate || !miniMetadata) {
+                log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
+                return rxjs.of(initValue);
+              }
               return mod.subscribeBalances({
                 networkId,
                 tokensWithAddresses,
-                connector: this.#chainConnectors.evm
+                connector: this.#chainConnectors.substrate,
+                miniMetadata: miniMetadata
               }).pipe(rxjs.map(results => ({
                 status: "live",
                 // exclude zero balances
                 balances: results.success.filter(b => new Balance(b).total.planck > 0n)
               })), rxjs.tap(updateStorage), rxjs.startWith(initValue));
-            }
-          case "polkadot":
-            if (!this.#chainConnectors.substrate || !miniMetadata) {
-              log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
-              return rxjs.of(initValue);
-            }
-            return mod.subscribeBalances({
-              networkId,
-              tokensWithAddresses,
-              connector: this.#chainConnectors.substrate,
-              miniMetadata: miniMetadata
-            }).pipe(rxjs.map(results => ({
-              status: "live",
-              // exclude zero balances
-              balances: results.success.filter(b => new Balance(b).total.planck > 0n)
-            })), rxjs.tap(updateStorage), rxjs.startWith(initValue));
-        }
-      }));
-    }), rxjs.map(results => {
-      return {
-        status: results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances)
-      };
-    }), rxjs.startWith({
-      status: "initialising",
-      balances: this.getStoredBalances(addressesByTokenId)
-    }));
+          }
+        }));
+      }), rxjs.map(results => {
+        return {
+          status: results.some(({
+            status
+          }) => status === "initialising") ? "initialising" : "live",
+          balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+        };
+      }), rxjs.startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(addressesByTokenId)
+      }), rxjs.distinctUntilChanged(lodashEs.isEqual),
+      // shareReplay + keepAlive allow for subscription to not restart as long as the inputs dont change
+      // for example, if another network is enabled/disabled
+      rxjs.shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), util.keepAlive(2_000));
+    });
   }
   getNetworkMiniMetadatas$(networkId) {
     return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) && this.#chainConnectors.substrate ? rxjs.from(getSpecVersion(this.#chainConnectors.substrate, networkId)).pipe(rxjs.switchMap(specVersion => this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])));
@@ -6421,13 +6427,17 @@ class BalancesProvider {
           miniMetadatas
         }));
       }));
-    }));
+    }),
+    // emit only when mini metadata changes, as a change here would restart all subscriptions for the network
+    rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   getStoredMiniMetadatas$(miniMetadataIds) {
     return this.storedMiniMetadataMapById$.pipe(rxjs.map(mapById => {
       const miniMetadatas = miniMetadataIds.map(id => mapById[id]);
       return miniMetadatas.length && miniMetadatas.every(util.isTruthy) ? miniMetadatas : null;
-    }));
+    }),
+    // source changes very often
+    rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   getDefaultMiniMetadatas$(miniMetadataIds) {
     return this.#chaindataProvider.miniMetadatasMapById$.pipe(rxjs.map(mapById => {
@@ -6440,9 +6450,9 @@ class BalancesProvider {
     return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({
       address,
       tokenId
-    })]).filter(util.isNotNil).sort((a, b) => getBalanceId(a).localeCompare(getBalanceId(b)));
+    })]).filter(util.isNotNil).sort(sortByBalanceId);
   }
-  cleanupAddressesByTokenId(addressesByTokenId) {
+  cleanupAddressesByTokenId$(addressesByTokenId) {
     return this.#chaindataProvider.getNetworksMapById$().pipe(rxjs.map(networksById => {
       return lodashEs.fromPairs(lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => {
         const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
@@ -6463,6 +6473,8 @@ const isAddressCompatibleWithNetwork = (network, address) => {
       throw new Error("Unsupported network platform");
   }
 };
+const sortByBalanceId = (a, b) => getBalanceId(a).localeCompare(getBalanceId(b));
+const sortByMiniMetadataId = (a, b) => a.id.localeCompare(b.id);
 
 Object.defineProperty(exports, "MINIMETADATA_VERSION", {
   enumerable: true,

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

@@ -6202,6 +6202,7 @@ const POOL = new PQueue__default.default({
 const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion) => {
   if (specVersion === undefined) specVersion = await getSpecVersion(chainConnector, networkId);
   const cacheKey = getCacheKey(networkId, specVersion);
+  if (CACHE.has(cacheKey)) return CACHE.get(cacheKey);
   const pResult = POOL.add(() => fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion));
 
   // keep the results in cache (unless call fails) as observables call this function a lot of times
@@ -6215,15 +6216,13 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
     });
   }
 };
-const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
+const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion) => {
   const start = performance.now();
   log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
   try {
     const network = await chaindataProvider.getNetworkById(chainId, "polkadot");
     if (!network) throw new Error(`Network ${chainId} not found in chaindataProvider`);
-    signal?.throwIfAborted();
     const metadataRpc = await getMetadataRpc(chainConnector, chainId);
-    signal?.throwIfAborted();
     return Promise.all(BALANCE_MODULES.filter(m => m.platform === "polkadot").map(mod => mod.getMiniMetadata({
       networkId: chainId,
       metadataRpc,
@@ -6256,9 +6255,9 @@ class BalancesProvider {
       balances,
       miniMetadatas
     }) => ({
-      balances: lodashEs.values(balances).filter(util.isNotNil),
-      miniMetadatas: lodashEs.values(miniMetadatas).filter(util.isNotNil)
-    })));
+      balances: lodashEs.values(balances).filter(util.isNotNil).sort(sortByBalanceId),
+      miniMetadatas: lodashEs.values(miniMetadatas).filter(util.isNotNil).sort(sortByMiniMetadataId)
+    }), rxjs.shareReplay(1)));
   }
   get storedMiniMetadataMapById$() {
     return this.#storage.pipe(rxjs.map(storage => lodashEs.keyBy(storage.miniMetadatas, m => m.id)), rxjs.distinctUntilChanged(lodashEs.isEqual), rxjs.shareReplay(1));
@@ -6266,39 +6265,35 @@ class BalancesProvider {
 
   // this is the only public method
   getBalances$(addressesByTokenId) {
-    // TODO move the getSharedObservable caching down to this.getNetworkBalances$ to prevent network-level subscriptions to restart when enabling/disabling other networks
-    // this will require addressesByTokenId arg to be normalized/sorted so the cache key can be compared properly, seems a bit random atm
-    return util.getSharedObservable("BalancesProvider.getBalances$", addressesByTokenId, () => {
-      return this.cleanupAddressesByTokenId(addressesByTokenId).pipe(rxjs.map(
-      // split by network
-      addressesByTokenId => lodashEs.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
-        const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
-        if (!acc[networkId]) acc[networkId] = {};
-        acc[networkId][tokenId] = addresses;
-        return acc;
-      }, {})), rxjs.switchMap(addressesByTokenIdByNetworkId =>
-      // fetch balances and start a 30s timer to mark the whole subscription live after 30s
-      rxjs.combineLatest({
-        isStale: rxjs.timer(30_000).pipe(rxjs.map(() => true), rxjs.startWith(false)),
-        results: rxjs.combineLatest(lodashEs.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
-      })), rxjs.map(
-      // combine
-      ({
-        isStale,
-        results
-      }) => ({
-        status: !isStale && results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
-          ...b,
-          status: "stale"
-        } : b)).sort((a, b) => getBalanceId(a).localeCompare(getBalanceId(b)))
-      })), rxjs.startWith({
-        status: "initialising",
-        balances: this.getStoredBalances(addressesByTokenId)
-      }), rxjs.distinctUntilChanged(lodashEs.isEqual));
-    });
+    return this.cleanupAddressesByTokenId$(addressesByTokenId).pipe(rxjs.map(
+    // split by network
+    addressesByTokenId => lodashEs.toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
+      const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
+      if (!acc[networkId]) acc[networkId] = {};
+      acc[networkId][tokenId] = addresses;
+      return acc;
+    }, {})), rxjs.switchMap(addressesByTokenIdByNetworkId =>
+    // fetch balances and start a 30s timer to mark the whole subscription live after 30s
+    rxjs.combineLatest({
+      isStale: rxjs.timer(30_000).pipe(rxjs.map(() => true), rxjs.startWith(false)),
+      results: rxjs.combineLatest(lodashEs.toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
+    })), rxjs.map(
+    // combine
+    ({
+      isStale,
+      results
+    }) => ({
+      status: !isStale && results.some(({
+        status
+      }) => status === "initialising") ? "initialising" : "live",
+      balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
+        ...b,
+        status: "stale"
+      } : b)).sort(sortByBalanceId)
+    })), rxjs.startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByTokenId)
+    }), rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   fetchBalances(addressesByTokenId) {
     // TODO: better
@@ -6309,84 +6304,95 @@ class BalancesProvider {
     }) => balances)));
   }
   getNetworkBalances$(networkId, addressesByTokenId) {
-    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
-    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
-    const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
-    return rxjs.combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(rxjs.switchMap(([network, miniMetadatas, tokensMapById]) => {
-      const tokensAndAddresses = lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
-      return rxjs.combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
-        const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
-        const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
-        const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
-
-        // all balance ids expected in result set
-        const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
-          tokenId,
-          address
-        })));
-        const initValue = {
-          status: "initialising",
-          balances: this.getStoredBalances(moduleAddressesByTokenId)
-        };
+    return util.getSharedObservable(`BalancesProvider.getNetorkBalances$`, {
+      networkId,
+      addressesByTokenId
+    }, () => {
+      const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+      const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+      const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
+      return rxjs.combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(rxjs.switchMap(([network, miniMetadatas, tokensMapById]) => {
+        const tokensAndAddresses = lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
+        return rxjs.combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
+          const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
+          const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+          const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
+
+          // all balance ids expected in result set
+          const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+            tokenId,
+            address
+          })));
+          const initValue = {
+            status: "initialising",
+            balances: this.getStoredBalances(moduleAddressesByTokenId)
+          };
 
-        // updating storage has to be done on a per-module basis, so we know which balances can be deleted
-        const updateStorage = results => {
-          if (results.status !== "live") return;
-          const storage = this.#storage.getValue();
-          const balances = lodashEs.assign({}, storage.balances,
-          // delete all balances expected in the result set. because if they are not present it means they are empty.
-          lodashEs.fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), lodashEs.keyBy(
-          // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
-          results.balances.map(b => ({
-            ...b,
-            status: "cache"
-          })), b => getBalanceId(b)));
-          this.#storage.next(lodashEs.assign({}, storage, {
-            balances
-          }));
-        };
-        switch (mod.platform) {
-          case "ethereum":
-            {
-              if (!this.#chainConnectors.evm) return rxjs.of(initValue);
+          // updating storage has to be done on a per-module basis, so we know which balances can be deleted
+          const updateStorage = results => {
+            if (results.status !== "live") return;
+            const storage = this.#storage.getValue();
+            const balances = lodashEs.assign({}, storage.balances,
+            // delete all balances expected in the result set. because if they are not present it means they are empty.
+            lodashEs.fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), lodashEs.keyBy(
+            // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
+            results.balances.map(b => ({
+              ...b,
+              status: "cache"
+            })), b => getBalanceId(b)));
+            this.#storage.next(lodashEs.assign({}, storage, {
+              balances
+            }));
+          };
+          switch (mod.platform) {
+            case "ethereum":
+              {
+                if (!this.#chainConnectors.evm) return rxjs.of(initValue);
+                return mod.subscribeBalances({
+                  networkId,
+                  tokensWithAddresses,
+                  connector: this.#chainConnectors.evm
+                }).pipe(rxjs.map(results => ({
+                  status: "live",
+                  // exclude zero balances
+                  balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+                })), rxjs.tap(updateStorage), rxjs.startWith(initValue));
+              }
+            case "polkadot":
+              if (!this.#chainConnectors.substrate || !miniMetadata) {
+                log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
+                return rxjs.of(initValue);
+              }
               return mod.subscribeBalances({
                 networkId,
                 tokensWithAddresses,
-                connector: this.#chainConnectors.evm
+                connector: this.#chainConnectors.substrate,
+                miniMetadata: miniMetadata
               }).pipe(rxjs.map(results => ({
                 status: "live",
                 // exclude zero balances
                 balances: results.success.filter(b => new Balance(b).total.planck > 0n)
               })), rxjs.tap(updateStorage), rxjs.startWith(initValue));
-            }
-          case "polkadot":
-            if (!this.#chainConnectors.substrate || !miniMetadata) {
-              log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
-              return rxjs.of(initValue);
-            }
-            return mod.subscribeBalances({
-              networkId,
-              tokensWithAddresses,
-              connector: this.#chainConnectors.substrate,
-              miniMetadata: miniMetadata
-            }).pipe(rxjs.map(results => ({
-              status: "live",
-              // exclude zero balances
-              balances: results.success.filter(b => new Balance(b).total.planck > 0n)
-            })), rxjs.tap(updateStorage), rxjs.startWith(initValue));
-        }
-      }));
-    }), rxjs.map(results => {
-      return {
-        status: results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances)
-      };
-    }), rxjs.startWith({
-      status: "initialising",
-      balances: this.getStoredBalances(addressesByTokenId)
-    }));
+          }
+        }));
+      }), rxjs.map(results => {
+        return {
+          status: results.some(({
+            status
+          }) => status === "initialising") ? "initialising" : "live",
+          balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+        };
+      }), rxjs.startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(addressesByTokenId)
+      }), rxjs.distinctUntilChanged(lodashEs.isEqual),
+      // shareReplay + keepAlive allow for subscription to not restart as long as the inputs dont change
+      // for example, if another network is enabled/disabled
+      rxjs.shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), util.keepAlive(2_000));
+    });
   }
   getNetworkMiniMetadatas$(networkId) {
     return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) && this.#chainConnectors.substrate ? rxjs.from(getSpecVersion(this.#chainConnectors.substrate, networkId)).pipe(rxjs.switchMap(specVersion => this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])));
@@ -6421,13 +6427,17 @@ class BalancesProvider {
           miniMetadatas
         }));
       }));
-    }));
+    }),
+    // emit only when mini metadata changes, as a change here would restart all subscriptions for the network
+    rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   getStoredMiniMetadatas$(miniMetadataIds) {
     return this.storedMiniMetadataMapById$.pipe(rxjs.map(mapById => {
       const miniMetadatas = miniMetadataIds.map(id => mapById[id]);
       return miniMetadatas.length && miniMetadatas.every(util.isTruthy) ? miniMetadatas : null;
-    }));
+    }),
+    // source changes very often
+    rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   getDefaultMiniMetadatas$(miniMetadataIds) {
     return this.#chaindataProvider.miniMetadatasMapById$.pipe(rxjs.map(mapById => {
@@ -6440,9 +6450,9 @@ class BalancesProvider {
     return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({
       address,
       tokenId
-    })]).filter(util.isNotNil).sort((a, b) => getBalanceId(a).localeCompare(getBalanceId(b)));
+    })]).filter(util.isNotNil).sort(sortByBalanceId);
   }
-  cleanupAddressesByTokenId(addressesByTokenId) {
+  cleanupAddressesByTokenId$(addressesByTokenId) {
     return this.#chaindataProvider.getNetworksMapById$().pipe(rxjs.map(networksById => {
       return lodashEs.fromPairs(lodashEs.toPairs(addressesByTokenId).map(([tokenId, addresses]) => {
         const networkId = chaindataProvider.parseTokenId(tokenId).networkId;
@@ -6463,6 +6473,8 @@ const isAddressCompatibleWithNetwork = (network, address) => {
       throw new Error("Unsupported network platform");
   }
 };
+const sortByBalanceId = (a, b) => getBalanceId(a).localeCompare(getBalanceId(b));
+const sortByMiniMetadataId = (a, b) => a.id.localeCompare(b.id);
 
 Object.defineProperty(exports, "MINIMETADATA_VERSION", {
   enumerable: true,

package/dist/talismn-balances.esm.js

@@ -1,6 +1,6 @@
 import { EvmErc20TokenSchema, parseTokenId, parseEvmErc20TokenId, evmErc20TokenId, isTokenOfType, TokenBaseSchema, EvmNativeTokenSchema, evmNativeTokenId, EvmUniswapV2TokenSchema, evmUniswapV2TokenId, SubAssetsTokenSchema, subAssetTokenId, MINIMETADATA_VERSION, SubForeignAssetsTokenSchema, subForeignAssetTokenId, SubHydrationTokenSchema, subHydrationTokenId, SubNativeTokenSchema, subNativeTokenId, SubPsp22TokenSchema, subPsp22TokenId, SubTokensTokenSchema, subTokensTokenId, isNetworkDot } from '@talismn/chaindata-provider';
 export { MINIMETADATA_VERSION } from '@talismn/chaindata-provider';
-import { isEthereumAddress, isNotNil, BigMath, isArrayOf, isBigInt, planckToTokens, isAbortError, getSharedObservable, isTruthy } from '@talismn/util';
+import { isEthereumAddress, isNotNil, BigMath, isArrayOf, isBigInt, planckToTokens, isAbortError, getSharedObservable, keepAlive, isTruthy } from '@talismn/util';
 import { parseAbi, erc20Abi, getContract, ContractFunctionExecutionError, hexToString, erc20Abi_bytes32, encodeFunctionData, withRetry } from 'viem';
 import { assign, omit, isEqual, keyBy, keys, uniq, fromPairs, values, toPairs } from 'lodash-es';
 import z from 'zod/v4';
@@ -6193,6 +6193,7 @@ const POOL = new PQueue({
 const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, specVersion) => {
   if (specVersion === undefined) specVersion = await getSpecVersion(chainConnector, networkId);
   const cacheKey = getCacheKey(networkId, specVersion);
+  if (CACHE.has(cacheKey)) return CACHE.get(cacheKey);
   const pResult = POOL.add(() => fetchMiniMetadatas(chainConnector, chaindataProvider, networkId, specVersion));
 
   // keep the results in cache (unless call fails) as observables call this function a lot of times
@@ -6206,15 +6207,13 @@ const getMiniMetadatas = async (chainConnector, chaindataProvider, networkId, sp
     });
   }
 };
-const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion, signal) => {
+const fetchMiniMetadatas = async (chainConnector, chaindataProvider, chainId, specVersion) => {
   const start = performance.now();
   log.info("[miniMetadata] fetching minimetadatas for %s", chainId);
   try {
     const network = await chaindataProvider.getNetworkById(chainId, "polkadot");
     if (!network) throw new Error(`Network ${chainId} not found in chaindataProvider`);
-    signal?.throwIfAborted();
     const metadataRpc = await getMetadataRpc(chainConnector, chainId);
-    signal?.throwIfAborted();
     return Promise.all(BALANCE_MODULES.filter(m => m.platform === "polkadot").map(mod => mod.getMiniMetadata({
       networkId: chainId,
       metadataRpc,
@@ -6247,9 +6246,9 @@ class BalancesProvider {
       balances,
       miniMetadatas
     }) => ({
-      balances: values(balances).filter(isNotNil),
-      miniMetadatas: values(miniMetadatas).filter(isNotNil)
-    })));
+      balances: values(balances).filter(isNotNil).sort(sortByBalanceId),
+      miniMetadatas: values(miniMetadatas).filter(isNotNil).sort(sortByMiniMetadataId)
+    }), shareReplay(1)));
   }
   get storedMiniMetadataMapById$() {
     return this.#storage.pipe(map(storage => keyBy(storage.miniMetadatas, m => m.id)), distinctUntilChanged(isEqual), shareReplay(1));
@@ -6257,39 +6256,35 @@ class BalancesProvider {
 
   // this is the only public method
   getBalances$(addressesByTokenId) {
-    // TODO move the getSharedObservable caching down to this.getNetworkBalances$ to prevent network-level subscriptions to restart when enabling/disabling other networks
-    // this will require addressesByTokenId arg to be normalized/sorted so the cache key can be compared properly, seems a bit random atm
-    return getSharedObservable("BalancesProvider.getBalances$", addressesByTokenId, () => {
-      return this.cleanupAddressesByTokenId(addressesByTokenId).pipe(map(
-      // split by network
-      addressesByTokenId => toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
-        const networkId = parseTokenId(tokenId).networkId;
-        if (!acc[networkId]) acc[networkId] = {};
-        acc[networkId][tokenId] = addresses;
-        return acc;
-      }, {})), switchMap(addressesByTokenIdByNetworkId =>
-      // fetch balances and start a 30s timer to mark the whole subscription live after 30s
-      combineLatest({
-        isStale: timer(30_000).pipe(map(() => true), startWith(false)),
-        results: combineLatest(toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
-      })), map(
-      // combine
-      ({
-        isStale,
-        results
-      }) => ({
-        status: !isStale && results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
-          ...b,
-          status: "stale"
-        } : b)).sort((a, b) => getBalanceId(a).localeCompare(getBalanceId(b)))
-      })), startWith({
-        status: "initialising",
-        balances: this.getStoredBalances(addressesByTokenId)
-      }), distinctUntilChanged(isEqual));
-    });
+    return this.cleanupAddressesByTokenId$(addressesByTokenId).pipe(map(
+    // split by network
+    addressesByTokenId => toPairs(addressesByTokenId).reduce((acc, [tokenId, addresses]) => {
+      const networkId = parseTokenId(tokenId).networkId;
+      if (!acc[networkId]) acc[networkId] = {};
+      acc[networkId][tokenId] = addresses;
+      return acc;
+    }, {})), switchMap(addressesByTokenIdByNetworkId =>
+    // fetch balances and start a 30s timer to mark the whole subscription live after 30s
+    combineLatest({
+      isStale: timer(30_000).pipe(map(() => true), startWith(false)),
+      results: combineLatest(toPairs(addressesByTokenIdByNetworkId).map(([networkId]) => this.getNetworkBalances$(networkId, addressesByTokenIdByNetworkId[networkId])))
+    })), map(
+    // combine
+    ({
+      isStale,
+      results
+    }) => ({
+      status: !isStale && results.some(({
+        status
+      }) => status === "initialising") ? "initialising" : "live",
+      balances: results.flatMap(result => result.balances.map(b => isStale && b.status !== "live" ? {
+        ...b,
+        status: "stale"
+      } : b)).sort(sortByBalanceId)
+    })), startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByTokenId)
+    }), distinctUntilChanged(isEqual));
   }
   fetchBalances(addressesByTokenId) {
     // TODO: better
@@ -6300,84 +6295,95 @@ class BalancesProvider {
     }) => balances)));
   }
   getNetworkBalances$(networkId, addressesByTokenId) {
-    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
-    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
-    const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
-    return combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(switchMap(([network, miniMetadatas, tokensMapById]) => {
-      const tokensAndAddresses = toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
-      return combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
-        const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
-        const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
-        const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
-
-        // all balance ids expected in result set
-        const balanceIds = toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
-          tokenId,
-          address
-        })));
-        const initValue = {
-          status: "initialising",
-          balances: this.getStoredBalances(moduleAddressesByTokenId)
-        };
+    return getSharedObservable(`BalancesProvider.getNetorkBalances$`, {
+      networkId,
+      addressesByTokenId
+    }, () => {
+      const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+      const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+      const miniMetadatas$ = this.getNetworkMiniMetadatas$(networkId);
+      return combineLatest([network$, miniMetadatas$, tokensMapById$]).pipe(switchMap(([network, miniMetadatas, tokensMapById]) => {
+        const tokensAndAddresses = toPairs(addressesByTokenId).map(([tokenId, addresses]) => [tokensMapById[tokenId], addresses]);
+        return combineLatest(BALANCE_MODULES.filter(mod => mod.platform === network?.platform).map(mod => {
+          const tokensWithAddresses = tokensAndAddresses.filter(([token]) => token.type === mod.type);
+          const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+          const miniMetadata = miniMetadatas.find(m => m.source === mod.type);
+
+          // all balance ids expected in result set
+          const balanceIds = toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+            tokenId,
+            address
+          })));
+          const initValue = {
+            status: "initialising",
+            balances: this.getStoredBalances(moduleAddressesByTokenId)
+          };
 
-        // updating storage has to be done on a per-module basis, so we know which balances can be deleted
-        const updateStorage = results => {
-          if (results.status !== "live") return;
-          const storage = this.#storage.getValue();
-          const balances = assign({}, storage.balances,
-          // delete all balances expected in the result set. because if they are not present it means they are empty.
-          fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), keyBy(
-          // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
-          results.balances.map(b => ({
-            ...b,
-            status: "cache"
-          })), b => getBalanceId(b)));
-          this.#storage.next(assign({}, storage, {
-            balances
-          }));
-        };
-        switch (mod.platform) {
-          case "ethereum":
-            {
-              if (!this.#chainConnectors.evm) return of(initValue);
+          // updating storage has to be done on a per-module basis, so we know which balances can be deleted
+          const updateStorage = results => {
+            if (results.status !== "live") return;
+            const storage = this.#storage.getValue();
+            const balances = assign({}, storage.balances,
+            // delete all balances expected in the result set. because if they are not present it means they are empty.
+            fromPairs(balanceIds.map(balanceId => [balanceId, undefined])), keyBy(
+            // storage balances must have status "cache", because they are used as start value when initialising subsequent subscriptions
+            results.balances.map(b => ({
+              ...b,
+              status: "cache"
+            })), b => getBalanceId(b)));
+            this.#storage.next(assign({}, storage, {
+              balances
+            }));
+          };
+          switch (mod.platform) {
+            case "ethereum":
+              {
+                if (!this.#chainConnectors.evm) return of(initValue);
+                return mod.subscribeBalances({
+                  networkId,
+                  tokensWithAddresses,
+                  connector: this.#chainConnectors.evm
+                }).pipe(map(results => ({
+                  status: "live",
+                  // exclude zero balances
+                  balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+                })), tap(updateStorage), startWith(initValue));
+              }
+            case "polkadot":
+              if (!this.#chainConnectors.substrate || !miniMetadata) {
+                log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
+                return of(initValue);
+              }
               return mod.subscribeBalances({
                 networkId,
                 tokensWithAddresses,
-                connector: this.#chainConnectors.evm
+                connector: this.#chainConnectors.substrate,
+                miniMetadata: miniMetadata
               }).pipe(map(results => ({
                 status: "live",
                 // exclude zero balances
                 balances: results.success.filter(b => new Balance(b).total.planck > 0n)
               })), tap(updateStorage), startWith(initValue));
-            }
-          case "polkadot":
-            if (!this.#chainConnectors.substrate || !miniMetadata) {
-              log.debug("[balances] no substrate connector or miniMetadata for polkadot", mod.type);
-              return of(initValue);
-            }
-            return mod.subscribeBalances({
-              networkId,
-              tokensWithAddresses,
-              connector: this.#chainConnectors.substrate,
-              miniMetadata: miniMetadata
-            }).pipe(map(results => ({
-              status: "live",
-              // exclude zero balances
-              balances: results.success.filter(b => new Balance(b).total.planck > 0n)
-            })), tap(updateStorage), startWith(initValue));
-        }
-      }));
-    }), map(results => {
-      return {
-        status: results.some(({
-          status
-        }) => status === "initialising") ? "initialising" : "live",
-        balances: results.flatMap(result => result.balances)
-      };
-    }), startWith({
-      status: "initialising",
-      balances: this.getStoredBalances(addressesByTokenId)
-    }));
+          }
+        }));
+      }), map(results => {
+        return {
+          status: results.some(({
+            status
+          }) => status === "initialising") ? "initialising" : "live",
+          balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+        };
+      }), startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(addressesByTokenId)
+      }), distinctUntilChanged(isEqual),
+      // shareReplay + keepAlive allow for subscription to not restart as long as the inputs dont change
+      // for example, if another network is enabled/disabled
+      shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), keepAlive(2_000));
+    });
   }
   getNetworkMiniMetadatas$(networkId) {
     return this.#chaindataProvider.getNetworkById$(networkId).pipe(switchMap(network => isNetworkDot(network) && this.#chainConnectors.substrate ? from(getSpecVersion(this.#chainConnectors.substrate, networkId)).pipe(switchMap(specVersion => this.getMiniMetadatas$(networkId, specVersion))) : of([])));
@@ -6412,13 +6418,17 @@ class BalancesProvider {
           miniMetadatas
         }));
       }));
-    }));
+    }),
+    // emit only when mini metadata changes, as a change here would restart all subscriptions for the network
+    distinctUntilChanged(isEqual));
   }
   getStoredMiniMetadatas$(miniMetadataIds) {
     return this.storedMiniMetadataMapById$.pipe(map(mapById => {
       const miniMetadatas = miniMetadataIds.map(id => mapById[id]);
       return miniMetadatas.length && miniMetadatas.every(isTruthy) ? miniMetadatas : null;
-    }));
+    }),
+    // source changes very often
+    distinctUntilChanged(isEqual));
   }
   getDefaultMiniMetadatas$(miniMetadataIds) {
     return this.#chaindataProvider.miniMetadatasMapById$.pipe(map(mapById => {
@@ -6431,9 +6441,9 @@ class BalancesProvider {
     return balanceDefs.map(([tokenId, address]) => this.#storage.value.balances[getBalanceId({
       address,
       tokenId
-    })]).filter(isNotNil).sort((a, b) => getBalanceId(a).localeCompare(getBalanceId(b)));
+    })]).filter(isNotNil).sort(sortByBalanceId);
   }
-  cleanupAddressesByTokenId(addressesByTokenId) {
+  cleanupAddressesByTokenId$(addressesByTokenId) {
     return this.#chaindataProvider.getNetworksMapById$().pipe(map(networksById => {
       return fromPairs(toPairs(addressesByTokenId).map(([tokenId, addresses]) => {
         const networkId = parseTokenId(tokenId).networkId;
@@ -6454,5 +6464,7 @@ const isAddressCompatibleWithNetwork = (network, address) => {
       throw new Error("Unsupported network platform");
   }
 };
+const sortByBalanceId = (a, b) => getBalanceId(a).localeCompare(getBalanceId(b));
+const sortByMiniMetadataId = (a, b) => a.id.localeCompare(b.id);
 
 export { BALANCE_MODULES, Balance, BalanceFormatter, BalanceValueGetter, Balances, BalancesProvider, Change24hCurrencyFormatter, EvmErc20BalanceModule, EvmErc20TokenConfigSchema, EvmNativeBalanceModule, EvmNativeTokenConfigSchema, EvmUniswapV2BalanceModule, EvmUniswapV2TokenConfigSchema, FiatSumBalancesFormatter, ONE_ALPHA_TOKEN, PlanckSumBalancesFormatter, SCALE_FACTOR, SUBTENSOR_MIN_STAKE_AMOUNT_PLANK, SUBTENSOR_ROOT_NETUID, SubAssetsBalanceModule, SubAssetsTokenConfigSchema, SubForeignAssetsBalanceModule, SubForeignAssetsTokenConfigSchema, SubHydrationBalanceModule, SubHydrationTokenConfigSchema, SubNativeBalanceModule, SubNativeMiniMetadataExtraSchema, SubNativeModuleConfigSchema, SubNativeTokenConfigSchema, SubPsp22BalanceModule, SubPsp22TokenConfigSchema, SubTokensBalanceModule, SubTokensMiniMetadataExtraSchema, SubTokensModuleConfigSchema, SubTokensTokenConfigSchema, SumBalancesFormatter, abiMulticall, calculateAlphaPrice, calculateTaoAmountFromAlpha, calculateTaoFromDynamicInfo, deriveMiniMetadataId, erc20BalancesAggregatorAbi, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterBaseLocks, filterMirrorTokens, getBalanceId, getLockTitle, getLockedType, getValueId, includeInTotalExtraAmount, isAddressCompatibleWithNetwork, uniswapV2PairAbi };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances",
-  "version": "0.0.0-pr2075-20250710091134",
+  "version": "0.0.0-pr2075-20250710124714",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -34,13 +34,13 @@
     "scale-ts": "^1.6.1",
     "viem": "^2.27.3",
     "zod": "^3.25.62",
-    "@talismn/chain-connector": "0.0.0-pr2075-20250710091134",
-    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250710091134",
-    "@talismn/chaindata-provider": "0.0.0-pr2075-20250710091134",
-    "@talismn/sapi": "0.0.0-pr2075-20250710091134",
-    "@talismn/token-rates": "0.0.0-pr2075-20250710091134",
-    "@talismn/util": "0.0.0-pr2075-20250710091134",
-    "@talismn/scale": "0.0.0-pr2075-20250710091134"
+    "@talismn/chain-connector": "0.0.0-pr2075-20250710124714",
+    "@talismn/chaindata-provider": "0.0.0-pr2075-20250710124714",
+    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250710124714",
+    "@talismn/sapi": "0.0.0-pr2075-20250710124714",
+    "@talismn/token-rates": "0.0.0-pr2075-20250710124714",
+    "@talismn/util": "0.0.0-pr2075-20250710124714",
+    "@talismn/scale": "0.0.0-pr2075-20250710124714"
   },
   "devDependencies": {
     "@polkadot/api-contract": "16.1.2",
@@ -55,8 +55,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": "*",