@exodus/balances 13.16.1 → 13.17.0

package/lib/module/index.js

@@ -0,0 +1,367 @@
+import { safeString } from '@exodus/safe-string';
+import { TxSet } from '@exodus/models';
+import { difference as getChanges } from '@exodus/atoms';
+import { difference, pick, set, mapValues } from '@exodus/basic-utils';
+import makeConcurrent from 'make-concurrent';
+import { processAssetBalances, validateBalances } from './balances-utils.js';
+import defaultConfig from '../default-config.js';
+const zipObject = (keys, values) => {
+    const result = Object.create(null);
+    for (const [i, key] of keys.entries()) {
+        result[key] = values[i];
+    }
+    return result;
+};
+export const cloneBalances = (balances) => {
+    const result = Object.create(null);
+    for (const walletAccount of Object.keys(balances)) {
+        const accountBalances = balances[walletAccount];
+        const clonedAccount = Object.create(null);
+        for (const assetName of Object.keys(accountBalances)) {
+            clonedAccount[assetName] = { ...accountBalances[assetName] };
+        }
+        result[walletAccount] = clonedAccount;
+    }
+    return result;
+};
+const zipNonNull = (keys, values) => {
+    const result = Object.create(null);
+    for (const [i, key] of keys.entries()) {
+        if (values[i] != null)
+            result[key] = values[i];
+    }
+    return result;
+};
+class Balances {
+    #logger;
+    #assetsAtom;
+    #assets = Object.create(null);
+    #availableAssetNamesAtom;
+    #availableAssetNames = [];
+    #balanceFieldsConfig;
+    #balanceFields;
+    #walletAccounts = [];
+    #ready = false;
+    #balances = Object.create(null);
+    #balancesAtom;
+    #blockchainMetadataAtom;
+    #feeDataAtom;
+    #enabledWalletAccountsAtom;
+    #loaded = false;
+    #subscriptions = [];
+    #errorTracking;
+    constructor({ assetsAtom, availableAssetNamesAtom, enabledWalletAccountsAtom, config, logger, balancesAtom, blockchainMetadataAtom, feeDataAtom, errorTracking, }) {
+        this.#logger = logger;
+        this.#assetsAtom = assetsAtom;
+        this.#availableAssetNamesAtom = availableAssetNamesAtom;
+        this.#balanceFieldsConfig = config?.balanceFieldsConfig || defaultConfig.balanceFieldsConfig;
+        this.#balanceFields = config?.balanceFields || defaultConfig.balanceFields;
+        this.#balancesAtom = balancesAtom;
+        this.#blockchainMetadataAtom = blockchainMetadataAtom;
+        this.#feeDataAtom = feeDataAtom;
+        this.#enabledWalletAccountsAtom = enabledWalletAccountsAtom;
+        this.#errorTracking = errorTracking;
+        const shareQueue = (fn) => (...args) => {
+            if (!this.#ready)
+                return;
+            void this.#pushIntoSharedQueue(() => fn.apply(this, args));
+        };
+        const swallowErrors = (fn, method) => async (...args) => {
+            try {
+                return await fn(...args);
+            }
+            catch (error) {
+                this.#errorTracking.track({ error: new Error(method, { cause: error }) });
+            }
+        };
+        this.#updateAssetSource = shareQueue(this.#updateAssetSource);
+        this.#handleBlockchainMetadataUpdate = shareQueue(this.#handleBlockchainMetadataUpdate);
+        this.#handleFeeDataUpdate = shareQueue(this.#handleFeeDataUpdate);
+        this.#recompute = shareQueue(this.#recompute);
+        this.#onAssetsChanged = shareQueue(this.#onAssetsChanged);
+        this.#getBalancesForAssetSource = swallowErrors(this.#getBalancesForAssetSource, safeString `getBalancesForAssetSource`);
+        this.#setWalletAccounts = swallowErrors(this.#setWalletAccounts, safeString `setWalletAccounts`);
+    }
+    load = async () => {
+        if (this.#loaded)
+            return;
+        this.#loaded = true;
+        const { value } = await this.#assetsAtom.get();
+        this.#assets = value;
+        this.#subscriptions.push(this.#assetsAtom.observe(({ value }) => {
+            this.#assets = value;
+        }), this.#enabledWalletAccountsAtom.observe((payload) => {
+            void this.#setWalletAccounts(Object.keys(payload));
+        }), this.#blockchainMetadataAtom.observe(({ accountStateChanges, txLogChanges }) => {
+            this.#flattenToBlockchainMetadataObjects({ accountStateChanges, txLogChanges }).forEach(({ walletAccount, assetName, accountState, txLogsByAssetName }) => this.#handleBlockchainMetadataUpdate({
+                walletAccount,
+                assetName,
+                accountState,
+                txLogsByAssetName,
+            }));
+        }), this.#feeDataAtom.observe((changes) => {
+            Object.entries(changes).forEach(([assetName, feeData]) => {
+                const asset = this.#getAsset(assetName).baseAsset;
+                if (asset.api?.features?.balancesRequireFeeData) {
+                    this.#walletAccounts.forEach((walletAccount) => {
+                        return this.#handleFeeDataUpdate({ walletAccount, assetName, feeData });
+                    });
+                }
+            });
+        }), getChanges(this.#availableAssetNamesAtom).observe(({ previous = [], current }) => {
+            this.#availableAssetNames = current;
+            const added = difference(current, previous);
+            const removed = difference(previous, current);
+            if (added.length > 0 || removed.length > 0)
+                void this.#onAssetsChanged({ added, removed });
+        }));
+        this.#availableAssetNames = await this.#availableAssetNamesAtom.get();
+    };
+    #getAsset = (assetName) => this.#assets[assetName];
+    #getAssets = () => this.#assets;
+    #flattenToBlockchainMetadataObjects = ({ accountStateChanges = Object.create(null), txLogChanges = Object.create(null), }) => {
+        const byBaseAssetName = mapValues(accountStateChanges, (accountStates) => mapValues(accountStates, (accountState) => ({ accountState })));
+        Object.entries(txLogChanges).forEach(([walletAccount, txLogs]) => {
+            Object.entries(txLogs).map(([assetName, txLog]) => {
+                const { baseAsset } = this.#getAsset(assetName);
+                set(byBaseAssetName, [walletAccount, baseAsset.name, 'txLogsByAssetName', assetName], txLog);
+            });
+        });
+        return Object.entries(byBaseAssetName).flatMap(([walletAccount, baseAssets]) => Object.entries(baseAssets).map(([baseAssetName, { accountState, txLogsByAssetName }]) => ({
+            walletAccount,
+            assetName: baseAssetName,
+            ...(accountState && { accountState }),
+            ...(txLogsByAssetName && { txLogsByAssetName }),
+        })));
+    };
+    #handleBlockchainMetadataUpdate = (opts) => {
+        if (!this.#ready) {
+            this.#logger.log('ignore update from blockchain-metadata event.', { isReady: this.#ready });
+            return;
+        }
+        return this.#updateAssetSource(opts);
+    };
+    #handleFeeDataUpdate = (opts) => {
+        if (!this.#ready) {
+            this.#logger.log('ignore update from fee-data event.', { isReady: this.#ready });
+            return;
+        }
+        return this.#updateAssetSource(opts);
+    };
+    #pushIntoSharedQueue = makeConcurrent((fn) => fn(), { concurrency: 1 });
+    #reset = ({ walletAccounts = this.#walletAccounts } = {}) => {
+        walletAccounts.forEach((walletAccount) => {
+            this.#balances[walletAccount] = Object.create(null);
+        });
+    };
+    #getBalancesForAssetSource = async ({ walletAccount, assetName, }) => {
+        const metadata = await this.#loadBlockchainMetadataForBalance({
+            walletAccount,
+            assetName,
+        });
+        return this.#getBalancesFromBlockchainMetadata({
+            assetNames: this.#getRelatedAssetNames(assetName),
+            ...metadata,
+        });
+    };
+    #getBalancesFromBlockchainMetadata = ({ assetNames, accountState, feeData, txLogsByAssetName, }) => {
+        const getAssetBalances = (assetName) => {
+            const asset = this.#getAsset(assetName);
+            const txLog = txLogsByAssetName[assetName];
+            const zero = asset.currency.ZERO;
+            const apiBalances = asset.api.getBalances({ asset, accountState, txLog, feeData });
+            const balances = processAssetBalances({
+                balanceFieldsConfig: this.#balanceFieldsConfig,
+                balances: apiBalances || Object.create(null),
+                zero,
+            });
+            return validateBalances({
+                balances: pick(balances, this.#balanceFields),
+                asset,
+                logger: this.#logger,
+            });
+        };
+        const balances = assetNames.map(getAssetBalances);
+        return zipNonNull(assetNames, balances);
+    };
+    #getBalancesForWalletAccount = async ({ walletAccount, }) => {
+        const assetNames = this.#getSupportedAssetNames();
+        const results = await Promise.allSettled(assetNames.map((assetName) => this.#getBalancesForAssetSource({ assetName, walletAccount })));
+        const balances = results
+            .map((result) => (result.status === 'fulfilled' ? result.value : undefined))
+            .filter(Boolean);
+        const accountBalances = Object.create(null);
+        Object.assign(accountBalances, ...balances);
+        return accountBalances;
+    };
+    #load = async ({ walletAccount }) => {
+        this.#logger.log(`loading walletAccount ${walletAccount}`);
+        this.#balances[walletAccount] = await this.#getBalancesForWalletAccount({ walletAccount });
+    };
+    #setWalletAccounts = async (walletAccounts) => {
+        const added = difference(walletAccounts, this.#walletAccounts);
+        const removed = difference(this.#walletAccounts, walletAccounts);
+        if (added.length === 0 && removed.length === 0)
+            return;
+        this.#walletAccounts = walletAccounts;
+        this.#ready = true;
+        if (removed.length > 0) {
+            this.#logger.log('recomputing after removing walletAccounts', removed);
+            removed.forEach((walletAccount) => {
+                delete this.#balances[walletAccount];
+            });
+        }
+        if (added.length > 0) {
+            this.#logger.log('recomputing after adding walletAccounts', added);
+            await this.#recompute({ walletAccounts: added });
+        }
+        else {
+            this.#flush();
+        }
+    };
+    #onAssetsChanged = async ({ added, removed }) => {
+        if (removed.length > 0) {
+            for (const walletAccount of this.#walletAccounts) {
+                for (const assetName of removed) {
+                    delete this.#balances[walletAccount]?.[assetName];
+                }
+            }
+        }
+        const newSupportedAssets = added.filter(this.#isSupportedAsset);
+        const missingAssets = newSupportedAssets.filter((name) => !this.#walletAccounts.every((walletAccount) => !!this.#balances?.[walletAccount]?.[name]));
+        if (missingAssets.length === 0) {
+            if (removed.length > 0)
+                this.#flush();
+            return;
+        }
+        this.#logger.log('computing balances for newly available assets', missingAssets);
+        await Promise.all(this.#walletAccounts.map(async (walletAccount) => {
+            const balances = await Promise.all(missingAssets.map((assetName) => this.#getBalancesForAssetSource({ assetName, walletAccount })));
+            if (this.#balances[walletAccount]) {
+                Object.assign(this.#balances[walletAccount], ...balances);
+            }
+        }));
+        this.#flush();
+    };
+    #isSupportedAsset = (assetName) => {
+        if (!this.#availableAssetNames.includes(assetName))
+            return false;
+        const asset = this.#getAsset(assetName);
+        return asset && !asset.isCombined;
+    };
+    #getSupportedAssetNames = () => Object.keys(this.#getAssets()).filter(this.#isSupportedAsset);
+    #getRelatedAssetNames = (assetName) => {
+        const asset = this.#assets[assetName];
+        if (asset.baseAsset.name === assetName) {
+            return Object.keys(this.#assets).filter((name) => this.#assets[name].baseAsset.name === assetName && this.#isSupportedAsset(name));
+        }
+        return [assetName];
+    };
+    #loadBlockchainMetadataForBalance = async ({ assetName, walletAccount, feeData: providedFeeData, accountState: providedAccountState = null, txLogsByAssetName: providedTxLogsByAssetName = {}, }) => {
+        const { value: { txs: txLogsByAssetSource, accountStates }, } = await this.#blockchainMetadataAtom.get();
+        let accountState = providedAccountState;
+        const baseAsset = this.#getAsset(assetName).baseAsset;
+        if (!accountState) {
+            const cached = accountStates[walletAccount]?.[baseAsset.name];
+            if (cached) {
+                accountState = cached;
+            }
+            else {
+                const AccountState = baseAsset.api?.createAccountState?.();
+                accountState = AccountState?.create();
+            }
+        }
+        let feeData = providedFeeData;
+        if (!feeData && baseAsset.api?.features?.balancesRequireFeeData) {
+            const fees = await this.#feeDataAtom.get();
+            feeData = fees[baseAsset.name];
+        }
+        const assetNames = this.#getRelatedAssetNames(assetName);
+        const txLogsByAssetName = zipObject(assetNames, assetNames.map((assetName) => providedTxLogsByAssetName[assetName] ||
+            txLogsByAssetSource[walletAccount]?.[assetName] ||
+            TxSet.EMPTY));
+        return {
+            feeData,
+            accountState,
+            txLogsByAssetName,
+        };
+    };
+    #updateAssetSource = async ({ assetName, walletAccount, accountState: providedAccountState, txLogsByAssetName: providedTxLogsByAssetName, feeData: providedFeeData, }) => {
+        if (!this.#isSupportedAsset(assetName))
+            return;
+        if (!this.#walletAccounts.includes(walletAccount)) {
+            this.#logger.warn(`unexpected update for disabled walletAccount ${walletAccount}`);
+            return;
+        }
+        const { accountState, txLogsByAssetName, feeData } = await this.#loadBlockchainMetadataForBalance({
+            assetName,
+            walletAccount,
+            feeData: providedFeeData,
+            accountState: providedAccountState,
+            txLogsByAssetName: providedTxLogsByAssetName,
+        });
+        const accountBalances = this.#balances[walletAccount];
+        const newBalances = this.#getBalancesFromBlockchainMetadata({
+            assetNames: this.#getRelatedAssetNames(assetName),
+            accountState,
+            txLogsByAssetName,
+            feeData,
+        });
+        const changes = Object.create(null);
+        for (const subAssetName in newBalances) {
+            const { currency } = this.#getAsset(subAssetName);
+            const newAssetBalances = newBalances?.[subAssetName];
+            for (const field of this.#balanceFields) {
+                const oldBalance = accountBalances?.[subAssetName]?.[field];
+                const newBalance = newAssetBalances?.[field];
+                if (!newBalance)
+                    continue;
+                if ((oldBalance || currency.ZERO).equals(newBalance))
+                    continue;
+                this.#logger.log(`updating assetSource ${walletAccount}:${assetName}`);
+                set(changes, [walletAccount, subAssetName, field], {
+                    from: oldBalance ?? currency.ZERO,
+                    to: newBalance,
+                });
+                set(accountBalances, [subAssetName, field], newBalance);
+            }
+        }
+        if (Object.keys(changes).length > 0)
+            this.#flush({ changes });
+    };
+    #recompute = async ({ walletAccounts = this.#walletAccounts, } = {}) => {
+        this.#reset({ walletAccounts });
+        await Promise.all(walletAccounts.map((walletAccount) => this.#load({ walletAccount })));
+        this.#flush();
+    };
+    #flush = ({ changes } = {}) => {
+        const balances = cloneBalances(this.#balances);
+        if (Object.keys(balances).length === 0)
+            return;
+        this.#logger.log('balances updated');
+        void this.#balancesAtom.set({ balances, changes });
+    };
+    stop = () => {
+        this.#subscriptions.forEach((unsubscribe) => unsubscribe());
+        this.#subscriptions = [];
+    };
+}
+const createBalances = (opts) => new Balances(opts);
+const balancesDefinition = {
+    id: 'balances',
+    type: 'module',
+    factory: createBalances,
+    dependencies: [
+        'assetsAtom',
+        'availableAssetNamesAtom',
+        'enabledWalletAccountsAtom',
+        'config',
+        'logger',
+        'balancesAtom',
+        'blockchainMetadataAtom',
+        'feeDataAtom',
+        'errorTracking',
+    ],
+    public: true,
+};
+export default balancesDefinition;

