@talismn/balances 0.0.0-pr2075-20250714011912 → 0.0.0-pr2075-20250714084622

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

@@ -19,6 +19,9 @@ export declare class BalancesProvider {
     getBalances$(addressesByTokenId: Record<TokenId, Address[]>): Observable<BalancesResult>;
     fetchBalances(addressesByTokenId: Record<TokenId, Address[]>): Promise<IBalance[]>;
     private getNetworkBalances$;
+    private getPolkadotNetworkModuleBalances$;
+    private getEthereumNetworkModuleBalances$;
+    private updateStorage$;
     private getNetworkMiniMetadatas$;
     private getNetworkSpecVersion$;
     private getMiniMetadatas$;

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

@@ -6296,7 +6296,6 @@ class BalancesProvider {
     })), rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   fetchBalances(addressesByTokenId) {
-    // TODO: better
     return rxjs.firstValueFrom(this.getBalances$(addressesByTokenId).pipe(rxjs.filter(({
       status
     }) => status === "live"), rxjs.map(({
@@ -6304,103 +6303,156 @@ class BalancesProvider {
     }) => balances)));
   }
   getNetworkBalances$(networkId, addressesByTokenId) {
-    return util.getSharedObservable(`BalancesProvider.getNetorkBalances$`, {
+    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+    const networkBalances$ = rxjs.combineLatest([network$, tokensMapById$]).pipe(rxjs.switchMap(([network, 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);
+        switch (mod.platform) {
+          case "ethereum":
+            {
+              return this.getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
+          case "polkadot":
+            {
+              return this.getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
+        }
+      }));
+    }), rxjs.map(results => {
+      return {
+        status: results.some(({
+          status
+        }) => status === "initialising") ? "initialising" : "live",
+        balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+      };
+    }), rxjs.distinctUntilChanged(lodashEs.isEqual));
+
+    // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+    return rxjs.defer(() => networkBalances$.pipe(rxjs.startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByTokenId)
+    })));
+  }
+  getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return util.getSharedObservable(`BalancesProvider.getPolkadotNetworkModuleBalances$`, {
       networkId,
-      addressesByTokenId
+      mod,
+      tokensWithAddresses
     }, () => {
-      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)
-          };
+      if (!tokensWithAddresses.length) return rxjs.of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
 
-          // 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.catchError(() => rxjs.EMPTY),
-                // don't emit, let provider mark balances stale
-                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.catchError(() => rxjs.EMPTY),
-              // don't emit, let provider mark balances stale
-              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));
-          }
+      // all balance ids expected in result set
+      const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.substrate) {
+        log.debug("[balances] no substrate connector or miniMetadata for module", mod.type);
+        return rxjs.defer(() => rxjs.of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
         }));
-      }), rxjs.map(results => {
-        return {
-          status: results.some(({
-            status
-          }) => status === "initialising") ? "initialising" : "live",
-          balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
-        };
-      }), rxjs.distinctUntilChanged(lodashEs.isEqual), rxjs.startWith({
+      }
+      const moduleBalances$ = this.getNetworkMiniMetadatas$(networkId).pipe(rxjs.map(miniMetadatas => miniMetadatas.find(m => m.source === mod.type)), rxjs.switchMap(miniMetadata => mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.substrate,
+        miniMetadata: miniMetadata
+      })), rxjs.catchError(() => rxjs.EMPTY),
+      // don't emit, let provider mark balances stale
+      rxjs.map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), rxjs.tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }), rxjs.shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), util.keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return rxjs.defer(() => moduleBalances$.pipe(rxjs.startWith({
         status: "initialising",
-        balances: this.getStoredBalances(addressesByTokenId)
-      }),
-      // shareReplay + keepAlive allow for this network subscription to not restart as long as the inputs don't change
-      // for example if another network is enabled/disabled, we don't want this subscription to be restarted
-      // the unsubscribe/resubscribe is instantaneous when parameters parameters change, so keepAlive 0ms does the job
-      rxjs.shareReplay({
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
+    });
+  }
+  getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return util.getSharedObservable(`BalancesProvider.getEthereumNetworkModuleBalances$`, {
+      networkId,
+      mod,
+      tokensWithAddresses
+    }, () => {
+      if (!tokensWithAddresses.length) return rxjs.of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+
+      // all balance ids expected in result set
+      const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.evm) {
+        log.debug("[balances] no ethereum connector for module", mod.type);
+        return rxjs.defer(() => rxjs.of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
+        }));
+      }
+      const moduleBalances$ = mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.evm
+      }).pipe(rxjs.catchError(() => rxjs.EMPTY),
+      // don't emit, let provider mark balances stale
+      rxjs.map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), rxjs.tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }), rxjs.shareReplay({
         refCount: true,
         bufferSize: 1
       }), util.keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return rxjs.defer(() => moduleBalances$.pipe(rxjs.startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
     });
   }
