@talismn/balances 0.3.3 → 0.4.1

package/dist/talismn-balances.esm.js

@@ -1,13 +1,8 @@
 import { Dexie } from 'dexie';
-import { decorateStorage, StorageKey } from '@polkadot/types';
+import { decorateStorage, StorageKey, TypeRegistry, Metadata } from '@polkadot/types';
+import { hasOwnProperty, BigMath, isArrayOf, planckToTokens } from '@talismn/util';
+import groupBy from 'lodash/groupBy';
 import anylogger from 'anylogger';
-import { BigMath, isArrayOf, planckToTokens } from '@talismn/util';
-import memoize from 'lodash/memoize';
-import { Memoize } from 'typescript-memoize';
-
-//
-// exported
-//
 
 // TODO: Document default balances module purpose/usage
 const DefaultBalanceModule = type => ({
@@ -26,12 +21,15 @@ const DefaultBalanceModule = type => ({
   async fetchEvmChainTokens() {
     return Promise.resolve({});
   },
-  async subscribeBalances(_chainConnectors, _chaindataProvider, _addressesByToken, callback) {
+  async subscribeBalances(_, callback) {
     callback(new Error("Balance subscriptions are not implemented in this module."));
     return () => {};
   },
   async fetchBalances() {
     throw new Error("Balance fetching is not implemented in this module.");
+  },
+  async transferToken() {
+    throw new Error("Token transfers are not implemented in this module.");
   }
 });
 
@@ -62,7 +60,7 @@ const db = new TalismanBalancesDatabase();
 
 var packageJson = {
 	name: "@talismn/balances",
-	version: "0.3.3",
+	version: "0.4.1",
 	author: "Talisman",
 	homepage: "https://talisman.xyz",
 	license: "UNLICENSED",
@@ -81,36 +79,36 @@ var packageJson = {
 		"/plugins"
 	],
 	engines: {
-		node: ">=14"
+		node: ">=18"
 	},
 	scripts: {
 		test: "jest",
-		lint: "eslint . --max-warnings 0",
+		lint: "eslint src --max-warnings 0",
 		clean: "rm -rf dist && rm -rf .turbo rm -rf node_modules"
 	},
 	dependencies: {
-		"@talismn/chain-connector": "workspace:^",
-		"@talismn/chain-connector-evm": "workspace:^",
-		"@talismn/chaindata-provider": "workspace:^",
-		"@talismn/token-rates": "workspace:^",
-		"@talismn/util": "workspace:^",
+		"@talismn/chain-connector": "workspace:*",
+		"@talismn/chain-connector-evm": "workspace:*",
+		"@talismn/chaindata-provider": "workspace:*",
+		"@talismn/token-rates": "workspace:*",
+		"@talismn/util": "workspace:*",
 		anylogger: "^1.0.11",
-		dexie: "^3.2.2",
-		lodash: "^4.17.21",
-		"typescript-memoize": "^1.1.0"
+		dexie: "^3.2.3",
+		lodash: "4.17.21"
 	},
 	devDependencies: {
-		"@polkadot/types": "^9.10.5",
-		"@talismn/eslint-config": "workspace:^",
-		"@talismn/tsconfig": "workspace:^",
+		"@polkadot/types": "^10.1.4",
+		"@talismn/eslint-config": "workspace:*",
+		"@talismn/tsconfig": "workspace:*",
 		"@types/jest": "^27.5.1",
+		"@types/lodash": "^4.14.180",
 		eslint: "^8.4.0",
 		jest: "^28.1.0",
 		"ts-jest": "^28.0.2",
 		typescript: "^4.6.4"
 	},
 	peerDependencies: {
-		"@polkadot/types": "9.x"
+		"@polkadot/types": "10.x"
 	},
 	preconstruct: {
 		entrypoints: [
@@ -128,18 +126,114 @@ var packageJson = {
 
 var log = anylogger(packageJson.name);
 
-async function balances(balanceModule, chainConnectors, chaindataProvider, addressesByToken, callback) {
+/**
+ * Wraps a BalanceModule's fetch/subscribe methods with a single `balances` method.
+ * This `balances` method will subscribe if a callback parameter is provided, or otherwise fetch.
+ */
+
+async function balances(balanceModule, addressesByToken, callback) {
   // subscription request
-  if (callback !== undefined) return await balanceModule.subscribeBalances(chainConnectors, chaindataProvider, addressesByToken, callback);
+  if (callback !== undefined) return await balanceModule.subscribeBalances(addressesByToken, callback);
 
   // one-off request
-  return await balanceModule.fetchBalances(chainConnectors, chaindataProvider, addressesByToken);
+  return await balanceModule.fetchBalances(addressesByToken);
 }
+const createTypeRegistryCache = () => {
+  const typeRegistryCache = new Map();
+  const getOrCreateTypeRegistry = (chainId, metadataRpc) => {
+    // TODO: Delete cache when metadataRpc is different from last time
+    const cached = typeRegistryCache.get(chainId);
+    if (cached) return cached;
+    const typeRegistry = new TypeRegistry();
+    if (typeof metadataRpc === "string") {
+      try {
+        const metadata = new Metadata(typeRegistry, metadataRpc);
+        metadata.registry.setMetadata(metadata);
+      } catch (cause) {
+        log.warn(new Error(`Failed to set metadata for chain ${chainId}`, {
+          cause
+        }), cause);
+      }
+    }
+    typeRegistryCache.set(chainId, typeRegistry);
+    return typeRegistry;
+  };
+  return {
+    getOrCreateTypeRegistry
+  };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+/**
+ * The following `Infer*` collection of generic types can be used when you want to
+ * extract one of the generic type arguments from an existing BalanceModule.
+ *
+ * For example, you might want to write a function which can accept any BalanceModule
+ * as an input, and then return the specific TokenType for that module:
+ * function getTokens<T extends AnyBalanceModule>(module: T): InferTokenType<T>
+ *
+ * Or for another example, you might want a function which can take any BalanceModule `type`
+ * string as input, and then return some data associated with that module with the correct type:
+ * function getChainMeta<T extends AnyBalanceModule>(type: InferModuleType<T>): InferChainMeta<T> | undefined
+ */
+
+/**
+ * Given a `moduleType` and a `chain` from a chaindataProvider, this function will find the chainMeta
+ * associated with the given balanceModule for the given chain.
+ */
+const findChainMeta = (moduleType, chain) => {
+  return (chain?.balanceMetadata ?? []).find(meta => meta.moduleType === moduleType)?.metadata;
+};
 const filterMirrorTokens = (balance, i, balances) => {
-  // TODO implement a mirrorOf property, which should be set from chaindata
   const mirrorOf = balance.token?.mirrorOf;
   return !mirrorOf || !balances.find(b => b.tokenId === mirrorOf);
 };
+const getValidSubscriptionIds = () => {
+  return new Set(localStorage.getItem("TalismanBalancesSubscriptionIds")?.split(",") ?? []);
+};
+const createSubscriptionId = () => {
+  // delete current id (if exists)
+  deleteSubscriptionId();
+
+  // create new id
+  const subscriptionId = Date.now().toString();
+  sessionStorage.setItem("TalismanBalancesSubscriptionId", subscriptionId);
+
+  // add to list of current ids
+  const subscriptionIds = getValidSubscriptionIds();
+  subscriptionIds.add(subscriptionId);
+  localStorage.setItem("TalismanBalancesSubscriptionIds", [...subscriptionIds].filter(Boolean).join(","));
+  return subscriptionId;
+};
+const deleteSubscriptionId = () => {
+  const subscriptionId = sessionStorage.getItem("TalismanBalancesSubscriptionId");
+  if (!subscriptionId) return;
+  const subscriptionIds = getValidSubscriptionIds();
+  subscriptionIds.delete(subscriptionId);
+  localStorage.setItem("TalismanBalancesSubscriptionIds", [...subscriptionIds].filter(Boolean).join(","));
+};
+
+/**
+ * Sets all balance statuses from `live-${string}` to either `live` or `cached`
+ */
+const deriveStatuses = (validSubscriptionIds, balances) => balances.map(balance => {
+  if (balance.status === "live" || balance.status === "cache" || balance.status === "stale") return balance;
+  if (validSubscriptionIds.length < 1) return {
+    ...balance,
+    status: "cache"
+  };
+  if (!validSubscriptionIds.includes(balance.status.slice("live-".length))) return {
+    ...balance,
+    status: "cache"
+  };
+  return {
+    ...balance,
+    status: "live"
+  };
+});
 
 /**
  * Used by a variety of balance modules to help encode and decode substrate state calls.
@@ -150,7 +244,11 @@ class StorageHelper {
   #module;
   #method;
   #parameters;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   tags = null;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(registry, module, method, ...parameters) {
     this.#registry = registry;
     this.#module = module;
@@ -184,6 +282,8 @@ class StorageHelper {
   get parameters() {
     return this.#parameters;
   }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   tag(tags) {
     this.tags = tags;
     return this;
@@ -222,34 +322,106 @@ class StorageHelper {
   }
 }
 
-function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) {
-  var desc = {};
-  Object.keys(descriptor).forEach(function (key) {
-    desc[key] = descriptor[key];
-  });
-  desc.enumerable = !!desc.enumerable;
-  desc.configurable = !!desc.configurable;
-  if ('value' in desc || desc.initializer) {
-    desc.writable = true;
-  }
-  desc = decorators.slice().reverse().reduce(function (desc, decorator) {
-    return decorator(target, property, desc) || desc;
-  }, desc);
-  if (context && desc.initializer !== void 0) {
-    desc.value = desc.initializer ? desc.initializer.call(context) : void 0;
-    desc.initializer = undefined;
-  }
-  if (desc.initializer === void 0) {
-    Object.defineProperty(target, property, desc);
-    desc = null;
-  }
-  return desc;
+/**
+ * Pass some these into an `RpcStateQueryHelper` in order to easily batch multiple state queries into the one rpc call.
+ */
+
+/**
+ * Used by a variety of balance modules to help batch multiple state queries into the one rpc call.
+ */
+class RpcStateQueryHelper {
+  #chainConnector;
+  #queries;
+  constructor(chainConnector, queries) {
+    this.#chainConnector = chainConnector;
+    this.#queries = queries;
+  }
+  async subscribe(callback, timeout = false, subscribeMethod = "state_subscribeStorage", responseMethod = "state_storage", unsubscribeMethod = "state_unsubscribeStorage") {
+    const queriesByChain = groupBy(this.#queries, "chainId");
+    const subscriptions = Object.entries(queriesByChain).map(([chainId, queries]) => {
+      const params = [queries.map(({
+        stateKey
+      }) => stateKey)];
+      const unsub = this.#chainConnector.subscribe(chainId, subscribeMethod, responseMethod, params, (error, result) => {
+        error ? callback(error) : callback(null, this.#distributeChangesToQueryDecoders.call(this, chainId, result));
+      }, timeout);
+      return () => unsub.then(unsubscribe => unsubscribe(unsubscribeMethod));
+    });
+    return () => subscriptions.forEach(unsubscribe => unsubscribe());
+  }
+  async fetch(method = "state_queryStorageAt") {
+    const queriesByChain = groupBy(this.#queries, "chainId");
+    const resultsByChain = await Promise.all(Object.entries(queriesByChain).map(async ([chainId, queries]) => {
+      const params = [queries.map(({
+        stateKey
+      }) => stateKey)];
+      const result = (await this.#chainConnector.send(chainId, method, params))[0];
+      return this.#distributeChangesToQueryDecoders.call(this, chainId, result);
+    }));
+    return resultsByChain.flatMap(result => result);
+  }
+  #distributeChangesToQueryDecoders(chainId, result) {
+    if (typeof result !== "object" || result === null) return [];
+    if (!hasOwnProperty(result, "changes") || typeof result.changes !== "object") return [];
+    if (!Array.isArray(result.changes)) return [];
+    return result.changes.flatMap(([reference, change]) => {
+      if (typeof reference !== "string") {
+        log.warn(`Received non-string reference in RPC result: ${reference}`);
+        return [];
+      }
+      if (typeof change !== "string" && change !== null) {
+        log.warn(`Received non-string and non-null change in RPC result: ${reference} | ${change}`);
+        return [];
+      }
+      const query = this.#queries.find(({
+        chainId: cId,
+        stateKey
+      }) => cId === chainId && stateKey === reference);
+      if (!query) {
+        log.warn(`Failed to find query:\n${reference} in\n${this.#queries.map(({
+          stateKey
+        }) => stateKey)}`);
+        return [];
+      }
+      return [query.decodeResult(change)];
+    });
+  }
 }
 
+/**
+ * `BalanceTypes` is an automatically determined sub-selection of `PluginBalanceTypes`.
+ *
+ * It is the same list, but with any invalid `BalanceType` definitions filtered out.
+ */
+
+/**
+ * The `BalanceJson` sum type, which is a union of all of the possible `BalanceTypes`.
+ *
+ * Each variant comes from a plugin in use by the consuming app.
+ *
+ * For example, in an app with the `substrate-native`, `evm-native`, `substrate-orml` and `evm-erc20` plugins:
+ *
+ *     type BalanceJson = SubNativeBalance | EvmNativeBalance | SubOrmlBalance | EvmErc20Balance
+ *
+ * If `BalanceTypes` is empty then `BalanceJson` will fall back to the common `IBalance` interface, which every balance must implement.
+ */
+
+/** A collection of `BalanceJson` objects */
+
+const BalanceStatusLive = subscriptionId => `live-${subscriptionId}`;
+
+/** `IBalance` is a common interface which all balance types must implement. */
+
+/** An unlabelled amount of a balance */
+
+/** A labelled amount of a balance */
+
+/** A labelled locked amount of a balance */
+
 function excludeFromTransferableAmount(locks) {
   if (typeof locks === "string") return BigInt(locks);
   if (!Array.isArray(locks)) locks = [locks];
-  return locks.filter(lock => lock.includeInTransferable !== true).map(lock => BigInt(lock.amount)).reduce((max, lock) => BigMath.max(max, lock), BigInt("0"));
+  return locks.filter(lock => lock.includeInTransferable !== true).map(lock => BigInt(lock.amount)).reduce((max, lock) => BigMath.max(max, lock), 0n);
 }
 function excludeFromFeePayableLocks(locks) {
   if (typeof locks === "string") return [];
@@ -260,31 +432,29 @@ function excludeFromFeePayableLocks(locks) {
 /** A labelled extra amount of a balance */
 
 function includeInTotalExtraAmount(extra) {
-  if (!extra) return BigInt("0");
+  if (!extra) return 0n;
   if (!Array.isArray(extra)) extra = [extra];
-  return extra.filter(extra => extra.includeInTotal).map(extra => BigInt(extra.amount)).reduce((a, b) => a + b, BigInt("0"));
+  return extra.filter(extra => extra.includeInTotal).map(extra => BigInt(extra.amount)).reduce((a, b) => a + b, 0n);
 }
 
 /** Used by plugins to help define their custom `BalanceType` */
 
-var _dec, _dec2, _dec3, _class, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _class2, _dec11, _class3, _dec12, _dec13, _dec14, _dec15, _dec16, _dec17, _dec18, _class4;
-
 /**
  * Have the importing library define its Token and BalanceJson enums (as a sum type of all plugins) and pass them into some
  * internal global typescript context, which is then picked up on by this module.
  */
 
 /** A utility type used to extract the underlying `BalanceType` of a specific source from a generalised `BalanceJson` */
-
+/** TODO: Remove this in favour of a frontend-friendly `ChaindataProvider` */
 /**
  * A collection of balances.
  */
-let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class = class Balances {
+class Balances {
   //
   // Properties
   //
 
-  #balances = {};
+  #balances = [];
 
   //
   // Methods
@@ -292,7 +462,7 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
 
   constructor(balances, hydrate) {
     // handle Balances (convert to Balance[])
-    if (balances instanceof Balances) return new Balances([...balances], hydrate);
+    if (balances instanceof Balances) return new Balances(balances.each, hydrate);
 
     // handle Balance (convert to Balance[])
     if (balances instanceof Balance) return new Balances([balances], hydrate);
@@ -307,19 +477,19 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
     if (!isArrayOf(balances, Balance)) return new Balances(balances.map(storage => new Balance(storage)), hydrate);
 
     // handle Balance[]
-    this.#balances = Object.fromEntries(balances.map(balance => [balance.id, balance]));
+    this.#balances = balances;
     if (hydrate !== undefined) this.hydrate(hydrate);
   }
 
   /**
    * Calling toJSON on a collection of balances will return the underlying BalanceJsonList.
    */
-  toJSON = () => Object.fromEntries(Object.entries(this.#balances).map(([id, balance]) => {
+  toJSON = () => Object.fromEntries(this.#balances.map(balance => {
     try {
-      return [id, balance.toJSON()];
+      return [balance.id, balance.toJSON()];
     } catch (error) {
       log.error("Failed to convert balance to JSON", error, {
-        id,
+        id: balance.id,
         balance
       });
       return null;
@@ -339,7 +509,7 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
    */
   [Symbol.iterator] = () =>
   // Create an array of the balances in this collection and return the result of its iterator.
-  Object.values(this.#balances)[Symbol.iterator]();
+  this.#balances[Symbol.iterator]();
 
   /**
    * Hydrates all balances in this collection.
@@ -347,7 +517,7 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
    * @param sources - The sources to hydrate from.
    */
   hydrate = sources => {
-    Object.values(this.#balances).map(balance => balance.hydrate(sources));
+    this.#balances.map(balance => balance.hydrate(sources));
   };
 
   /**
@@ -356,7 +526,7 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
    * @param id - The id of the balance to fetch.
    * @returns The balance if one exists, or none.
    */
-  get = id => this.#balances[id] || null;
+  get = id => this.#balances.find(balance => balance.id === id) ?? null;
 
   /**
    * Retrieve balances from this collection by search query.
@@ -375,6 +545,27 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
     return new Balances([...this].filter(filter));
   };
 
+  /**
+   * Filters this collection to exclude token balances where the token has a `mirrorOf` field
+   * and another balance exists in this collection for the token specified by the `mirrorOf` field.
+   */
+  filterMirrorTokens = () => new Balances([...this].filter(filterMirrorTokens));
+
+  /**
+   * Filters this collection to only include balances which are not zero.
+   */
+  filterNonZero = type => {
+    const filter = balance => balance[type].planck > 0n;
+    return this.find(filter);
+  };
+  /**
+   * Filters this collection to only include balances which are not zero AND have a fiat conversion rate.
+   */
+  filterNonZeroFiat = (type, currency) => {
+    const filter = balance => (balance[type].fiat(currency) ?? 0) > 0;
+    return this.find(filter);
+  };
+
   /**
    * Add some balances to this collection.
    * Added balances take priority over existing balances.
@@ -389,10 +580,8 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
     if (balances instanceof Balance) return this.add(new Balances(balances));
 
     // merge balances
-    const mergedBalances = {
-      ...this.#balances
-    };
-    [...balances].forEach(balance => mergedBalances[balance.id] = balance);
+    const mergedBalances = Object.fromEntries(this.#balances.map(balance => [balance.id, balance]));
+    balances.each.forEach(balance => mergedBalances[balance.id] = balance);
 
     // return new balances
     return new Balances(Object.values(mergedBalances));
@@ -410,25 +599,23 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
     // handle single id
     if (!Array.isArray(ids)) return this.remove([ids]);
 
-    // merge balances
-    const removedBalances = {
-      ...this.#balances
-    };
-    ids.forEach(id => delete removedBalances[id]);
-
-    // return new balances
-    return new Balances(Object.values(removedBalances));
+    // merge and return new balances
+    return new Balances(this.#balances.filter(balance => !ids.includes(balance.id)));
   };
 
   // TODO: Add some more useful aggregator methods
 
+  get each() {
+    return [...this];
+  }
+
   /**
    * Get an array of balances in this collection, sorted by chain sortIndex.
    *
    * @returns A sorted array of the balances in this collection.
    */
   get sorted() {
-    return [...this].sort((a, b) => ((a.chain || a.evmNetwork)?.sortIndex || Number.MAX_SAFE_INTEGER) - ((b.chain || b.evmNetwork)?.sortIndex || Number.MAX_SAFE_INTEGER));
+    return [...this].sort((a, b) => ((a.chain || a.evmNetwork)?.sortIndex ?? Number.MAX_SAFE_INTEGER) - ((b.chain || b.evmNetwork)?.sortIndex ?? Number.MAX_SAFE_INTEGER));
   }
 
   /**
@@ -451,12 +638,12 @@ let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class
   get sum() {
     return new SumBalancesFormatter(this);
   }
-}, (_applyDecoratedDescriptor(_class.prototype, "sorted", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "sorted"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "count", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "count"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "sum", [_dec3], Object.getOwnPropertyDescriptor(_class.prototype, "sum"), _class.prototype)), _class));
+}
 
 /**
  * An individual balance.
  */
-let Balance = (_dec4 = Memoize(), _dec5 = Memoize(), _dec6 = Memoize(), _dec7 = Memoize(), _dec8 = Memoize(), _dec9 = Memoize(), _dec10 = Memoize(), (_class2 = class Balance {
+class Balance {
   //
   // Properties
   //
@@ -470,7 +657,6 @@ let Balance = (_dec4 = Memoize(), _dec5 = Memoize(), _dec6 = Memoize(), _dec7 =
   //
 
   constructor(storage, hydrate) {
-    this.#format = memoize(this.#format);
     this.#storage = storage;
     if (hydrate !== undefined) this.hydrate(hydrate);
   }
@@ -502,13 +688,14 @@ let Balance = (_dec4 = Memoize(), _dec5 = Memoize(), _dec6 = Memoize(), _dec7 =
   get id() {
     const {
       source,
+      subSource,
       address,
       chainId,
       evmNetworkId,
       tokenId
     } = this.#storage;
     const locationId = chainId !== undefined ? chainId : evmNetworkId;
-    return `${source}-${address}-${locationId}-${tokenId}`;
+    return [source, address, locationId, tokenId, subSource].filter(Boolean).join("-");
   }
   get source() {
     return this.#storage.source;
@@ -557,17 +744,43 @@ let Balance = (_dec4 = Memoize(), _dec5 = Memoize(), _dec6 = Memoize(), _dec7 =
   }
   /** The non-reserved balance of this token. Includes the frozen amount. Is included in the total. */
   get free() {
-    return this.#format(typeof this.#storage.free === "string" ? BigInt(this.#storage.free) : Array.isArray(this.#storage.free) ? this.#storage.free.map(reserve => BigInt(reserve.amount)).reduce((a, b) => a + b, BigInt("0")) : BigInt(this.#storage.free?.amount || "0"));
+    return this.#format(typeof this.#storage.free === "string" ? BigInt(this.#storage.free) : Array.isArray(this.#storage.free) ? this.#storage.free.map(reserve => BigInt(reserve.amount)).reduce((a, b) => a + b, 0n) : BigInt(this.#storage.free?.amount || "0"));
   }
   /** The reserved balance of this token. Is included in the total. */
   get reserved() {
-    return this.#format(typeof this.#storage.reserves === "string" ? BigInt(this.#storage.reserves) : Array.isArray(this.#storage.reserves) ? this.#storage.reserves.map(reserve => BigInt(reserve.amount)).reduce((a, b) => a + b, BigInt("0")) : BigInt(this.#storage.reserves?.amount || "0"));
+    return this.#format(typeof this.#storage.reserves === "string" ? BigInt(this.#storage.reserves) : Array.isArray(this.#storage.reserves) ? this.#storage.reserves.map(reserve => BigInt(reserve.amount)).reduce((a, b) => a + b, 0n) : BigInt(this.#storage.reserves?.amount || "0"));
+  }
+  get reserves() {
+    return (Array.isArray(this.#storage.reserves) ? this.#storage.reserves : [this.#storage.reserves]).flatMap(reserve => {
+      if (reserve === undefined) return [];
+      if (typeof reserve === "string") return {
+        label: "reserved",
+        amount: this.#format(reserve)
+      };
+      return {
+        ...reserve,
+        amount: this.#format(reserve.amount)
+      };
+    });
   }
   /** The frozen balance of this token. Is included in the free amount. */
   get locked() {
-    return this.#format(typeof this.#storage.locks === "string" ? BigInt(this.#storage.locks) : Array.isArray(this.#storage.locks) ? this.#storage.locks.map(lock => BigInt(lock.amount)).reduce((a, b) => BigMath.max(a, b), BigInt("0")) : BigInt(this.#storage.locks?.amount || "0"));
+    return this.#format(typeof this.#storage.locks === "string" ? BigInt(this.#storage.locks) : Array.isArray(this.#storage.locks) ? this.#storage.locks.map(lock => BigInt(lock.amount)).reduce((a, b) => BigMath.max(a, b), 0n) : BigInt(this.#storage.locks?.amount || "0"));
+  }
+  get locks() {
+    return (Array.isArray(this.#storage.locks) ? this.#storage.locks : [this.#storage.locks]).flatMap(lock => {
+      if (lock === undefined) return [];
+      if (typeof lock === "string") return {
+        label: "other",
+        amount: this.#format(lock)
+      };
+      return {
+        ...lock,
+        amount: this.#format(lock.amount)
+      };
+    });
   }
-  /** @depreacted - use balance.locked */
+  /** @deprecated Use balance.locked */
   get frozen() {
     return this.locked;
   }
@@ -580,7 +793,7 @@ let Balance = (_dec4 = Memoize(), _dec5 = Memoize(), _dec6 = Memoize(), _dec7 =
     const excludeAmount = excludeFromTransferableAmount(this.#storage.locks);
 
     // subtract the lock from the free amount (but don't go below 0)
-    return this.#format(BigMath.max(this.free.planck - excludeAmount, BigInt("0")));
+    return this.#format(BigMath.max(this.free.planck - excludeAmount, 0n));
   }
   /** The feePayable balance of this token. Is generally the free amount - the feeFrozen amount. */
   get feePayable() {
@@ -588,13 +801,13 @@ let Balance = (_dec4 = Memoize(), _dec5 = Memoize(), _dec6 = Memoize(), _dec7 =
     if (!this.#storage.locks) return this.free;
 
     // find the largest lock which can't be used to pay tx fees
-    const excludeAmount = excludeFromFeePayableLocks(this.#storage.locks).map(lock => BigInt(lock.amount)).reduce((max, lock) => BigMath.max(max, lock), BigInt("0"));
+    const excludeAmount = excludeFromFeePayableLocks(this.#storage.locks).map(lock => BigInt(lock.amount)).reduce((max, lock) => BigMath.max(max, lock), 0n);
 
     // subtract the lock from the free amount (but don't go below 0)
-    return this.#format(BigMath.max(this.free.planck - excludeAmount, BigInt("0")));
+    return this.#format(BigMath.max(this.free.planck - excludeAmount, 0n));
   }
-}, (_applyDecoratedDescriptor(_class2.prototype, "total", [_dec4], Object.getOwnPropertyDescriptor(_class2.prototype, "total"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "free", [_dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "free"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "reserved", [_dec6], Object.getOwnPropertyDescriptor(_class2.prototype, "reserved"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "locked", [_dec7], Object.getOwnPropertyDescriptor(_class2.prototype, "locked"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "frozen", [_dec8], Object.getOwnPropertyDescriptor(_class2.prototype, "frozen"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "transferable", [_dec9], Object.getOwnPropertyDescriptor(_class2.prototype, "transferable"), _class2.prototype), _applyDecoratedDescriptor(_class2.prototype, "feePayable", [_dec10], Object.getOwnPropertyDescriptor(_class2.prototype, "feePayable"), _class2.prototype)), _class2));
-let BalanceFormatter = (_dec11 = Memoize(), (_class3 = class BalanceFormatter {
+}
+class BalanceFormatter {
   #planck;
   #decimals;
   #fiatRatios;
@@ -602,7 +815,6 @@ let BalanceFormatter = (_dec11 = Memoize(), (_class3 = class BalanceFormatter {
     this.#planck = typeof planck === "bigint" ? planck.toString() : planck ?? "0";
     this.#decimals = decimals || 0;
     this.#fiatRatios = fiatRatios || null;
-    this.fiat = memoize(this.fiat);
   }
   toJSON = () => this.#planck;
   get planck() {
@@ -617,26 +829,66 @@ let BalanceFormatter = (_dec11 = Memoize(), (_class3 = class BalanceFormatter {
     if (!ratio) return null;
     return parseFloat(this.tokens) * ratio;
   }
-}, (_applyDecoratedDescriptor(_class3.prototype, "tokens", [_dec11], Object.getOwnPropertyDescriptor(_class3.prototype, "tokens"), _class3.prototype)), _class3));
-let FiatSumBalancesFormatter = (_dec12 = Memoize(), _dec13 = Memoize(), _dec14 = Memoize(), _dec15 = Memoize(), _dec16 = Memoize(), _dec17 = Memoize(), _dec18 = Memoize(), (_class4 = class FiatSumBalancesFormatter {
+}
+class PlanckSumBalancesFormatter {
+  #balances;
+  constructor(balances) {
+    this.#balances = balances;
+  }
+  #sum = balanceField => {
+    // a function to get a planck amount from a balance
+    const planck = balance => balance[balanceField].planck ?? 0n;
+    return this.#balances.filterMirrorTokens().each.reduce(
+    // add the total amount to the planck amount of each balance
+    (total, balance) => total + planck(balance),
+    // start with a total of 0
+    0n);
+  };
+
+  /**
+   * The total balance of these tokens. Includes the free and the reserved amount.
+   */
+  get total() {
+    return this.#sum("total");
+  }
+  /** The non-reserved balance of these tokens. Includes the frozen amount. Is included in the total. */
+  get free() {
+    return this.#sum("free");
+  }
+  /** The reserved balance of these tokens. Is included in the total. */
+  get reserved() {
+    return this.#sum("reserved");
+  }
+  /** The frozen balance of these tokens. Is included in the free amount. */
+  get locked() {
+    return this.#sum("locked");
+  }
+  /** @deprecated Use balances.locked */
+  get frozen() {
+    return this.locked;
+  }
+  /** The transferable balance of these tokens. Is generally the free amount - the miscFrozen amount. */
+  get transferable() {
+    return this.#sum("transferable");
+  }
+  /** The feePayable balance of these tokens. Is generally the free amount - the feeFrozen amount. */
+  get feePayable() {
+    return this.#sum("feePayable");
+  }
+}
+class FiatSumBalancesFormatter {
   #balances;
   #currency;
   constructor(balances, currency) {
     this.#balances = balances;
     this.#currency = currency;
-    this.#sum = memoize(this.#sum);
   }
   #sum = balanceField => {
     // a function to get a fiat amount from a balance
-    const fiat = balance => balance[balanceField].fiat(this.#currency) || 0;
-
-    // a function to add two amounts
-    const sum = (a, b) => a + b;
-    return [...this.#balances].filter(filterMirrorTokens).reduce((total, balance) => sum(
-    // add the total amount...
-    total,
-    // ...to the fiat amount of each balance
-    fiat(balance)),
+    const fiat = balance => balance[balanceField].fiat(this.#currency) ?? 0;
+    return this.#balances.filterMirrorTokens().each.reduce(
+    // add the total amount to the fiat amount of each balance
+    (total, balance) => total + fiat(balance),
     // start with a total of 0
     0);
   };
@@ -659,7 +911,7 @@ let FiatSumBalancesFormatter = (_dec12 = Memoize(), _dec13 = Memoize(), _dec14 =
   get locked() {
     return this.#sum("locked");
   }
-  /** @deprecated - use balances.locked */
+  /** @deprecated Use balances.locked */
   get frozen() {
     return this.locked;
   }
@@ -671,16 +923,18 @@ let FiatSumBalancesFormatter = (_dec12 = Memoize(), _dec13 = Memoize(), _dec14 =
   get feePayable() {
     return this.#sum("feePayable");
   }
-}, (_applyDecoratedDescriptor(_class4.prototype, "total", [_dec12], Object.getOwnPropertyDescriptor(_class4.prototype, "total"), _class4.prototype), _applyDecoratedDescriptor(_class4.prototype, "free", [_dec13], Object.getOwnPropertyDescriptor(_class4.prototype, "free"), _class4.prototype), _applyDecoratedDescriptor(_class4.prototype, "reserved", [_dec14], Object.getOwnPropertyDescriptor(_class4.prototype, "reserved"), _class4.prototype), _applyDecoratedDescriptor(_class4.prototype, "locked", [_dec15], Object.getOwnPropertyDescriptor(_class4.prototype, "locked"), _class4.prototype), _applyDecoratedDescriptor(_class4.prototype, "frozen", [_dec16], Object.getOwnPropertyDescriptor(_class4.prototype, "frozen"), _class4.prototype), _applyDecoratedDescriptor(_class4.prototype, "transferable", [_dec17], Object.getOwnPropertyDescriptor(_class4.prototype, "transferable"), _class4.prototype), _applyDecoratedDescriptor(_class4.prototype, "feePayable", [_dec18], Object.getOwnPropertyDescriptor(_class4.prototype, "feePayable"), _class4.prototype)), _class4));
+}
 class SumBalancesFormatter {
   #balances;
   constructor(balances) {
     this.#balances = balances;
-    this.fiat = memoize(this.fiat);
+  }
+  get planck() {
+    return new PlanckSumBalancesFormatter(this.#balances);
   }
   fiat(currency) {
     return new FiatSumBalancesFormatter(this.#balances, currency);
   }
 }
 
-export { Balance, BalanceFormatter, Balances, DefaultBalanceModule, FiatSumBalancesFormatter, StorageHelper, SumBalancesFormatter, TalismanBalancesDatabase, balances, db, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterMirrorTokens, includeInTotalExtraAmount };
+export { Balance, BalanceFormatter, BalanceStatusLive, Balances, DefaultBalanceModule, FiatSumBalancesFormatter, PlanckSumBalancesFormatter, RpcStateQueryHelper, StorageHelper, SumBalancesFormatter, TalismanBalancesDatabase, balances, createSubscriptionId, createTypeRegistryCache, db, deleteSubscriptionId, deriveStatuses, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterMirrorTokens, findChainMeta, getValidSubscriptionIds, includeInTotalExtraAmount };