package/lib/module/mockable-balances.d.ts

@@ -0,0 +1,16 @@
+import type { BalancesModule } from './types.js';
+import type { BalancesAtom, BalancesByAssetSource } from '../types.js';
+declare const mockableBalancesDefinition: {
+    readonly id: "balances";
+    readonly type: "module";
+    readonly factory: (opts: Options) => BalancesModule;
+    readonly dependencies: readonly ["config", "balancesAtom"];
+    readonly public: true;
+};
+type Options = {
+    config: {
+        importReport: BalancesByAssetSource;
+    };
+    balancesAtom: BalancesAtom;
+};
+export default mockableBalancesDefinition;

package/lib/module/mockable-balances.js

@@ -0,0 +1,21 @@
+class Balances {
+    #balancesAtom;
+    #configBalances;
+    constructor({ config, balancesAtom }) {
+        this.#balancesAtom = balancesAtom;
+        this.#configBalances = config.importReport;
+    }
+    load = async () => {
+        void this.#balancesAtom.set({ balances: this.#configBalances });
+    };
+    stop = () => { };
+}
+const createBalances = (opts) => new Balances(opts);
+const mockableBalancesDefinition = {
+    id: 'balances',
+    type: 'module',
+    factory: createBalances,
+    dependencies: ['config', 'balancesAtom'],
+    public: true,
+};
+export default mockableBalancesDefinition;