+  updateStorage$(balanceIds, balancesResult) {
+    if (balancesResult.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
+    balancesResult.balances.map(b => ({
+      ...b,
+      status: "cache"
+    })), b => getBalanceId(b)));
+    this.#storage.next(lodashEs.assign({}, storage, {
+      balances
+    }));
+  }
   getNetworkMiniMetadatas$(networkId) {
-    return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(rxjs.switchMap(specVersion => specVersion === null ? rxjs.of([]) : this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])), rxjs.distinctUntilChanged(lodashEs.isEqual));
+    return util.getSharedObservable(`BalancesProvider.getNetworkMiniMetadatas$`, {
+      networkId
+    }, () => {
+      return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(rxjs.switchMap(specVersion => specVersion === null ? rxjs.of([]) : this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])), rxjs.distinctUntilChanged(lodashEs.isEqual));
+    });
   }
   getNetworkSpecVersion$(networkId) {
     return rxjs.from(viem.withRetry(() => getSpecVersion(this.#chainConnectors.substrate, networkId), {

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

@@ -6296,7 +6296,6 @@ class BalancesProvider {
     })), rxjs.distinctUntilChanged(lodashEs.isEqual));
   }
   fetchBalances(addressesByTokenId) {
-    // TODO: better
     return rxjs.firstValueFrom(this.getBalances$(addressesByTokenId).pipe(rxjs.filter(({
       status
     }) => status === "live"), rxjs.map(({
@@ -6304,103 +6303,156 @@ class BalancesProvider {
     }) => balances)));
   }
   getNetworkBalances$(networkId, addressesByTokenId) {
-    return util.getSharedObservable(`BalancesProvider.getNetorkBalances$`, {
+    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+    const networkBalances$ = rxjs.combineLatest([network$, tokensMapById$]).pipe(rxjs.switchMap(([network, 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);
+        switch (mod.platform) {
+          case "ethereum":
+            {
+              return this.getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
+          case "polkadot":
+            {
+              return this.getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
+        }
+      }));
+    }), rxjs.map(results => {
+      return {
+        status: results.some(({
+          status
+        }) => status === "initialising") ? "initialising" : "live",
+        balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+      };
+    }), rxjs.distinctUntilChanged(lodashEs.isEqual));
+
+    // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+    return rxjs.defer(() => networkBalances$.pipe(rxjs.startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByTokenId)
+    })));
+  }
+  getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return util.getSharedObservable(`BalancesProvider.getPolkadotNetworkModuleBalances$`, {
       networkId,
-      addressesByTokenId
+      mod,
+      tokensWithAddresses
     }, () => {
-      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)
-          };
+      if (!tokensWithAddresses.length) return rxjs.of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
 
-          // 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.catchError(() => rxjs.EMPTY),
-                // don't emit, let provider mark balances stale
-                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.catchError(() => rxjs.EMPTY),
-              // don't emit, let provider mark balances stale
-              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));
-          }
+      // all balance ids expected in result set
+      const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.substrate) {
+        log.debug("[balances] no substrate connector or miniMetadata for module", mod.type);
+        return rxjs.defer(() => rxjs.of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
         }));
