@exodus/balances 13.16.1 → 13.17.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [13.17.0](https://github.com/ExodusMovement/exodus/compare/@exodus/balances@13.16.1...@exodus/balances@13.17.0) (2026-11-13)
+
+### Features
+
+- **balances:** migrate to TypeScript ([#48879](https://github.com/ExodusMovement/exodus/issues/48879)) ([6f6294b](https://github.com/ExodusMovement/exodus/commit/6f6294bb458c26ba5e59d1cc9125ab39ce7a909e))
+
 ## [13.16.1](https://github.com/ExodusMovement/exodus/compare/@exodus/balances@13.16.0...@exodus/balances@13.16.1) (2026-10-09)
 
 **Note:** Version bump only for package @exodus/balances

package/atoms/asset-names-with-balance.d.ts

@@ -0,0 +1 @@
+export { default } from '../lib/atoms/asset-names-with-balance.js'

package/atoms/asset-names-with-balance.js

@@ -1,40 +1 @@
-import { compute } from '@exodus/atoms'
-
-const setsAreEqual = (setA, setB) => {
-  if (setA.size !== setB.size) {
-    return false
-  }
-
-  for (const item of setA) {
-    if (!setB.has(item)) {
-      return false
-    }
-  }
-
-  return true
-}
-
-const createAssetNamesWithBalanceAtom = ({ balancesAtom }) => {
-  let previousValue = new Set()
-  const selector = ({ balances }) => {
-    const assetsWithBalances = new Set()
-
-    Object.values(balances).forEach((accountBalances) => {
-      Object.keys(accountBalances).forEach((assetName) => {
-        if (!accountBalances[assetName]?.balance.isZero) {
-          assetsWithBalances.add(assetName)
-        }
-      })
-    })
-
-    if (!setsAreEqual(assetsWithBalances, previousValue)) {
-      previousValue = assetsWithBalances
-    }
-
-    return previousValue
-  }
-
-  return compute({ atom: balancesAtom, selector })
-}
-
-export default createAssetNamesWithBalanceAtom
+export { default } from '../lib/atoms/asset-names-with-balance.js'

package/atoms/asset-total-wallet-amounts.d.ts

@@ -0,0 +1 @@
+export { default } from '../lib/atoms/asset-total-wallet-amounts.js'

package/atoms/asset-total-wallet-amounts.js

@@ -1,47 +1 @@
-import { compute, dedupe } from '@exodus/atoms'
-
-const numberUnitMapsAreEqual = (mapA, mapB) => {
-  if (mapA.size !== mapB.size) {
-    return false
-  }
-
-  for (const [key, val] of mapA) {
-    const itemB = mapB.get(key)
-    if (!itemB || !itemB.equals(val)) {
-      return false
-    }
-  }
-
-  return true
-}
-
-const createAssetTotalWalletAmountsAtom = ({ balancesAtom }) => {
-  let previousValue = new Map()
-  const selector = ({ balances }) => {
-    const assetsWithBalances = new Map()
-
-    Object.values(balances).forEach((accountBalances) => {
-      Object.keys(accountBalances).forEach((assetName) => {
-        const accountAssetBalance = accountBalances[assetName] && accountBalances[assetName].balance
-        if (accountAssetBalance) {
-          if (assetsWithBalances.has(assetName)) {
-            const currentAssetBalance = assetsWithBalances.get(assetName)
-            assetsWithBalances.set(assetName, accountAssetBalance.add(currentAssetBalance))
-          } else {
-            assetsWithBalances.set(assetName, accountAssetBalance)
-          }
-        }
-      })
-    })
-
-    if (!numberUnitMapsAreEqual(assetsWithBalances, previousValue)) {
-      previousValue = assetsWithBalances
-    }
-
-    return previousValue
-  }
-
-  return dedupe(compute({ atom: balancesAtom, selector }))
-}
-
-export default createAssetTotalWalletAmountsAtom
+export { default } from '../lib/atoms/asset-total-wallet-amounts.js'

package/atoms/assets-with-balance-count.d.ts

@@ -0,0 +1 @@
+export { default } from '../lib/atoms/assets-with-balance-count.js'

package/atoms/assets-with-balance-count.js

@@ -1,8 +1 @@
-import { compute } from '@exodus/atoms'
-
-const createAssetsWithBalanceCountAtom = ({ assetNamesWithBalanceAtom }) => {
-  const selector = (assetNamesWithBalance) => assetNamesWithBalance.size
-  return compute({ atom: assetNamesWithBalanceAtom, selector })
-}
-
-export default createAssetsWithBalanceCountAtom
+export { default } from '../lib/atoms/assets-with-balance-count.js'

package/atoms/balances.d.ts

@@ -0,0 +1 @@
+export { default } from '../lib/atoms/balances.js'

package/atoms/balances.js

@@ -1,6 +1 @@
-import { createInMemoryAtom } from '@exodus/atoms'
-
-// oxlint-disable-next-line @exodus/oxlint-plugin-hydra/in-memory-atom-default-value
-const createBalancesAtom = () => createInMemoryAtom()
-
-export default createBalancesAtom
+export { default } from '../lib/atoms/balances.js'

package/atoms/funded-wallet-accounts.d.ts

@@ -0,0 +1 @@
+export { default } from '../lib/atoms/funded-wallet-accounts.js'

package/atoms/funded-wallet-accounts.js

@@ -1,25 +1 @@
-import { combine, compute, dedupe } from '@exodus/atoms'
-import { mapValues } from '@exodus/basic-utils'
-
-const computeFundedWalletAccounts = ({ walletAccounts, balances }) => {
-  return mapValues(walletAccounts, (_, key) => {
-    const walletAccountBalaces = balances.balances[key] || {}
-    return Object.values(walletAccountBalaces).some(({ balance }) => !balance.isZero)
-  })
-}
-
-const createFundedWalletAccountsAtom = ({ balancesAtom, enabledWalletAccountsAtom }) => {
-  const walletAccountsBalanceAtom = combine({
-    walletAccounts: enabledWalletAccountsAtom,
-    balances: balancesAtom,
-  })
-
-  return dedupe(
-    compute({
-      atom: walletAccountsBalanceAtom,
-      selector: computeFundedWalletAccounts,
-    })
-  )
-}
-
-export default createFundedWalletAccountsAtom
+export { default } from '../lib/atoms/funded-wallet-accounts.js'

package/atoms/has-balance.d.ts

@@ -0,0 +1 @@
+export { default } from '../lib/atoms/has-balance.js'

package/atoms/has-balance.js

@@ -1,31 +1 @@
-import { compute, createStorageAtomFactory } from '@exodus/atoms'
-// eslint-disable-next-line no-restricted-imports -- TODO: Fix this the next time the file is edited.
-import lodash from 'lodash'
-
-const { flatMap, map } = lodash
-
-// balancesAtom schema: { balances: { [walletAccount]: { [assetName]: { balance: NumberUnit } } } } }
-
-const createComputedAtom = ({ balancesAtom }) => {
-  const selector = ({ balances } = {}) => {
-    const numberUnits = flatMap(balances, (value) => map(value, 'balance'))
-    return numberUnits.some((numberUnit) => (numberUnit ? !numberUnit.isZero : false))
-  }
-
-  return compute({ atom: balancesAtom, selector })
-}
-
-const createHasBalanceAtom = ({ balancesAtom, storage }) => {
-  const storageAtom = createStorageAtomFactory({ storage })({
-    key: 'hasBalance',
-    defaultValue: false,
-    isSoleWriter: true,
-  })
-  const computedAtom = createComputedAtom({ balancesAtom })
-  // oxlint-disable-next-line @exodus/oxlint-plugin-hydra/no-eternal-subscription
-  computedAtom.observe((value) => storageAtom.set(value))
-
-  return storageAtom
-}
-
-export default createHasBalanceAtom
+export { default } from '../lib/atoms/has-balance.js'

package/atoms/index.d.ts

@@ -0,0 +1,8 @@
+export {
+  balancesAtomDefinition,
+  hasBalanceAtomDefinition,
+  fundedWalletAccountsAtomDefinition,
+  assetNamesWithBalanceAtomDefinition,
+  assetsWithBalanceCountAtomDefinition,
+  assetsTotalWalletAmountsDefinition,
+} from '../lib/atoms/index.js'

package/atoms/index.js

@@ -1,54 +1,8 @@
-import createAssetNamesWithBalanceAtom from './asset-names-with-balance.js'
-import createAssetsWithBalanceCountAtom from './assets-with-balance-count.js'
-import createBalancesAtom from './balances.js'
-import createFundedWalletAccountsAtom from './funded-wallet-accounts.js'
-import createHasBalanceAtom from './has-balance.js'
-import createAssetsTotalWalletAmountsAtom from './asset-total-wallet-amounts.js'
-
-export const balancesAtomDefinition = {
-  id: 'balancesAtom',
-  type: 'atom',
-  factory: createBalancesAtom,
-  dependencies: [],
-  public: true,
-}
-
-export const hasBalanceAtomDefinition = {
-  id: 'hasBalanceAtom',
-  type: 'atom',
-  factory: createHasBalanceAtom,
-  dependencies: ['balancesAtom', 'storage'],
-  public: true,
-}
-
-export const fundedWalletAccountsAtomDefinition = {
-  id: 'fundedWalletAccountsAtom',
-  type: 'atom',
-  factory: createFundedWalletAccountsAtom,
-  dependencies: ['balancesAtom', 'enabledWalletAccountsAtom'],
-  public: true,
-}
-
-export const assetNamesWithBalanceAtomDefinition = {
-  id: 'assetNamesWithBalanceAtom',
-  type: 'atom',
-  factory: createAssetNamesWithBalanceAtom,
-  dependencies: ['balancesAtom'],
-  public: true,
-}
-
-export const assetsWithBalanceCountAtomDefinition = {
-  id: 'assetsWithBalanceCountAtom',
-  type: 'atom',
-  factory: createAssetsWithBalanceCountAtom,
-  dependencies: ['assetNamesWithBalanceAtom'],
-  public: true,
-}
-
-export const assetsTotalWalletAmountsDefinition = {
-  id: 'assetsTotalWalletAmountsAtom',
-  type: 'atom',
-  factory: createAssetsTotalWalletAmountsAtom,
-  dependencies: ['balancesAtom'],
-  public: true,
-}
+export {
+  balancesAtomDefinition,
+  hasBalanceAtomDefinition,
+  fundedWalletAccountsAtomDefinition,
+  assetNamesWithBalanceAtomDefinition,
+  assetsWithBalanceCountAtomDefinition,
+  assetsTotalWalletAmountsDefinition,
+} from '../lib/atoms/index.js'

package/default-config.d.ts

@@ -0,0 +1 @@
+export { default } from './lib/default-config.js'

package/default-config.js

@@ -1,26 +1 @@
-const balanceFieldsConfig = [
-  { name: 'total', legacyName: 'balance', default: 'zero' },
-  { name: 'spendable', legacyName: 'spendableBalance', default: 'total' },
-  { name: 'unconfirmedSent', default: 'zero' },
-  { name: 'unconfirmedReceived', default: 'zero' },
-  { name: 'unspendable', default: 'zero' },
-  { name: 'walletReserve', default: 'zero' },
-  { name: 'networkReserve', default: 'zero' },
-  { name: 'staking', default: 'zero' },
-  { name: 'staked', default: 'zero' },
-  { name: 'stakeable', default: 'zero' },
-  { name: 'unstaking', default: 'zero' },
-  { name: 'unstaked', default: 'zero' },
-  { name: 'rewards', default: 'zero' },
-  { name: 'frozen', default: 'zero' },
-]
-
-const config = {
-  balanceFieldsConfig,
-  balanceFields: balanceFieldsConfig
-    .flatMap((fieldConfig) => [fieldConfig.name, fieldConfig.legacyName])
-    .filter(Boolean), // wallets can reduce the number of exposed fields,
-  assetsToTrackForBalances: [],
-}
-
-export default config
+export { default } from './lib/default-config.js'

package/index.d.ts

@@ -1,35 +1,2 @@
-import type { BalanceFieldName, Balances as AssetBalances } from '@exodus/asset-types'
-import type { Atom } from '@exodus/atoms'
-import type NumberUnit from '@exodus/currency'
-
-declare const balances: (walletConfig?: Record<string, unknown>) => {
-  id: string
-  definitions: unknown[]
-}
-
-export type Balances = Partial<AssetBalances>
-
-type WalletAccountName = string
-
-type AssetName = string
-
-export type BalancesByAssetSource = Record<WalletAccountName, Record<AssetName, Balances>>
-
-export type BalanceChange = {
-  from: NumberUnit
-  to: NumberUnit
-}
-
-export type BalanceChanges = Record<
-  WalletAccountName,
-  Record<AssetName, Partial<Record<BalanceFieldName, BalanceChange>>>
->
-
-export type BalancesAtomValue = {
-  balances: BalancesByAssetSource
-  changes?: BalanceChanges
-}
-
-export type BalancesAtom = Atom<BalancesAtomValue>
-
-export default balances
+export { default } from './lib/index.js'
+export type * from './lib/types.js'

package/index.js

@@ -1,65 +1 @@
-import balancesDefinition from './module/index.js'
-import {
-  balancesAtomDefinition,
-  hasBalanceAtomDefinition,
-  fundedWalletAccountsAtomDefinition,
-  assetsWithBalanceCountAtomDefinition,
-  assetNamesWithBalanceAtomDefinition,
-  assetsTotalWalletAmountsDefinition,
-} from './atoms/index.js'
-import balancesReportDefinition from './report/index.js'
-import {
-  balancesLifecyclePluginDefinition,
-  balancesAnalyticsPluginDefinition,
-} from './plugins/index.js'
-import typeforce from '@exodus/typeforce'
-import defaultConfig from './default-config.js'
-import mockableBalancesDefinition from './module/mockable-balances.js'
-import { safeString } from '@exodus/safe-string'
-
-const balances = (walletConfig) => {
-  const config = {
-    ...defaultConfig,
-    balanceFields: walletConfig?.balanceFields || defaultConfig.balanceFields,
-    assetsToTrackForBalances:
-      walletConfig?.assetsToTrackForBalances || defaultConfig.assetsToTrackForBalances,
-  }
-  typeforce(
-    {
-      balanceFields: typeforce.arrayOf('String'),
-      balanceFieldsConfig: typeforce.arrayOf('Object'),
-      assetsToTrackForBalances: typeforce.arrayOf('Object'),
-    },
-    config,
-    true
-  )
-
-  return {
-    id: safeString`balances`,
-    definitions: [
-      {
-        definition: walletConfig?.importReport ? mockableBalancesDefinition : balancesDefinition,
-        config,
-      },
-      { definition: balancesAtomDefinition },
-      { definition: assetNamesWithBalanceAtomDefinition },
-      { definition: assetsWithBalanceCountAtomDefinition },
-      {
-        definition: hasBalanceAtomDefinition,
-        storage: { namespace: 'balances' },
-        aliases: [{ implementationId: 'unsafeStorage', interfaceId: 'storage' }],
-      },
-      { definition: fundedWalletAccountsAtomDefinition },
-      { definition: balancesReportDefinition },
-      { definition: balancesLifecyclePluginDefinition },
-      { definition: assetsTotalWalletAmountsDefinition },
-      {
-        if: { registered: ['analytics'] },
-        definition: balancesAnalyticsPluginDefinition,
-        config: { assetsToTrackForBalances: config.assetsToTrackForBalances },
-      },
-    ],
-  }
-}
-
-export default balances
+export { default } from './lib/index.js'

package/lib/atoms/asset-names-with-balance.d.ts

@@ -0,0 +1,5 @@
+import type { BalancesAtom } from '../types.js';
+declare const createAssetNamesWithBalanceAtom: ({ balancesAtom }: {
+    balancesAtom: BalancesAtom;
+}) => import("@exodus/atoms").ReadonlyAtom<Set<string>>;
+export default createAssetNamesWithBalanceAtom;

package/lib/atoms/asset-names-with-balance.js

@@ -0,0 +1,31 @@
+import { compute } from '@exodus/atoms';
+const setsAreEqual = (setA, setB) => {
+    if (setA.size !== setB.size) {
+        return false;
+    }
+    for (const item of setA) {
+        if (!setB.has(item)) {
+            return false;
+        }
+    }
+    return true;
+};
+const createAssetNamesWithBalanceAtom = ({ balancesAtom }) => {
+    let previousValue = new Set();
+    const selector = ({ balances }) => {
+        const assetsWithBalances = new Set();
+        Object.values(balances).forEach((accountBalances) => {
+            Object.keys(accountBalances).forEach((assetName) => {
+                if (!accountBalances[assetName]?.balance.isZero) {
+                    assetsWithBalances.add(assetName);
+                }
+            });
+        });
+        if (!setsAreEqual(assetsWithBalances, previousValue)) {
+            previousValue = assetsWithBalances;
+        }
+        return previousValue;
+    };
+    return compute({ atom: balancesAtom, selector });
+};
+export default createAssetNamesWithBalanceAtom;

package/lib/atoms/asset-total-wallet-amounts.d.ts

@@ -0,0 +1,5 @@
+import type { AssetTotalWalletAmountsAtom, BalancesAtom } from '../types.js';
+declare const createAssetTotalWalletAmountsAtom: ({ balancesAtom, }: {
+    balancesAtom: BalancesAtom;
+}) => AssetTotalWalletAmountsAtom;
+export default createAssetTotalWalletAmountsAtom;

package/lib/atoms/asset-total-wallet-amounts.js

@@ -0,0 +1,39 @@
+import { compute, dedupe } from '@exodus/atoms';
+const numberUnitMapsAreEqual = (mapA, mapB) => {
+    if (mapA.size !== mapB.size) {
+        return false;
+    }
+    for (const [key, val] of mapA) {
+        const itemB = mapB.get(key);
+        if (!itemB || !itemB.equals(val)) {
+            return false;
+        }
+    }
+    return true;
+};
+const createAssetTotalWalletAmountsAtom = ({ balancesAtom, }) => {
+    let previousValue = new Map();
+    const selector = ({ balances }) => {
+        const assetsWithBalances = new Map();
+        Object.values(balances).forEach((accountBalances) => {
+            Object.keys(accountBalances).forEach((assetName) => {
+                const accountAssetBalance = accountBalances[assetName]?.balance;
+                if (accountAssetBalance) {
+                    if (assetsWithBalances.has(assetName)) {
+                        const currentAssetBalance = assetsWithBalances.get(assetName);
+                        assetsWithBalances.set(assetName, accountAssetBalance.add(currentAssetBalance));
+                    }
+                    else {
+                        assetsWithBalances.set(assetName, accountAssetBalance);
+                    }
+                }
+            });
+        });
+        if (!numberUnitMapsAreEqual(assetsWithBalances, previousValue)) {
+            previousValue = assetsWithBalances;
+        }
+        return previousValue;
+    };
+    return dedupe(compute({ atom: balancesAtom, selector }));
+};
+export default createAssetTotalWalletAmountsAtom;

package/lib/atoms/assets-with-balance-count.d.ts

@@ -0,0 +1,5 @@
+import type { ReadonlyAtom } from '@exodus/atoms';
+declare const createAssetsWithBalanceCountAtom: ({ assetNamesWithBalanceAtom, }: {
+    assetNamesWithBalanceAtom: ReadonlyAtom<Set<string>>;
+}) => ReadonlyAtom<number>;
+export default createAssetsWithBalanceCountAtom;

package/lib/atoms/assets-with-balance-count.js

@@ -0,0 +1,6 @@
+import { compute } from '@exodus/atoms';
+const createAssetsWithBalanceCountAtom = ({ assetNamesWithBalanceAtom, }) => {
+    const selector = (assetNamesWithBalance) => assetNamesWithBalance.size;
+    return compute({ atom: assetNamesWithBalanceAtom, selector });
+};
+export default createAssetsWithBalanceCountAtom;

package/lib/atoms/balances.d.ts

@@ -0,0 +1,3 @@
+import type { BalancesAtomValue } from '../types.js';
+declare const createBalancesAtom: () => import("@exodus/atoms").Atom<BalancesAtomValue>;
+export default createBalancesAtom;

package/lib/atoms/balances.js

@@ -0,0 +1,3 @@
+import { createInMemoryAtom } from '@exodus/atoms';
+const createBalancesAtom = () => createInMemoryAtom();
+export default createBalancesAtom;

package/lib/atoms/funded-wallet-accounts.d.ts

@@ -0,0 +1,8 @@
+import type { FundedWalletAccountsAtom, BalancesAtom } from '../types.js';
+import type { ReadonlyAtom } from '@exodus/atoms';
+import type { WalletAccount } from '@exodus/models';
+declare const createFundedWalletAccountsAtom: ({ balancesAtom, enabledWalletAccountsAtom, }: {
+    balancesAtom: BalancesAtom;
+    enabledWalletAccountsAtom: ReadonlyAtom<Record<string, WalletAccount>>;
+}) => FundedWalletAccountsAtom;
+export default createFundedWalletAccountsAtom;

package/lib/atoms/funded-wallet-accounts.js

@@ -0,0 +1,19 @@
+import { combine, compute, dedupe } from '@exodus/atoms';
+import { mapValues } from '@exodus/basic-utils';
+const computeFundedWalletAccounts = ({ walletAccounts, balances, }) => {
+    return mapValues(walletAccounts, (_, key) => {
+        const walletAccountBalaces = balances.balances[key] || {};
+        return Object.values(walletAccountBalaces).some(({ balance }) => !balance.isZero);
+    });
+};
+const createFundedWalletAccountsAtom = ({ balancesAtom, enabledWalletAccountsAtom, }) => {
+    const walletAccountsBalanceAtom = combine({
+        walletAccounts: enabledWalletAccountsAtom,
+        balances: balancesAtom,
+    });
+    return dedupe(compute({
+        atom: walletAccountsBalanceAtom,
+        selector: computeFundedWalletAccounts,
+    }));
+};
+export default createFundedWalletAccountsAtom;

package/lib/atoms/has-balance.d.ts

@@ -0,0 +1,7 @@
+import type { Storage } from '@exodus/storage-interface';
+import type { HasBalanceAtom, BalancesAtom } from '../types.js';
+declare const createHasBalanceAtom: ({ balancesAtom, storage, }: {
+    balancesAtom: BalancesAtom;
+    storage: Storage<boolean>;
+}) => HasBalanceAtom;
+export default createHasBalanceAtom;

package/lib/atoms/has-balance.js

@@ -0,0 +1,21 @@
+import { compute, createStorageAtomFactory } from '@exodus/atoms';
+import lodash from 'lodash';
+const { flatMap, map } = lodash;
+const createComputedAtom = ({ balancesAtom }) => {
+    const selector = ({ balances } = { balances: {} }) => {
+        const numberUnits = flatMap(balances, (value) => map(value, 'balance'));
+        return numberUnits.some((numberUnit) => (numberUnit ? !numberUnit.isZero : false));
+    };
+    return compute({ atom: balancesAtom, selector });
+};
+const createHasBalanceAtom = ({ balancesAtom, storage, }) => {
+    const storageAtom = createStorageAtomFactory({ storage })({
+        key: 'hasBalance',
+        defaultValue: false,
+        isSoleWriter: true,
+    });
+    const computedAtom = createComputedAtom({ balancesAtom });
+    computedAtom.observe((value) => storageAtom.set(value));
+    return storageAtom;
+};
+export default createHasBalanceAtom;

package/lib/atoms/index.d.ts

@@ -0,0 +1,54 @@
+export declare const balancesAtomDefinition: {
+    readonly id: "balancesAtom";
+    readonly type: "atom";
+    readonly factory: () => import("@exodus/atoms").Atom<import("../types.js").BalancesAtomValue>;
+    readonly dependencies: readonly [];
+    readonly public: true;
+};
+export declare const hasBalanceAtomDefinition: {
+    readonly id: "hasBalanceAtom";
+    readonly type: "atom";
+    readonly factory: ({ balancesAtom, storage, }: {
+        balancesAtom: import("../types.js").BalancesAtom;
+        storage: import("@exodus/storage-interface").Storage<boolean>;
+    }) => import("../types.js").HasBalanceAtom;
+    readonly dependencies: readonly ["balancesAtom", "storage"];
+    readonly public: true;
+};
+export declare const fundedWalletAccountsAtomDefinition: {
+    readonly id: "fundedWalletAccountsAtom";
+    readonly type: "atom";
+    readonly factory: ({ balancesAtom, enabledWalletAccountsAtom, }: {
+        balancesAtom: import("../types.js").BalancesAtom;
+        enabledWalletAccountsAtom: import("@exodus/atoms").ReadonlyAtom<Record<string, import("@exodus/models").WalletAccount>>;
+    }) => import("../types.js").FundedWalletAccountsAtom;
+    readonly dependencies: readonly ["balancesAtom", "enabledWalletAccountsAtom"];
+    readonly public: true;
+};
+export declare const assetNamesWithBalanceAtomDefinition: {
+    readonly id: "assetNamesWithBalanceAtom";
+    readonly type: "atom";
+    readonly factory: ({ balancesAtom }: {
+        balancesAtom: import("../types.js").BalancesAtom;
+    }) => import("@exodus/atoms").ReadonlyAtom<Set<string>>;
+    readonly dependencies: readonly ["balancesAtom"];
+    readonly public: true;
+};
+export declare const assetsWithBalanceCountAtomDefinition: {
+    readonly id: "assetsWithBalanceCountAtom";
+    readonly type: "atom";
+    readonly factory: ({ assetNamesWithBalanceAtom, }: {
+        assetNamesWithBalanceAtom: import("@exodus/atoms").ReadonlyAtom<Set<string>>;
+    }) => import("@exodus/atoms").ReadonlyAtom<number>;
+    readonly dependencies: readonly ["assetNamesWithBalanceAtom"];
+    readonly public: true;
+};
+export declare const assetsTotalWalletAmountsDefinition: {
+    readonly id: "assetsTotalWalletAmountsAtom";
+    readonly type: "atom";
+    readonly factory: ({ balancesAtom, }: {
+        balancesAtom: import("../types.js").BalancesAtom;
+    }) => import("../types.js").AssetTotalWalletAmountsAtom;
+    readonly dependencies: readonly ["balancesAtom"];
+    readonly public: true;
+};