package/lib/module/types.d.ts

@@ -0,0 +1,80 @@
+import type { Atom, ReadonlyAtom, Logger } from '@exodus/atoms';
+import type { TxSet, WalletAccount } from '@exodus/models';
+import type { BaseAsset } from '@exodus/asset-types';
+import type { BalancesAtomValue, BalancesByAssetSource } from '../types.js';
+import type NumberUnit from '@exodus/currency';
+export type FieldBalances = Record<string, NumberUnit>;
+export type BalanceFieldConfig = {
+    name: string;
+    legacyName?: string;
+    default?: string;
+};
+export type BalancesConfig = {
+    balanceFieldsConfig: BalanceFieldConfig[];
+    balanceFields: string[];
+    assetsToTrackForBalances: {
+        assetName: string;
+        analyticsName: string;
+    }[];
+    importReport?: BalancesByAssetSource;
+};
+export type AccountState = object;
+export type FeeData = Record<string, unknown>;
+export type Metadata = {
+    accountState?: AccountState | null;
+    txLogsByAssetName: Record<string, TxSet>;
+    feeData?: FeeData;
+};
+export type Source = {
+    walletAccount: string;
+    assetName: string;
+};
+export type SourceUpdate = Source & Partial<Metadata>;
+export type MetadataChanges = {
+    accountStateChanges?: Record<string, Record<string, AccountState>>;
+    txLogChanges?: Record<string, Record<string, TxSet>>;
+};
+export type BalanceAsset = Pick<BaseAsset, 'name' | 'currency'> & {
+    isCombined?: boolean;
+    baseAsset: BalanceAsset;
+    api: {
+        features?: {
+            balancesRequireFeeData?: boolean;
+        };
+        createAccountState?: () => {
+            create(): AccountState;
+        };
+        getBalances(params: {
+            asset: BalanceAsset;
+            accountState?: AccountState | null;
+            txLog?: TxSet;
+            feeData?: FeeData;
+        }): FieldBalances | undefined;
+    };
+};
+export type Options = {
+    assetsAtom: ReadonlyAtom<{
+        value: Record<string, BalanceAsset>;
+    }>;
+    availableAssetNamesAtom: ReadonlyAtom<string[]>;
+    enabledWalletAccountsAtom: ReadonlyAtom<Record<string, WalletAccount>>;
+    config?: Partial<BalancesConfig>;
+    logger: Pick<Logger, 'log' | 'warn'>;
+    balancesAtom: Atom<BalancesAtomValue>;
+    blockchainMetadataAtom: ReadonlyAtom<MetadataChanges & {
+        value: {
+            txs: Record<string, Record<string, TxSet>>;
+            accountStates: Record<string, Record<string, AccountState>>;
+        };
+    }>;
+    feeDataAtom: ReadonlyAtom<Record<string, FeeData>>;
+    errorTracking: {
+        track(params: {
+            error: Error;
+        }): void;
+    };
+};
+export interface BalancesModule {
+    load(): Promise<void>;
+    stop(): void;
+}