-      }), rxjs.map(results => {
-        return {
-          status: results.some(({
-            status
-          }) => status === "initialising") ? "initialising" : "live",
-          balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
-        };
-      }), rxjs.distinctUntilChanged(lodashEs.isEqual), rxjs.startWith({
+      }
+      const moduleBalances$ = this.getNetworkMiniMetadatas$(networkId).pipe(rxjs.map(miniMetadatas => miniMetadatas.find(m => m.source === mod.type)), rxjs.switchMap(miniMetadata => mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.substrate,
+        miniMetadata: miniMetadata
+      })), rxjs.catchError(() => rxjs.EMPTY),
+      // don't emit, let provider mark balances stale
+      rxjs.map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), rxjs.tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }), rxjs.shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), util.keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return rxjs.defer(() => moduleBalances$.pipe(rxjs.startWith({
         status: "initialising",
-        balances: this.getStoredBalances(addressesByTokenId)
-      }),
-      // shareReplay + keepAlive allow for this network subscription to not restart as long as the inputs don't change
-      // for example if another network is enabled/disabled, we don't want this subscription to be restarted
-      // the unsubscribe/resubscribe is instantaneous when parameters parameters change, so keepAlive 0ms does the job
-      rxjs.shareReplay({
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
+    });
+  }
+  getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return util.getSharedObservable(`BalancesProvider.getEthereumNetworkModuleBalances$`, {
+      networkId,
+      mod,
+      tokensWithAddresses
+    }, () => {
+      if (!tokensWithAddresses.length) return rxjs.of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = lodashEs.fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+
+      // all balance ids expected in result set
+      const balanceIds = lodashEs.toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.evm) {
+        log.debug("[balances] no ethereum connector for module", mod.type);
+        return rxjs.defer(() => rxjs.of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
+        }));
+      }
+      const moduleBalances$ = mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.evm
+      }).pipe(rxjs.catchError(() => rxjs.EMPTY),
+      // don't emit, let provider mark balances stale
+      rxjs.map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), rxjs.tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }), rxjs.shareReplay({
         refCount: true,
         bufferSize: 1
       }), util.keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return rxjs.defer(() => moduleBalances$.pipe(rxjs.startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
     });
   }
+  updateStorage$(balanceIds, balancesResult) {
+    if (balancesResult.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
+    balancesResult.balances.map(b => ({
+      ...b,
+      status: "cache"
+    })), b => getBalanceId(b)));
+    this.#storage.next(lodashEs.assign({}, storage, {
+      balances
+    }));
+  }
   getNetworkMiniMetadatas$(networkId) {
-    return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(rxjs.switchMap(specVersion => specVersion === null ? rxjs.of([]) : this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])), rxjs.distinctUntilChanged(lodashEs.isEqual));
+    return util.getSharedObservable(`BalancesProvider.getNetworkMiniMetadatas$`, {
+      networkId
+    }, () => {
+      return this.#chaindataProvider.getNetworkById$(networkId).pipe(rxjs.switchMap(network => chaindataProvider.isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(rxjs.switchMap(specVersion => specVersion === null ? rxjs.of([]) : this.getMiniMetadatas$(networkId, specVersion))) : rxjs.of([])), rxjs.distinctUntilChanged(lodashEs.isEqual));
+    });
   }
   getNetworkSpecVersion$(networkId) {
     return rxjs.from(viem.withRetry(() => getSpecVersion(this.#chainConnectors.substrate, networkId), {

package/dist/talismn-balances.esm.js

@@ -5,7 +5,7 @@ import { parseAbi, erc20Abi, getContract, ContractFunctionExecutionError, hexToS
 import { assign, omit, isEqual, uniq, keyBy, keys, fromPairs, values, toPairs } from 'lodash-es';
 import z from 'zod/v4';
 import anylogger from 'anylogger';
-import { of, Observable, distinctUntilChanged, map, timer, switchMap, from, firstValueFrom, combineLatest, BehaviorSubject, shareReplay, startWith, filter, catchError, EMPTY, tap } from 'rxjs';
+import { of, Observable, distinctUntilChanged, map, timer, switchMap, from, firstValueFrom, combineLatest, BehaviorSubject, shareReplay, startWith, filter, defer, catchError, EMPTY, tap } from 'rxjs';
 import BigNumber from 'bignumber.js';
 import { parseMetadataRpc, toHex, unifyMetadata, decAnyMetadata, getDynamicBuilder, getLookupFn, decodeScale, getStorageKeyPrefix, Twox128, compactMetadata, encodeMetadata, papiParse, papiStringify } from '@talismn/scale';
 import { newTokenRates } from '@talismn/token-rates';
@@ -6287,7 +6287,6 @@ class BalancesProvider {
     })), distinctUntilChanged(isEqual));
   }
   fetchBalances(addressesByTokenId) {
-    // TODO: better
     return firstValueFrom(this.getBalances$(addressesByTokenId).pipe(filter(({
       status
     }) => status === "live"), map(({
@@ -6295,103 +6294,156 @@ class BalancesProvider {
     }) => balances)));
   }
   getNetworkBalances$(networkId, addressesByTokenId) {
-    return getSharedObservable(`BalancesProvider.getNetorkBalances$`, {
+    const network$ = this.#chaindataProvider.getNetworkById$(networkId);
+    const tokensMapById$ = this.#chaindataProvider.getTokensMapById$();
+    const networkBalances$ = combineLatest([network$, tokensMapById$]).pipe(switchMap(([network, 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);
+        switch (mod.platform) {
+          case "ethereum":
+            {
+              return this.getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
+          case "polkadot":
+            {
+              return this.getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod);
+            }
+        }
+      }));
+    }), map(results => {
+      return {
+        status: results.some(({
+          status
+        }) => status === "initialising") ? "initialising" : "live",
+        balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
+      };
+    }), distinctUntilChanged(isEqual));
+
+    // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+    return defer(() => networkBalances$.pipe(startWith({
+      status: "initialising",
+      balances: this.getStoredBalances(addressesByTokenId)
+    })));
+  }
+  getPolkadotNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return getSharedObservable(`BalancesProvider.getPolkadotNetworkModuleBalances$`, {
       networkId,
-      addressesByTokenId
+      mod,
+      tokensWithAddresses
     }, () => {
-      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)
-          };
+      if (!tokensWithAddresses.length) return of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
 
