@talismn/balances 0.2.3 → 0.3.1

package/dist/talismn-balances.esm.js

@@ -0,0 +1,683 @@
+import { Dexie } from 'dexie';
+import { decorateStorage, StorageKey } from '@polkadot/types';
+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 => ({
+  get type() {
+    return type;
+  },
+  async fetchSubstrateChainMeta() {
+    return null;
+  },
+  async fetchEvmChainMeta() {
+    return null;
+  },
+  async fetchSubstrateChainTokens() {
+    return Promise.resolve({});
+  },
+  async fetchEvmChainTokens() {
+    return Promise.resolve({});
+  },
+  async subscribeBalances(_chainConnectors, _chaindataProvider, _addressesByToken, 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.");
+  }
+});
+
+//
+// internal
+//
+
+class TalismanBalancesDatabase extends Dexie {
+  constructor() {
+    super("TalismanBalances");
+
+    // https://dexie.org/docs/Tutorial/Design#database-versioning
+    this.version(1).stores({
+      // You only need to specify properties that you wish to index.
+      // The object store will allow any properties on your stored objects but you can only query them by indexed properties
+      // https://dexie.org/docs/API-Reference#declare-database
+      //
+      // Never index properties containing images, movies or large (huge) strings. Store them in IndexedDB, yes! but just don’t index them!
+      // https://dexie.org/docs/Version/Version.stores()#warning
+      balances: "id, source, status, address, tokenId"
+    });
+
+    // this.on("ready", async () => {})
+  }
+}
+
+const db = new TalismanBalancesDatabase();
+
+var packageJson = {
+	name: "@talismn/balances",
+	version: "0.3.1",
+	author: "Talisman",
+	homepage: "https://talisman.xyz",
+	license: "UNLICENSED",
+	publishConfig: {
+		access: "public"
+	},
+	repository: {
+		directory: "packages/balances",
+		type: "git",
+		url: "https://github.com/talismansociety/talisman.git"
+	},
+	main: "dist/talismn-balances.cjs.js",
+	module: "dist/talismn-balances.esm.js",
+	files: [
+		"/dist",
+		"/plugins"
+	],
+	engines: {
+		node: ">=14"
+	},
+	scripts: {
+		test: "jest",
+		lint: "eslint . --max-warnings 0",
+		clean: "rm -rf dist && rm -rf .turbo rm -rf node_modules"
+	},
+	dependencies: {
+		"@polkadot/types": "9.10.5",
+		"@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"
+	},
+	devDependencies: {
+		"@talismn/eslint-config": "workspace:^",
+		"@talismn/tsconfig": "workspace:^",
+		"@types/jest": "^27.5.1",
+		eslint: "^8.4.0",
+		jest: "^28.1.0",
+		"ts-jest": "^28.0.2",
+		typescript: "^4.6.4"
+	},
+	preconstruct: {
+		entrypoints: [
+			"index.ts",
+			"plugins.ts"
+		]
+	},
+	eslintConfig: {
+		root: true,
+		"extends": [
+			"@talismn/eslint-config/base"
+		]
+	}
+};
+
+var log = anylogger(packageJson.name);
+
+async function balances(balanceModule, chainConnectors, chaindataProvider, addressesByToken, callback) {
+  // subscription request
+  if (callback !== undefined) return await balanceModule.subscribeBalances(chainConnectors, chaindataProvider, addressesByToken, callback);
+
+  // one-off request
+  return await balanceModule.fetchBalances(chainConnectors, chaindataProvider, addressesByToken);
+}
+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);
+};
+
+/**
+ * Used by a variety of balance modules to help encode and decode substrate state calls.
+ */
+class StorageHelper {
+  #registry;
+  #storageKey;
+  #module;
+  #method;
+  #parameters;
+  tags = null;
+  constructor(registry, module, method, ...parameters) {
+    this.#registry = registry;
+    this.#module = module;
+    this.#method = method;
+    this.#parameters = parameters;
+    const _metadataVersion = 0; // is not used inside the decorateStorage function
+    let query;
+    try {
+      query = decorateStorage(registry, registry.metadata, _metadataVersion);
+    } catch (error) {
+      log.debug(`Failed to decorate storage: ${error.message}`);
+      this.#storageKey = null;
+    }
+    try {
+      if (!query) throw new Error(`decoratedStorage unavailable`);
+      this.#storageKey = new StorageKey(registry, parameters ? [query[module][method], parameters] : query[module][method]);
+    } catch (error) {
+      log.debug(`Failed to create storageKey ${module || "unknown"}.${method || "unknown"}: ${error.message}`);
+      this.#storageKey = null;
+    }
+  }
+  get stateKey() {
+    return this.#storageKey?.toHex();
+  }
+  get module() {
+    return this.#module;
+  }
+  get method() {
+    return this.#method;
+  }
+  get parameters() {
+    return this.#parameters;
+  }
+  tag(tags) {
+    this.tags = tags;
+    return this;
+  }
+  decode(input) {
+    if (!this.#storageKey) return;
+    return this.#decodeStorageScaleResponse(this.#registry, this.#storageKey, input);
+  }
+  #decodeStorageScaleResponse(typeRegistry, storageKey, input) {
+    if (input === undefined || input === null) return;
+    const type = storageKey.outputType || "Raw";
+    const meta = storageKey.meta || {
+      fallback: undefined,
+      modifier: {
+        isOptional: true
+      },
+      type: {
+        asMap: {
+          linked: {
+            isTrue: false
+          }
+        },
+        isMap: false
+      }
+    };
+    try {
+      return typeRegistry.createTypeUnsafe(type, [meta.modifier.isOptional ? typeRegistry.createTypeUnsafe(type, [input], {
+        isPedantic: true
+      }) : input], {
+        isOptional: meta.modifier.isOptional,
+        isPedantic: !meta.modifier.isOptional
+      });
+    } catch (error) {
+      throw new Error(`Unable to decode storage ${storageKey.section || "unknown"}.${storageKey.method || "unknown"}: ${error.message}`);
+    }
+  }
+}
+
+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;
+}
+
+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"));
+}
+function excludeFromFeePayableLocks(locks) {
+  if (typeof locks === "string") return [];
+  if (!Array.isArray(locks)) locks = [locks];
+  return locks.filter(lock => lock.excludeFromFeePayable);
+}
+
+/** A labelled extra amount of a balance */
+
+function includeInTotalExtraAmount(extra) {
+  if (!extra) return BigInt("0");
+  if (!Array.isArray(extra)) extra = [extra];
+  return extra.filter(extra => extra.includeInTotal).map(extra => BigInt(extra.amount)).reduce((a, b) => a + b, BigInt("0"));
+}
+
+/** 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` */
+
+/**
+ * A collection of balances.
+ */
+let Balances = (_dec = Memoize(), _dec2 = Memoize(), _dec3 = Memoize(), (_class = class Balances {
+  //
+  // Properties
+  //
+
+  #balances = {};
+
+  //
+  // Methods
+  //
+
+  constructor(balances, hydrate) {
+    // handle Balances (convert to Balance[])
+    if (balances instanceof Balances) return new Balances([...balances], hydrate);
+
+    // handle Balance (convert to Balance[])
+    if (balances instanceof Balance) return new Balances([balances], hydrate);
+
+    // handle BalanceJsonList (the only remaining non-array type of balances) (convert to BalanceJson[])
+    if (!Array.isArray(balances)) return new Balances(Object.values(balances), hydrate);
+
+    // handle no balances
+    if (balances.length === 0) return this;
+
+    // handle BalanceJson[]
+    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]));
+    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]) => {
+    try {
+      return [id, balance.toJSON()];
+    } catch (error) {
+      log.error("Failed to convert balance to JSON", error, {
+        id,
+        balance
+      });
+      return null;
+    }
+  }).filter(Array.isArray));
+
+  /**
+   * Allows the collection to be iterated over.
+   *
+   * @example
+   * [...balances].forEach(balance => { // do something // })
+   *
+   * @example
+   * for (const balance of balances) {
+   *   // do something
+   * }
+   */
+  [Symbol.iterator] = () =>
+  // Create an array of the balances in this collection and return the result of its iterator.
+  Object.values(this.#balances)[Symbol.iterator]();
+
+  /**
+   * Hydrates all balances in this collection.
+   *
+   * @param sources - The sources to hydrate from.
+   */
+  hydrate = sources => {
+    Object.values(this.#balances).map(balance => balance.hydrate(sources));
+  };
+
+  /**
+   * Retrieve a balance from this collection by id.
+   *
+   * @param id - The id of the balance to fetch.
+   * @returns The balance if one exists, or none.
+   */
+  get = id => this.#balances[id] || null;
+
+  /**
+   * Retrieve balances from this collection by search query.
+   *
+   * @param query - The search query.
+   * @returns All balances which match the query.
+   */
+  find = query => {
+    // construct filter
+    const orQueries = (Array.isArray(query) ? query : [query]).map(query => typeof query === "function" ? query : Object.entries(query));
+
+    // filter balances
+    const filter = balance => orQueries.some(query => typeof query === "function" ? query(balance) : query.every(([key, value]) => balance[key] === value));
+
+    // return filter matches
+    return new Balances([...this].filter(filter));
+  };
+
+  /**
+   * Add some balances to this collection.
+   * Added balances take priority over existing balances.
+   * The aggregation of the two collections is returned.
+   * The original collection is not mutated.
+   *
+   * @param balances - Either a balance or collection of balances to add.
+   * @returns The new collection of balances.
+   */
+  add = balances => {
+    // handle single balance
+    if (balances instanceof Balance) return this.add(new Balances(balances));
+
+    // merge balances
+    const mergedBalances = {
+      ...this.#balances
+    };
+    [...balances].forEach(balance => mergedBalances[balance.id] = balance);
+
+    // return new balances
+    return new Balances(Object.values(mergedBalances));
+  };
+
+  /**
+   * Remove balances from this collection by id.
+   * A new collection without these balances is returned.
+   * The original collection is not mutated.
+   *
+   * @param ids - The id(s) of the balances to remove.
+   * @returns The new collection of balances.
+   */
+  remove = ids => {
+    // 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));
+  };
+
+  // TODO: Add some more useful aggregator methods
+
+  /**
+   * 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));
+  }
+
+  /**
+   * Get the number of balances in this collection.
+   *
+   * @returns The number of balances in this collection.
+   */
+  get count() {
+    return [...this].length;
+  }
+
+  /**
+   * Get the summed value of balances in this collection.
+   * TODO: Sum up token amounts AND fiat amounts
+   *
+   * @example
+   * // Get the sum of all transferable balances in usd.
+   * balances.sum.fiat('usd').transferable
+   */
+  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 {
+  //
+  // Properties
+  //
+
+  /** The underlying data for this balance */
+  #storage;
+  #db = null;
+
+  //
+  // Methods
+  //
+
+  constructor(storage, hydrate) {
+    this.#format = memoize(this.#format);
+    this.#storage = storage;
+    if (hydrate !== undefined) this.hydrate(hydrate);
+  }
+  toJSON = () => this.#storage;
+  isSource = source => this.#storage.source === source;
+  // // TODO: Fix this method, the types don't work with our plugin architecture.
+  // // Specifically, the `BalanceJson` type is compiled down to `IBalance` in the following way:
+  // //
+  // //     toJSON: () => BalanceJson // works
+  // //     isSource: (source: BalanceSource) => boolean // works
+  // //     asSource: <P extends string>(source: P) => NarrowBalanceType<IBalance, P> | null // Doesn't work! IBalance should just be BalanceJson!
+  // //
+  // // `IBalance` won't match the type of `BalanceSource` after `PluginBalanceTypes` has been extended by balance plugins.
+  // // As a result, typescript will think that the returned #storage is not a BalanceJson.
+  // asSource = <P extends BalanceSource>(source: P): NarrowBalanceType<BalanceJson, P> | null => {
+  //   if (this.#storage.source === source) return this.#storage as NarrowBalanceType<BalanceJson, P>
+  //   return null
+  // }
+
+  hydrate = hydrate => {
+    if (hydrate !== undefined) this.#db = hydrate;
+  };
+  #format = balance => new BalanceFormatter(typeof balance === "bigint" ? balance.toString() : balance, this.decimals || undefined, this.#db?.tokenRates && this.#db.tokenRates[this.tokenId]);
+
+  //
+  // Accessors
+  //
+
+  get id() {
+    const {
+      source,
+      address,
+      chainId,
+      evmNetworkId,
+      tokenId
+    } = this.#storage;
+    const locationId = chainId !== undefined ? chainId : evmNetworkId;
+    return `${source}-${address}-${locationId}-${tokenId}`;
+  }
+  get source() {
+    return this.#storage.source;
+  }
+  get status() {
+    return this.#storage.status;
+  }
+  get address() {
+    return this.#storage.address;
+  }
+  get chainId() {
+    return this.#storage.chainId;
+  }
+  get chain() {
+    return this.#db?.chains && this.chainId && this.#db?.chains[this.chainId] || null;
+  }
+  get evmNetworkId() {
+    return this.#storage.evmNetworkId;
+  }
+  get evmNetwork() {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.#db?.evmNetworks && this.#db?.evmNetworks[this.evmNetworkId] || null;
+  }
+  get tokenId() {
+    return this.#storage.tokenId;
+  }
+  get token() {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return this.#db?.tokens && this.#db?.tokens[this.tokenId] || null;
+  }
+  get decimals() {
+    return this.token?.decimals || null;
+  }
+  get rates() {
+    return this.#db?.tokenRates && this.#db.tokenRates[this.tokenId] || null;
+  }
+
+  /**
+   * The total balance of this token.
+   * Includes the free and the reserved amount.
+   * The balance will be reaped if this goes below the existential deposit.
+   */
+  get total() {
+    const extra = includeInTotalExtraAmount(this.#storage.extra);
+    return this.#format(this.free.planck + this.reserved.planck + extra);
+  }
+  /** 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"));
+  }
+  /** 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"));
+  }
+  /** 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"));
+  }
+  /** @depreacted - use balance.locked */
+  get frozen() {
+    return this.locked;
+  }
+  /** The transferable balance of this token. Is generally the free amount - the miscFrozen amount. */
+  get transferable() {
+    // if no locks exist, transferable is equal to the free amount
+    if (!this.#storage.locks) return this.free;
+
+    // find the largest lock (but ignore any locks which are marked as `includeInTransferable`)
+    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")));
+  }
+  /** The feePayable balance of this token. Is generally the free amount - the feeFrozen amount. */
+  get feePayable() {
+    // if no locks exist, feePayable is equal to the free amount
+    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"));
+
+    // subtract the lock from the free amount (but don't go below 0)
+    return this.#format(BigMath.max(this.free.planck - excludeAmount, BigInt("0")));
+  }
+}, (_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 {
+  #planck;
+  #decimals;
+  #fiatRatios;
+  constructor(planck, decimals, fiatRatios) {
+    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() {
+    return BigInt(this.#planck);
+  }
+  get tokens() {
+    return planckToTokens(this.#planck, this.#decimals);
+  }
+  fiat(currency) {
+    if (!this.#fiatRatios) return null;
+    const ratio = this.#fiatRatios[currency];
+    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 {
+  #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)),
+    // start with a total of 0
+    0);
+  };
+
+  /**
+   * 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");
+  }
+}, (_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);
+  }
+  fiat(currency) {
+    return new FiatSumBalancesFormatter(this.#balances, currency);
+  }
+}
+
+export { Balance, BalanceFormatter, Balances, DefaultBalanceModule, FiatSumBalancesFormatter, StorageHelper, SumBalancesFormatter, TalismanBalancesDatabase, balances, db, excludeFromFeePayableLocks, excludeFromTransferableAmount, filterMirrorTokens, includeInTotalExtraAmount };