package/lib/module/types.js

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

package/lib/plugins/analytics.d.ts

@@ -0,0 +1,18 @@
+import type { HasBalanceAtom } from '../types.js';
+import type { ReadonlyAtom } from '@exodus/atoms';
+import type { BalancesConfig } from '../module/types.js';
+import type NumberUnit from '@exodus/currency';
+declare const createBalancesAnalyticsPlugin: ({ analytics, hasBalanceAtom, assetsWithBalanceCountAtom, assetsTotalWalletAmountsAtom, config: { assetsToTrackForBalances }, }: {
+    analytics: {
+        requireDefaultEventProperties(keys: string[]): void;
+        setDefaultEventProperties(properties: Record<string, boolean | number>): void;
+    };
+    hasBalanceAtom: Pick<HasBalanceAtom, "get" | "observe">;
+    assetsWithBalanceCountAtom: ReadonlyAtom<number>;
+    assetsTotalWalletAmountsAtom: ReadonlyAtom<Map<string, NumberUnit>>;
+    config: Pick<BalancesConfig, "assetsToTrackForBalances">;
+}) => {
+    onStart: () => void;
+    onStop: () => void;
+};
+export default createBalancesAnalyticsPlugin;

package/lib/plugins/analytics.js

@@ -0,0 +1,30 @@
+const createBalancesAnalyticsPlugin = ({ analytics, hasBalanceAtom, assetsWithBalanceCountAtom, assetsTotalWalletAmountsAtom, config: { assetsToTrackForBalances }, }) => {
+    let subscriptions = [];
+    const getAssetAmountFromNumberUnit = (unit) => {
+        if (!unit)
+            return 0;
+        return unit.toDefaultNumber();
+    };
+    const onStart = () => {
+        analytics.requireDefaultEventProperties(['hasBalance', 'numberOfAssets']);
+        const unsubscribeBalanceAtom = hasBalanceAtom.observe((hasBalance) => analytics.setDefaultEventProperties({ hasBalance }));
+        const unsubscribeBalanceCountAtom = assetsWithBalanceCountAtom.observe((numberOfAssets) => analytics.setDefaultEventProperties({ numberOfAssets }));
+        const unsubscribeWalletAmountsAtom = assetsTotalWalletAmountsAtom.observe(async (balances) => {
+            const assetBalances = assetsToTrackForBalances.reduce((acc, obj) => {
+                acc[obj.analyticsName] = getAssetAmountFromNumberUnit(balances.get(obj.assetName));
+                return acc;
+            }, Object.create(null));
+            analytics.setDefaultEventProperties(assetBalances);
+        });
+        subscriptions = [
+            unsubscribeBalanceAtom,
+            unsubscribeBalanceCountAtom,
+            unsubscribeWalletAmountsAtom,
+        ];
+    };
+    const onStop = () => {
+        subscriptions.forEach((unsubscribe) => unsubscribe());
+    };
+    return { onStart, onStop };
+};
+export default createBalancesAnalyticsPlugin;