-          // 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(catchError(() => EMPTY),
-                // don't emit, let provider mark balances stale
-                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(catchError(() => EMPTY),
-              // don't emit, let provider mark balances stale
-              map(results => ({
-                status: "live",
-                // exclude zero balances
-                balances: results.success.filter(b => new Balance(b).total.planck > 0n)
-              })), tap(updateStorage), startWith(initValue));
-          }
+      // all balance ids expected in result set
+      const balanceIds = toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.substrate) {
+        log.debug("[balances] no substrate connector or miniMetadata for module", mod.type);
+        return defer(() => of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
         }));
-      }), map(results => {
-        return {
-          status: results.some(({
-            status
-          }) => status === "initialising") ? "initialising" : "live",
-          balances: results.flatMap(result => result.balances).sort(sortByBalanceId)
-        };
-      }), distinctUntilChanged(isEqual), startWith({
+      }
+      const moduleBalances$ = this.getNetworkMiniMetadatas$(networkId).pipe(map(miniMetadatas => miniMetadatas.find(m => m.source === mod.type)), switchMap(miniMetadata => mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.substrate,
+        miniMetadata: miniMetadata
+      })), catchError(() => EMPTY),
+      // don't emit, let provider mark balances stale
+      map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }), shareReplay({
+        refCount: true,
+        bufferSize: 1
+      }), keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return defer(() => moduleBalances$.pipe(startWith({
         status: "initialising",
-        balances: this.getStoredBalances(addressesByTokenId)
-      }),
-      // shareReplay + keepAlive allow for this network subscription to not restart as long as the inputs don't change
-      // for example if another network is enabled/disabled, we don't want this subscription to be restarted
-      // the unsubscribe/resubscribe is instantaneous when parameters parameters change, so keepAlive 0ms does the job
-      shareReplay({
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
+    });
+  }
+  getEthereumNetworkModuleBalances$(networkId, tokensWithAddresses, mod) {
+    return getSharedObservable(`BalancesProvider.getEthereumNetworkModuleBalances$`, {
+      networkId,
+      mod,
+      tokensWithAddresses
+    }, () => {
+      if (!tokensWithAddresses.length) return of({
+        status: "live",
+        balances: []
+      });
+      const moduleAddressesByTokenId = fromPairs(tokensWithAddresses.map(([token, addresses]) => [token.id, addresses]));
+
+      // all balance ids expected in result set
+      const balanceIds = toPairs(moduleAddressesByTokenId).flatMap(([tokenId, addresses]) => addresses.map(address => getBalanceId({
+        tokenId,
+        address
+      })));
+      if (!this.#chainConnectors.evm) {
+        log.debug("[balances] no ethereum connector for module", mod.type);
+        return defer(() => of({
+          status: "initialising",
+          balances: this.getStoredBalances(moduleAddressesByTokenId)
+        }));
+      }
+      const moduleBalances$ = mod.subscribeBalances({
+        networkId,
+        tokensWithAddresses,
+        connector: this.#chainConnectors.evm
+      }).pipe(catchError(() => EMPTY),
+      // don't emit, let provider mark balances stale
+      map(results => ({
+        status: "live",
+        // exclude zero balances
+        balances: results.success.filter(b => new Balance(b).total.planck > 0n)
+      })), tap(results => {
+        this.updateStorage$(balanceIds, results);
+      }), shareReplay({
         refCount: true,
         bufferSize: 1
       }), keepAlive(0));
+
+      // defer the startWith call to start with up to date balances each time the observable is re-subscribed to
+      return defer(() => moduleBalances$.pipe(startWith({
+        status: "initialising",
+        balances: this.getStoredBalances(moduleAddressesByTokenId)
+      })));
     });
   }
+  updateStorage$(balanceIds, balancesResult) {
+    if (balancesResult.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
+    balancesResult.balances.map(b => ({
+      ...b,
+      status: "cache"
+    })), b => getBalanceId(b)));
+    this.#storage.next(assign({}, storage, {
+      balances
+    }));
+  }
   getNetworkMiniMetadatas$(networkId) {
-    return this.#chaindataProvider.getNetworkById$(networkId).pipe(switchMap(network => isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(switchMap(specVersion => specVersion === null ? of([]) : this.getMiniMetadatas$(networkId, specVersion))) : of([])), distinctUntilChanged(isEqual));
+    return getSharedObservable(`BalancesProvider.getNetworkMiniMetadatas$`, {
+      networkId
+    }, () => {
+      return this.#chaindataProvider.getNetworkById$(networkId).pipe(switchMap(network => isNetworkDot(network) ? this.getNetworkSpecVersion$(networkId).pipe(switchMap(specVersion => specVersion === null ? of([]) : this.getMiniMetadatas$(networkId, specVersion))) : of([])), distinctUntilChanged(isEqual));
+    });
   }
   getNetworkSpecVersion$(networkId) {
     return from(withRetry(() => getSpecVersion(this.#chainConnectors.substrate, networkId), {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/balances",
-  "version": "0.0.0-pr2075-20250714011912",
+  "version": "0.0.0-pr2075-20250714084622",
   "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-20250714011912",
-    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250714011912",
-    "@talismn/chaindata-provider": "0.0.0-pr2075-20250714011912",
-    "@talismn/sapi": "0.0.0-pr2075-20250714011912",
-    "@talismn/scale": "0.0.0-pr2075-20250714011912",
-    "@talismn/token-rates": "0.0.0-pr2075-20250714011912",
-    "@talismn/util": "0.0.0-pr2075-20250714011912"
+    "@talismn/chain-connector": "0.0.0-pr2075-20250714084622",
+    "@talismn/token-rates": "0.0.0-pr2075-20250714084622",
+    "@talismn/chaindata-provider": "0.0.0-pr2075-20250714084622",
+    "@talismn/chain-connector-evm": "0.0.0-pr2075-20250714084622",
+    "@talismn/sapi": "0.0.0-pr2075-20250714084622",
+    "@talismn/util": "0.0.0-pr2075-20250714084622",
+    "@talismn/scale": "0.0.0-pr2075-20250714084622"
   },
   "devDependencies": {
     "@polkadot/api-contract": "16.1.2",