@talismn/balances 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# @talismn/balances
+
+## 0.1.1
+
+### Patch Changes
+
+- Fixed publish config
+- Updated dependencies
+  - @talismn/chain-connector@0.1.1
+  - @talismn/chaindata-provider@0.1.1
+  - @talismn/token-rates@0.1.1
+  - @talismn/util@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- 43c1a3a: Initial release
+
+### Patch Changes
+
+- Updated dependencies [43c1a3a]
+  - @talismn/chain-connector@0.1.0
+  - @talismn/chaindata-provider@0.1.0
+  - @talismn/token-rates@0.1.0
+  - @talismn/util@0.1.0

package/README.md

@@ -0,0 +1 @@
+# @talismn/balances

package/dist/BalanceModule.d.ts

@@ -0,0 +1,36 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChainId, ChaindataProvider, IToken } from "@talismn/chaindata-provider";
+import { AddressesByToken, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
+export interface BalanceModule<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> extends BalanceModuleSubstrate<TModuleType, TTokenType, TChainMeta, TModuleConfig>, BalanceModuleEvm<TModuleType, TTokenType, TChainMeta, TModuleConfig> {
+}
+export declare const DefaultBalanceModule: <TModuleType extends string, TTokenType extends IToken, TChainMeta extends ExtendableChainMeta = undefined, TModuleConfig extends ExtendableModuleConfig = undefined>(type: TModuleType) => BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig>;
+export declare type ExtendableTokenType = IToken;
+export declare type ExtendableChainMeta = Record<string, unknown> | undefined;
+export declare type DefaultChainMeta = undefined;
+export declare type ExtendableModuleConfig = Record<string, unknown> | undefined;
+export declare type DefaultModuleConfig = undefined;
+interface BalanceModuleSubstrate<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> extends BalanceModuleCommon<TModuleType, TTokenType, TChainMeta, TModuleConfig> {
+    /** Pre-processes any substrate chain metadata required by this module ahead of time */
+    fetchSubstrateChainMeta(chainConnector: ChainConnector, chainId: ChainId): Promise<TChainMeta | null>;
+    /** Detects which tokens are available on a given substrate chain */
+    fetchSubstrateChainTokens(chainConnector: ChainConnector, chainId: ChainId, chainMeta: TChainMeta): Promise<Record<TTokenType["id"], TTokenType>>;
+}
+interface BalanceModuleEvm<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> extends BalanceModuleCommon<TModuleType, TTokenType, TChainMeta, TModuleConfig> {
+    /** Pre-processes any evm chain metadata required by this module ahead of time */
+    fetchEvmChainMeta(chainConnector: ChainConnector, chainId: ChainId): Promise<TChainMeta | null>;
+    /** Detects which tokens are available on a given evm chain */
+    fetchEvmChainTokens(chainConnector: ChainConnector, chainId: ChainId, chainMeta: TChainMeta): Promise<Record<TTokenType["id"], TTokenType>>;
+}
+interface BalanceModuleCommon<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig> {
+    get type(): TModuleType;
+    /**
+     * Subscribe to balances for this module with optional filtering.
+     *
+     * If subscriptions are not possible, this function should poll at some reasonable interval.
+     */
+    subscribeBalances(chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;
+    /** Fetch balances for this module with optional filtering */
+    fetchBalances(chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
+    [x: string | number | symbol]: unknown;
+}
+export {};

package/dist/BalanceModule.js

@@ -0,0 +1,46 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// TODO: Document default balances module purpose/usage
+export const DefaultBalanceModule = (type) => ({
+    get type() {
+        return type;
+    },
+    fetchSubstrateChainMeta() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    },
+    fetchEvmChainMeta() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    },
+    fetchSubstrateChainTokens(chainConnector, chainId, chainMeta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve({});
+        });
+    },
+    fetchEvmChainTokens(chainConnector, chainId, chainMeta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve({});
+        });
+    },
+    subscribeBalances(chainConnector, chaindataProvider, addressesByToken, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callback(new Error("Balance subscriptions are not implemented in this module."));
+            return () => { };
+        });
+    },
+    fetchBalances(chainConnector, chaindataProvider, addressesByToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Balance fetching is not implemented in this module.");
+        });
+    },
+});

package/dist/helpers.d.ts