package/lib/plugins/index.d.ts

@@ -0,0 +1,35 @@
+export declare const balancesLifecyclePluginDefinition: {
+    readonly id: "balancesLifecyclePlugin";
+    readonly type: "plugin";
+    readonly factory: ({ balancesAtom, port, balances, hasBalanceAtom, }: {
+        balancesAtom: import("../types.js").BalancesAtom;
+        port: import("@exodus/atoms").Port<import("../types.js").BalancesAtomValue | boolean | undefined>;
+        balances: import("../module/types.js").BalancesModule;
+        hasBalanceAtom: import("../types.js").HasBalanceAtom;
+    }) => {
+        onLoad: () => void;
+        onStop: () => void;
+        onClear: () => Promise<void>;
+    };
+    readonly dependencies: readonly ["balancesAtom", "port", "balances", "hasBalanceAtom"];
+    readonly public: true;
+};
+export declare const balancesAnalyticsPluginDefinition: {
+    readonly id: "balancesAnalyticsPlugin";
+    readonly type: "plugin";
+    readonly factory: ({ analytics, hasBalanceAtom, assetsWithBalanceCountAtom, assetsTotalWalletAmountsAtom, config: { assetsToTrackForBalances }, }: {
+        analytics: {
+            requireDefaultEventProperties(keys: string[]): void;
+            setDefaultEventProperties(properties: Record<string, boolean | number>): void;
+        };
+        hasBalanceAtom: Pick<import("../types.js").HasBalanceAtom, "get" | "observe">;
+        assetsWithBalanceCountAtom: import("@exodus/atoms").ReadonlyAtom<number>;
+        assetsTotalWalletAmountsAtom: import("@exodus/atoms").ReadonlyAtom<Map<string, import("@exodus/currency").default>>;
+        config: Pick<import("../module/types.js").BalancesConfig, "assetsToTrackForBalances">;
+    }) => {
+        onStart: () => void;
+        onStop: () => void;
+    };
+    readonly dependencies: readonly ["analytics", "hasBalanceAtom", "assetsWithBalanceCountAtom", "assetsTotalWalletAmountsAtom", "config?"];
+    readonly public: true;
+};

package/lib/plugins/index.js

@@ -0,0 +1,22 @@
+import createBalancesAnalyticsPlugin from './analytics.js';
+import createBalancesLifecyclePlugin from './lifecycle.js';
+export const balancesLifecyclePluginDefinition = {
+    id: 'balancesLifecyclePlugin',
+    type: 'plugin',
+    factory: createBalancesLifecyclePlugin,
+    dependencies: ['balancesAtom', 'port', 'balances', 'hasBalanceAtom'],
+    public: true,
+};
+export const balancesAnalyticsPluginDefinition = {
+    id: 'balancesAnalyticsPlugin',
+    type: 'plugin',
+    factory: createBalancesAnalyticsPlugin,
+    dependencies: [
+        'analytics',
+        'hasBalanceAtom',
+        'assetsWithBalanceCountAtom',
+        'assetsTotalWalletAmountsAtom',
+        'config?',
+    ],
+    public: true,
+};

package/lib/plugins/lifecycle.d.ts

@@ -0,0 +1,14 @@
+import type { BalancesModule } from '../module/types.js';
+import type { HasBalanceAtom, BalancesAtom, BalancesAtomValue } from '../types.js';
+import type { Port } from '@exodus/atoms';
+declare const createBalancesLifecyclePlugin: ({ balancesAtom, port, balances, hasBalanceAtom, }: {
+    balancesAtom: BalancesAtom;
+    port: Port<BalancesAtomValue | boolean | undefined>;
+    balances: BalancesModule;
+    hasBalanceAtom: HasBalanceAtom;
+}) => {
+    onLoad: () => void;
+    onStop: () => void;
+    onClear: () => Promise<void>;
+};
+export default createBalancesLifecyclePlugin;

package/lib/plugins/lifecycle.js

@@ -0,0 +1,32 @@
+import { createAtomObserver } from '@exodus/atoms';
+const createBalancesLifecyclePlugin = ({ balancesAtom, port, balances, hasBalanceAtom, }) => {
+    const balancesAtomObserver = createAtomObserver({
+        port,
+        atom: balancesAtom,
+        event: 'balances',
+    });
+    const hasBalanceAtomObserver = createAtomObserver({
+        port,
+        atom: hasBalanceAtom,
+        event: 'hasBalance',
+    });
+    const onLoad = () => {
+        hasBalanceAtomObserver.start();
+        balancesAtomObserver.start();
+        void balances.load();
+    };
+    const onStop = () => {
+        balancesAtomObserver.unregister();
+        hasBalanceAtomObserver.unregister();
+        balances.stop();
+    };
+    const onClear = async () => {
+        await hasBalanceAtom.set(undefined);
+    };
+    return {
+        onLoad,
+        onStop,
+        onClear,
+    };
+};
+export default createBalancesLifecyclePlugin;

package/lib/redux/id.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "balances";
+export default _default;

package/lib/redux/id.js

@@ -0,0 +1 @@
+export default 'balances';