@@ -0,0 +1,10 @@
+import { ChainConnector } from "@talismn/chain-connector";
+import { ChaindataProvider } from "@talismn/chaindata-provider";
+import { BalanceModule, DefaultChainMeta, DefaultModuleConfig, ExtendableChainMeta, ExtendableModuleConfig, ExtendableTokenType } from "./BalanceModule";
+import { AddressesByToken, Balances, SubscriptionCallback, UnsubscribeFn } from "./types";
+/**
+ * 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.
+ */
+export declare function balances<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig>(balanceModule: BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig>, chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>): Promise<Balances>;
+export declare function balances<TModuleType extends string, TTokenType extends ExtendableTokenType, TChainMeta extends ExtendableChainMeta = DefaultChainMeta, TModuleConfig extends ExtendableModuleConfig = DefaultModuleConfig>(balanceModule: BalanceModule<TModuleType, TTokenType, TChainMeta, TModuleConfig>, chainConnector: ChainConnector, chaindataProvider: ChaindataProvider, addressesByToken: AddressesByToken<TTokenType>, callback: SubscriptionCallback<Balances>): Promise<UnsubscribeFn>;

package/dist/helpers.js

@@ -0,0 +1,18 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function balances(balanceModule, chainConnector, chaindataProvider, addressesByToken, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // subscription request
+        if (callback !== undefined)
+            return yield balanceModule.subscribeBalances(chainConnector, chaindataProvider, addressesByToken, callback);
+        // one-off request
+        return yield balanceModule.fetchBalances(chainConnector, chaindataProvider, addressesByToken);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./BalanceModule";
+export * from "./helpers";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,14 @@
+//
+// NOTE: Do not export `./plugins` from here!
+// Doing so will introduce a circular dependency!
+// It is a separate entrypoint meant to be used like this:
+//
+//     import { PluginBalanceTypes } from '@talismn/balances/plugins'
+//
+// Not this:
+//
+//     import { PluginBalanceTypes } from '@talismn/balances'
+//
+export * from "./BalanceModule";
+export * from "./helpers";
+export * from "./types";

package/dist/plugins.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `PluginBalanceTypes` is a collection of plugin-provided balance definitions.
+ *
+ * By hacking declaration merging (typescript magic) we can add variants to this type from within other modules.
+ *
+ * For more details on this process, see:
+ * - https://www.typescriptlang.org/docs/handbook/declaration-merging.html
+ * - https://stackoverflow.com/a/58261244/3926156
+ * - https://stackoverflow.com/a/56099769/3926156
+ * - https://stackoverflow.com/a/56516998/3926156
+ * - https://pqina.nl/blog/typescript-interface-merging-and-extending-modules/
+ *
+ * As a result, consumers of this api will have type information for the `BalanceJson` type
+ * based on the selection of plugins they are using in their app.
+ */
+export interface PluginBalanceTypes {
+}

package/dist/plugins.js

@@ -0,0 +1 @@
+export {};

package/dist/types/addresses.d.ts

@@ -0,0 +1,4 @@
+export declare type Address = string;
+export declare type AddressesByToken<TTokenType extends {
+    id: string;
+}> = Record<TTokenType["id"], Address[]>;

package/dist/types/addresses.js

@@ -0,0 +1 @@
+export {};

package/dist/types/balances.d.ts

@@ -0,0 +1,174 @@
+import { ChainList, EvmNetworkList, TokenList } from "@talismn/chaindata-provider";
+import { TokenRateCurrency, TokenRates } from "@talismn/token-rates";
+import { NonFunctionProperties } from "@talismn/util";
+import { BalanceJson, BalanceJsonList, IBalance } from "./balancetypes";
+/**
+ * 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` */
+export declare type NarrowBalanceType<S extends IBalance, P> = S extends {
+    source: P;
+} ? S : never;
+export declare type BalanceSource = BalanceJson["source"];
+/** TODO: Remove this in favour of a frontend-friendly `ChaindataProvider` */
+export declare type HydrateDb = Partial<{
+    chains: ChainList;
+    evmNetworks: EvmNetworkList;
+    tokens: TokenList;
+}>;
+export declare type BalanceSearchQuery = Partial<NonFunctionProperties<Balance>> | ((balance: Balance) => boolean);
+/**
+ * A collection of balances.
+ */
+export declare class Balances {
+    #private;
+    constructor(balances: Balances | BalanceJsonList | Balance[] | BalanceJson[] | Balance, hydrate?: HydrateDb);
+    /**
+     * Calling toJSON on a collection of balances will return the underlying BalanceJsonList.
+     */
+    toJSON: () => BalanceJsonList;
+    /**
+     * Allows the collection to be iterated over.
+     *
+     * @example
+     * [...balances].forEach(balance => { // do something // })
+     *
+     * @example
+     * for (const balance of balances) {
+     *   // do something
+     * }
+     */
+    [Symbol.iterator]: () => IterableIterator<Balance>;
+    /**
+     * Hydrates all balances in this collection.
+     *
+     * @param sources - The sources to hydrate from.
+     */
+    hydrate: (sources: HydrateDb) => void;
+    /**
+     * 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: string) => Balance | null;
+    /**
+     * Retrieve balances from this collection by search query.
+     *
+     * @param query - The search query.
+     * @returns All balances which match the query.
+     */
+    find: (query: BalanceSearchQuery | BalanceSearchQuery[]) => Balances;
+    /**
+     * 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: Balances | Balance) => Balances;
+    /**
+     * 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: string[] | string) => Balances;
+    /**
+     * Get an array of balances in this collection, sorted by chain sortIndex.
+     *
+     * @returns A sorted array of the balances in this collection.
+     */
+    get sorted(): Balance[];
+    /**
+     * Get the number of balances in this collection.
+     *
+     * @returns The number of balances in this collection.
+     */
+    get count(): number;
+    /**
+     * Get the summed value of balances in this collection.
+     *
+     * @example
+     * // Get the sum of all transferable balances in usd.
+     * balances.sum.fiat('usd').transferable
+     */
+    get sum(): SumBalancesFormatter;
+}
+/**
+ * An individual balance.
+ */
+export declare class Balance {
+    #private;
+    constructor(storage: BalanceJson, hydrate?: HydrateDb);
+    toJSON: () => BalanceJson;
+    isSource: (source: BalanceSource) => boolean;
+    hydrate: (hydrate?: HydrateDb) => void;
+    get id(): string;
+    get source(): string;
+    get status(): import("./balancetypes").BalanceStatus;
+    get address(): string;
+    get chainId(): string | undefined;
+    get chain(): import("@talismn/chaindata-provider").Chain | null;
+    get evmNetworkId(): number | undefined;
+    get evmNetwork(): import("@talismn/chaindata-provider").EvmNetwork | null;
+    get tokenId(): string;
+    get token(): import("@talismn/chaindata-provider").IToken | null;
+    get decimals(): number | 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(): BalanceFormatter;
+    /** The non-reserved balance of this token. Includes the frozen amount. Is included in the total. */
+    get free(): BalanceFormatter;
+    /** The reserved balance of this token. Is included in the total. */
+    get reserved(): BalanceFormatter;
+    /** The frozen balance of this token. Is included in the free amount. */
+    get locked(): BalanceFormatter;
+    /** @depreacted - use balance.locked */
+    get frozen(): BalanceFormatter;
+    /** The transferable balance of this token. Is generally the free amount - the miscFrozen amount. */
+    get transferable(): BalanceFormatter;
+    /** The feePayable balance of this token. Is generally the free amount - the feeFrozen amount. */
+    get feePayable(): BalanceFormatter;
+}
+export declare class BalanceFormatter {
+    #private;
+    constructor(planck: string | bigint, decimals?: number, fiatRatios?: TokenRates);
+    toJSON: () => string;
+    get planck(): bigint;
+    get tokens(): string;
+    fiat(currency: TokenRateCurrency): number | null;
+}
+export declare class FiatSumBalancesFormatter {
+    #private;
+    constructor(balances: Balances, currency: TokenRateCurrency);
+    /**
+     * The total balance of these tokens. Includes the free and the reserved amount.
+     */
+    get total(): number;
+    /** The non-reserved balance of these tokens. Includes the frozen amount. Is included in the total. */
+    get free(): number;
+    /** The reserved balance of these tokens. Is included in the total. */
+    get reserved(): number;
+    /** The frozen balance of these tokens. Is included in the free amount. */
+    get locked(): number;
+    /** @deprecated - use balances.locked */
+    get frozen(): number;
+    /** The transferable balance of these tokens. Is generally the free amount - the miscFrozen amount. */
+    get transferable(): number;
+    /** The feePayable balance of these tokens. Is generally the free amount - the feeFrozen amount. */
+    get feePayable(): number;
+}
+export declare class SumBalancesFormatter {
+    #private;
+    constructor(balances: Balances);
+    fiat(currency: TokenRateCurrency): FiatSumBalancesFormatter;
+}

package/dist/types/balances.js

@@ -0,0 +1,490 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Balances_balances, _a, _Balance_storage, _Balance_db, _Balance_format, _BalanceFormatter_planck, _BalanceFormatter_decimals, _BalanceFormatter_fiatRatios, _FiatSumBalancesFormatter_balances, _FiatSumBalancesFormatter_currency, _FiatSumBalancesFormatter_sum, _SumBalancesFormatter_balances;
+import { BigMath, isArrayOf, planckToTokens } from "@talismn/util";
+import memoize from "lodash/memoize";
+import { Memoize } from "typescript-memoize";
+import { excludeFromFeePayableLocks, excludeFromTransferableAmount, includeInTotalExtraAmount, } from "./balancetypes";
+/**
+ * A collection of balances.
+ */
+export class Balances {
+    //
+    // Methods
+    //
+    constructor(balances, hydrate) {
+        //
+        // Properties
+        //
+        _Balances_balances.set(this, {}
+        //
+        // Methods
+        //
+        );
+        /**
+         * Calling toJSON on a collection of balances will return the underlying BalanceJsonList.
+         */
+        this.toJSON = () => Object.fromEntries(Object.entries(__classPrivateFieldGet(this, _Balances_balances, "f")).map(([id, balance]) => [id, balance.toJSON()]));
+        /**
+         * Allows the collection to be iterated over.
+         *
+         * @example
+         * [...balances].forEach(balance => { // do something // })
+         *
+         * @example
+         * for (const balance of balances) {
+         *   // do something
+         * }
+         */
+        this[_a] = () => 
+        // Create an array of the balances in this collection and return the result of its iterator.
+        Object.values(__classPrivateFieldGet(this, _Balances_balances, "f"))[Symbol.iterator]();
+        /**
+         * Hydrates all balances in this collection.
+         *
+         * @param sources - The sources to hydrate from.
+         */
+        this.hydrate = (sources) => {
+            Object.values(__classPrivateFieldGet(this, _Balances_balances, "f")).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.
+         */
+        this.get = (id) => __classPrivateFieldGet(this, _Balances_balances, "f")[id] || null;
+        /**
+         * Retrieve balances from this collection by search query.
+         *
+         * @param query - The search query.
+         * @returns All balances which match the query.
+         */
+        this.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.
+         */
+        this.add = (balances) => {
+            // handle single balance
+            if (balances instanceof Balance)
+                return this.add(new Balances(balances));
+            // merge balances
+            const mergedBalances = Object.assign({}, __classPrivateFieldGet(this, _Balances_balances, "f"));
+            [...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.
+         */
+        this.remove = (ids) => {
+            // handle single id
+            if (!Array.isArray(ids))
+                return this.remove([ids]);
+            // merge balances
+            const removedBalances = Object.assign({}, __classPrivateFieldGet(this, _Balances_balances, "f"));
+            ids.forEach((id) => delete removedBalances[id]);
+            // return new balances
+            return new Balances(Object.values(removedBalances));
+        };
+        // 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[]
+        __classPrivateFieldSet(this, _Balances_balances, Object.fromEntries(balances.map((balance) => [balance.id, balance])), "f");
+        if (hydrate !== undefined)
+            this.hydrate(hydrate);
+    }
+    // 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) => {
+            var _b, _c;
+            return (((_b = (a.chain || a.evmNetwork)) === null || _b === void 0 ? void 0 : _b.sortIndex) || Number.MAX_SAFE_INTEGER) -
+                (((_c = (b.chain || b.evmNetwork)) === null || _c === void 0 ? void 0 : _c.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.
+     *
+     * @example
+     * // Get the sum of all transferable balances in usd.
+     * balances.sum.fiat('usd').transferable
+     */
+    get sum() {
+        return new SumBalancesFormatter(this);
+    }
+}
+_Balances_balances = new WeakMap(), _a = Symbol.iterator;
+__decorate([
+    Memoize()
+], Balances.prototype, "sorted", null);
+__decorate([
+    Memoize()
+], Balances.prototype, "count", null);
+__decorate([
+    Memoize()
+], Balances.prototype, "sum", null);
+/**
+ * An individual balance.
+ */
+export class Balance {
+    //
+    // Methods
+    //
+    constructor(storage, hydrate) {
+        //
+        // Properties
+        //
+        /** The underlying data for this balance */
+        _Balance_storage.set(this, void 0);
+        _Balance_db.set(this, null
+        //
+        // Methods
+        //
+        );
+        this.toJSON = () => __classPrivateFieldGet(this, _Balance_storage, "f");
+        this.isSource = (source) => __classPrivateFieldGet(this, _Balance_storage, "f").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
+        // }
+        this.hydrate = (hydrate) => {
+            if (hydrate !== undefined)
+                __classPrivateFieldSet(this, _Balance_db, hydrate, "f");
+        };
+        _Balance_format.set(this, (balance) => {
+            var _b;
+            return new BalanceFormatter(typeof balance === "bigint" ? balance.toString() : balance, this.decimals || undefined, ((_b = this.token) === null || _b === void 0 ? void 0 : _b.rates) || undefined);
+        }
+        //
+        // Accessors
+        //
+        );
+        __classPrivateFieldSet(this, _Balance_format, memoize(__classPrivateFieldGet(this, _Balance_format, "f")), "f");
+        __classPrivateFieldSet(this, _Balance_storage, storage, "f");
+        if (hydrate !== undefined)
+            this.hydrate(hydrate);
+    }
+    //
+    // Accessors
+    //
+    get id() {
+        const { source, address, chainId, evmNetworkId, tokenId } = __classPrivateFieldGet(this, _Balance_storage, "f");
+        const locationId = chainId !== undefined ? chainId : evmNetworkId;
+        return `${source}-${address}-${locationId}-${tokenId}`;
+    }
+    get source() {
+        return __classPrivateFieldGet(this, _Balance_storage, "f").source;
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _Balance_storage, "f").status;
+    }
+    get address() {
+        return __classPrivateFieldGet(this, _Balance_storage, "f").address;
+    }
+    get chainId() {
+        return __classPrivateFieldGet(this, _Balance_storage, "f").chainId;
+    }
+    get chain() {
+        var _b, _c;
+        return (((_b = __classPrivateFieldGet(this, _Balance_db, "f")) === null || _b === void 0 ? void 0 : _b.chains) && this.chainId && ((_c = __classPrivateFieldGet(this, _Balance_db, "f")) === null || _c === void 0 ? void 0 : _c.chains[this.chainId])) || null;
+    }
+    get evmNetworkId() {
+        return __classPrivateFieldGet(this, _Balance_storage, "f").evmNetworkId;
+    }
+    get evmNetwork() {
+        var _b, _c;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return (((_b = __classPrivateFieldGet(this, _Balance_db, "f")) === null || _b === void 0 ? void 0 : _b.evmNetworks) && ((_c = __classPrivateFieldGet(this, _Balance_db, "f")) === null || _c === void 0 ? void 0 : _c.evmNetworks[this.evmNetworkId])) || null;
+    }
+    get tokenId() {
+        return __classPrivateFieldGet(this, _Balance_storage, "f").tokenId;
+    }
+    get token() {
+        var _b, _c;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return (((_b = __classPrivateFieldGet(this, _Balance_db, "f")) === null || _b === void 0 ? void 0 : _b.tokens) && ((_c = __classPrivateFieldGet(this, _Balance_db, "f")) === null || _c === void 0 ? void 0 : _c.tokens[this.tokenId])) || null;
+    }
+    get decimals() {
+        var _b;
+        return ((_b = this.token) === null || _b === void 0 ? void 0 : _b.decimals) || 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(__classPrivateFieldGet(this, _Balance_storage, "f").extra);
+        return __classPrivateFieldGet(this, _Balance_format, "f").call(this, 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() {
+        var _b;
+        return __classPrivateFieldGet(this, _Balance_format, "f").call(this, typeof __classPrivateFieldGet(this, _Balance_storage, "f").free === "string"
+            ? BigInt(__classPrivateFieldGet(this, _Balance_storage, "f").free)
+            : Array.isArray(__classPrivateFieldGet(this, _Balance_storage, "f").free)
+                ? __classPrivateFieldGet(this, _Balance_storage, "f").free
+                    .map((reserve) => BigInt(reserve.amount))
+                    .reduce((a, b) => a + b, BigInt("0"))
+                : BigInt(((_b = __classPrivateFieldGet(this, _Balance_storage, "f").free) === null || _b === void 0 ? void 0 : _b.amount) || "0"));
+    }
+    /** The reserved balance of this token. Is included in the total. */
+    get reserved() {
+        var _b;
+        return __classPrivateFieldGet(this, _Balance_format, "f").call(this, typeof __classPrivateFieldGet(this, _Balance_storage, "f").reserves === "string"
+            ? BigInt(__classPrivateFieldGet(this, _Balance_storage, "f").reserves)
+            : Array.isArray(__classPrivateFieldGet(this, _Balance_storage, "f").reserves)
+                ? __classPrivateFieldGet(this, _Balance_storage, "f").reserves
+                    .map((reserve) => BigInt(reserve.amount))
+                    .reduce((a, b) => a + b, BigInt("0"))
+                : BigInt(((_b = __classPrivateFieldGet(this, _Balance_storage, "f").reserves) === null || _b === void 0 ? void 0 : _b.amount) || "0"));
+    }
+    /** The frozen balance of this token. Is included in the free amount. */
+    get locked() {
+        var _b;
+        return __classPrivateFieldGet(this, _Balance_format, "f").call(this, typeof __classPrivateFieldGet(this, _Balance_storage, "f").locks === "string"
+            ? BigInt(__classPrivateFieldGet(this, _Balance_storage, "f").locks)
+            : Array.isArray(__classPrivateFieldGet(this, _Balance_storage, "f").locks)
+                ? __classPrivateFieldGet(this, _Balance_storage, "f").locks
+                    .map((lock) => BigInt(lock.amount))
+                    .reduce((a, b) => BigMath.max(a, b), BigInt("0"))
+                : BigInt(((_b = __classPrivateFieldGet(this, _Balance_storage, "f").locks) === null || _b === void 0 ? void 0 : _b.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 (!__classPrivateFieldGet(this, _Balance_storage, "f").locks)
+            return this.free;
+        // find the largest lock (but ignore any locks which are marked as `includeInTransferable`)
+        const excludeAmount = excludeFromTransferableAmount(__classPrivateFieldGet(this, _Balance_storage, "f").locks);
+        // subtract the lock from the free amount (but don't go below 0)
+        return __classPrivateFieldGet(this, _Balance_format, "f").call(this, 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 (!__classPrivateFieldGet(this, _Balance_storage, "f").locks)
+            return this.free;
+        // find the largest lock which can't be used to pay tx fees
+        const excludeAmount = excludeFromFeePayableLocks(__classPrivateFieldGet(this, _Balance_storage, "f").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 __classPrivateFieldGet(this, _Balance_format, "f").call(this, BigMath.max(this.free.planck - excludeAmount, BigInt("0")));
+    }
+}
+_Balance_storage = new WeakMap(), _Balance_db = new WeakMap(), _Balance_format = new WeakMap();
+__decorate([
+    Memoize()
+], Balance.prototype, "total", null);
+__decorate([
+    Memoize()
+], Balance.prototype, "free", null);
+__decorate([
+    Memoize()
+], Balance.prototype, "reserved", null);
+__decorate([
+    Memoize()
+], Balance.prototype, "locked", null);
+__decorate([
+    Memoize()
+], Balance.prototype, "frozen", null);
+__decorate([
+    Memoize()
+], Balance.prototype, "transferable", null);
+__decorate([
+    Memoize()
+], Balance.prototype, "feePayable", null);
+export class BalanceFormatter {
+    constructor(planck, decimals, fiatRatios) {
+        _BalanceFormatter_planck.set(this, void 0);
+        _BalanceFormatter_decimals.set(this, void 0);
+        _BalanceFormatter_fiatRatios.set(this, void 0);
+        this.toJSON = () => __classPrivateFieldGet(this, _BalanceFormatter_planck, "f");
+        __classPrivateFieldSet(this, _BalanceFormatter_planck, typeof planck === "bigint" ? planck.toString() : planck, "f");
+        __classPrivateFieldSet(this, _BalanceFormatter_decimals, decimals || 0, "f");
+        __classPrivateFieldSet(this, _BalanceFormatter_fiatRatios, fiatRatios || null, "f");
+        this.fiat = memoize(this.fiat);
+    }
+    get planck() {
+        return BigInt(__classPrivateFieldGet(this, _BalanceFormatter_planck, "f"));
+    }
+    get tokens() {
+        return planckToTokens(__classPrivateFieldGet(this, _BalanceFormatter_planck, "f"), __classPrivateFieldGet(this, _BalanceFormatter_decimals, "f"));
+    }
+    fiat(currency) {
+        if (!__classPrivateFieldGet(this, _BalanceFormatter_fiatRatios, "f"))
+            return null;
+        const ratio = __classPrivateFieldGet(this, _BalanceFormatter_fiatRatios, "f")[currency];
+        if (!ratio)
+            return null;
+        return parseFloat(this.tokens) * ratio;
+    }
+}
+_BalanceFormatter_planck = new WeakMap(), _BalanceFormatter_decimals = new WeakMap(), _BalanceFormatter_fiatRatios = new WeakMap();
+__decorate([
+    Memoize()
+], BalanceFormatter.prototype, "tokens", null);
+export class FiatSumBalancesFormatter {
+    constructor(balances, currency) {
+        _FiatSumBalancesFormatter_balances.set(this, void 0);
+        _FiatSumBalancesFormatter_currency.set(this, void 0);
+        _FiatSumBalancesFormatter_sum.set(this, (balanceField) => {
+            // a function to get a fiat amount from a balance
+            const fiat = (balance) => balance[balanceField].fiat(__classPrivateFieldGet(this, _FiatSumBalancesFormatter_currency, "f")) || 0;
+            // a function to add two amounts
+            const sum = (a, b) => a + b;
+            return [...__classPrivateFieldGet(this, _FiatSumBalancesFormatter_balances, "f")].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.
+         */
+        );
+        __classPrivateFieldSet(this, _FiatSumBalancesFormatter_balances, balances, "f");
+        __classPrivateFieldSet(this, _FiatSumBalancesFormatter_currency, currency, "f");
+        __classPrivateFieldSet(this, _FiatSumBalancesFormatter_sum, memoize(__classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f")), "f");
+    }
+    /**
+     * The total balance of these tokens. Includes the free and the reserved amount.
+     */
+    get total() {
+        return __classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f").call(this, "total");
+    }
+    /** The non-reserved balance of these tokens. Includes the frozen amount. Is included in the total. */
+    get free() {
+        return __classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f").call(this, "free");
+    }
+    /** The reserved balance of these tokens. Is included in the total. */
+    get reserved() {
+        return __classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f").call(this, "reserved");
+    }
+    /** The frozen balance of these tokens. Is included in the free amount. */
+    get locked() {
+        return __classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f").call(this, "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 __classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f").call(this, "transferable");
+    }
+    /** The feePayable balance of these tokens. Is generally the free amount - the feeFrozen amount. */
+    get feePayable() {
+        return __classPrivateFieldGet(this, _FiatSumBalancesFormatter_sum, "f").call(this, "feePayable");
+    }
+}
+_FiatSumBalancesFormatter_balances = new WeakMap(), _FiatSumBalancesFormatter_currency = new WeakMap(), _FiatSumBalancesFormatter_sum = new WeakMap();
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "total", null);
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "free", null);
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "reserved", null);
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "locked", null);
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "frozen", null);
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "transferable", null);
+__decorate([
+    Memoize()
+], FiatSumBalancesFormatter.prototype, "feePayable", null);
+export class SumBalancesFormatter {
+    constructor(balances) {
+        _SumBalancesFormatter_balances.set(this, void 0);
+        __classPrivateFieldSet(this, _SumBalancesFormatter_balances, balances, "f");
+        this.fiat = memoize(this.fiat);
+    }
+    fiat(currency) {
+        return new FiatSumBalancesFormatter(__classPrivateFieldGet(this, _SumBalancesFormatter_balances, "f"), currency);
+    }
+}
+_SumBalancesFormatter_balances = new WeakMap();

package/dist/types/balancetypes.d.ts

@@ -0,0 +1,88 @@
+import { ChainId, EvmNetworkId, MultiChainId, TokenId } from "@talismn/chaindata-provider";
+import { PluginBalanceTypes } from "../plugins";
+import { Address } from "./addresses";
+/**
+ * `BalanceTypes` is an automatically determined sub-selection of `PluginBalanceTypes`.
+ *
+ * It is the same list, but with any invalid `BalanceType` definitions filtered out.
+ */
+export declare type BalanceTypes = {
+    [BalanceType in keyof PluginBalanceTypes]: PluginBalanceTypes[BalanceType] extends IBalance ? PluginBalanceTypes[BalanceType] : never;
+};
+/**
+ * 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.
+ */
+export declare type BalanceJson = BalanceTypes[keyof BalanceTypes] extends never ? IBalance : BalanceTypes[keyof BalanceTypes];
+/** A collection of `BalanceJson` objects */
+export declare type BalanceJsonList = Record<string, BalanceJson>;
+export declare type BalanceStatus = "live" | "cache";
+/** `IBalance` is a common interface which all balance types must implement. */
+export declare type IBalance = {
+    /** The module that this balance was retrieved by */
+    source: string;
+    /** Has this balance never been fetched, or is it from a cache, or is it up to date? */
+    status: BalanceStatus;
+    /** The address of the account which owns this balance */
+    address: Address;
+    /** The token this balance is for */
+    tokenId: TokenId;
+    /** WIP, use `chainId` or `evmNetworkId` for now */
+    multiChainId: MultiChainId;
+    /** The substrate chain this balance is on */
+    chainId?: ChainId;
+    /** The evm chain this balance is on */
+    evmNetworkId?: EvmNetworkId;
+} & IBalanceAmounts;
+export declare type IBalanceAmounts = {
+    /** The portion of a balance that is not reserved. The free balance is the only balance that matters for most operations. */
+    free?: Amount | AmountWithLabel<string> | Array<AmountWithLabel<string>>;
+    /** The portion of a balance that is owned by the account but is reserved/suspended/unavailable. Reserved balance can still be slashed, but only after all the free balance has been slashed. */
+    reserves?: Amount | AmountWithLabel<string> | Array<AmountWithLabel<string>>;
+    /** A freeze on a specified amount of an account's free balance until a specified block number. Multiple locks always operate over the same funds, so they overlay rather than stack. */
+    locks?: Amount | LockedAmount<string> | Array<LockedAmount<string>>;
+    /** Additional balances held by an account. By default these will not be included in the account total. Dapps may choose to add support for showing extra amounts on a case by case basis. */
+    extra?: ExtraAmount<string> | Array<ExtraAmount<string>>;
+};
+/** An unlabelled amount of a balance */
+export declare type Amount = string;
+/** A labelled amount of a balance */
+export declare type AmountWithLabel<TLabel extends string> = {
+    label: TLabel;
+    amount: Amount;
+};
+/** A labelled locked amount of a balance */
+export declare type LockedAmount<TLabel extends string> = AmountWithLabel<TLabel> & {
+    /**
+     * By default, the largest locked amount is subtrated from the transferable amount of this balance.
+     * If this property is set to true, this particular lock will be skipped when making this calculation.
+     * As such, this locked amount will be included in the calculated transferable amount.
+     */
+    includeInTransferable?: boolean;
+    /**
+     * By default, tx fees can be deducted from locked amounts of balance.
+     * As such, locked amounts are ignored when calculating if the user has enough funds to pay tx fees.
+     * If this property is set to true, this particular lock will be subtracted from the available funds when making this calculation.
+     * As such, this locked amount will not be included in the calculated available funds.
+     */
+    excludeFromFeePayable?: boolean;
+};
+export declare function excludeFromTransferableAmount(locks: Amount | LockedAmount<string> | Array<LockedAmount<string>>): bigint;
+export declare function excludeFromFeePayableLocks(locks: Amount | LockedAmount<string> | Array<LockedAmount<string>>): Array<LockedAmount<string>>;
+/** A labelled extra amount of a balance */
+export declare type ExtraAmount<TLabel extends string> = AmountWithLabel<TLabel> & {
+    /** If set to true, this extra amount will be included in the calculation of the total amount of this balance. */
+    includeInTotal?: boolean;
+};
+export declare function includeInTotalExtraAmount(extra?: ExtraAmount<string> | Array<ExtraAmount<string>>): bigint;
+/** Used by plugins to help define their custom `BalanceType` */
+export declare type NewBalanceType<TModuleType extends string, T extends IBalanceAmounts> = IBalance & {
+    source: TModuleType;
+} & T;

package/dist/types/balancetypes.js

@@ -0,0 +1,28 @@
+import { BigMath } from "@talismn/util";
+export 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"));
+}
+export function excludeFromFeePayableLocks(locks) {
+    if (typeof locks === "string")
+        return [];
+    if (!Array.isArray(locks))
+        locks = [locks];
+    return locks.filter((lock) => lock.excludeFromFeePayable);
+}
+export 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"));
+}

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./addresses";
+export * from "./balances";
+export * from "./balancetypes";
+export * from "./subscriptions";

package/dist/types/index.js

@@ -0,0 +1,4 @@
+export * from "./addresses";
+export * from "./balances";
+export * from "./balancetypes";
+export * from "./subscriptions";

package/dist/types/subscriptions.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A callback with either an error or a result.
+ */
+export interface SubscriptionCallback<Result> {
+    (error: null, result: Result): void;
+    (error: any, result?: never): void;
+}
+/**
+ * A function which cancels a subscription when called.
+ */
+export declare type UnsubscribeFn = () => void;

package/dist/types/subscriptions.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@talismn/balances",
+  "version": "0.1.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/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist",
+    "/plugins"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "dev": "tsc --watch --declarationMap",
+    "build": "tsc --declarationMap",
+    "build:packages:prod": "rm -rf dist && tsc",
+    "prepack": "yarn build:packages:prod",
+    "test": "jest",
+    "lint": "eslint . --max-warnings 0",
+    "clean": "rm -rf dist && rm -rf .turbo rm -rf node_modules"
+  },
+  "dependencies": {
+    "@talismn/chain-connector": "^0.1.1",
+    "@talismn/chaindata-provider": "^0.1.1",
+    "@talismn/token-rates": "^0.1.1",
+    "@talismn/util": "^0.1.1",
+    "lodash": "^4.17.21",
+    "typescript-memoize": "^1.1.0"
+  },
+  "devDependencies": {
+    "@talismn/eslint-config": "^0.0.0",
+    "@talismn/tsconfig": "^0.0.0",
+    "@types/jest": "^27.5.1",
+    "eslint": "^8.4.0",
+    "jest": "^28.1.0",
+    "ts-jest": "^28.0.2",
+    "typescript": "^4.6.4"
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@talismn/eslint-config"
+    ]
+  }
+}

package/plugins/package.json

@@ -0,0 +1,5 @@
+{
+  "internal": true,
+  "main": "../dist/plugins.js",
+  "types": "../dist/plugins.d.ts"
+}