@exodus/balances 13.16.0 → 13.17.0

package/lib/redux/selectors/index.d.ts

@@ -0,0 +1,339 @@
+declare const _default: readonly [{
+    readonly id: "byAsset";
+    readonly resultFunction: (walletAccounts: string[], getAssetBalances: (account: string) => Record<string, import("@exodus/currency").default>) => Record<string, import("@exodus/currency").default>;
+    readonly dependencies: readonly [{
+        readonly module: "walletAccounts";
+        readonly selector: "enabled";
+    }, {
+        readonly selector: "getAccountAssetsBalanceSelector";
+    }];
+}, {
+    readonly id: "createUnconfirmedBalance";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, createAssetSourceSelector: (source: import("../types.js").Source) => import("../types.js").Selector<import("@exodus/models").TxSet>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default, (res1: import("../types.js").Asset | undefined, res2: import("@exodus/models").TxSet) => import("@exodus/currency").default>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly module: "txLog";
+        readonly selector: "createAssetSourceSelector";
+    }];
+}, {
+    readonly id: "getBalanceForField";
+    readonly resultFunction: (getAsset: import("../types.js").GetAsset, getBalances: import("../types.js").GetBalances) => (({ assetName, walletAccount, field }: import("../types.js").FieldSource) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "getAsset";
+    }, {
+        readonly module: "balances";
+        readonly selector: "getBalances";
+    }];
+}, ...(({
+    readonly id: "getTotal";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getBalance";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getSpendable";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getSpendableBalance";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getUnconfirmedSent";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getUnconfirmedReceived";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getUnspendable";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getWalletReserve";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getNetworkReserve";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getStaking";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getStaked";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getStakeable";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getUnstaking";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getUnstaked";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getRewards";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+} | {
+    readonly id: "getFrozen";
+    readonly resultFunction: (getBalanceForField: import("../types.js").GetBalanceForField) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default | undefined) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+}) | ({
+    readonly id: "createTotal";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createBalance";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createSpendable";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createSpendableBalance";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createUnconfirmedSent";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createUnconfirmedReceived";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createUnspendable";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createWalletReserve";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createNetworkReserve";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createStaking";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createStaked";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createStakeable";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createUnstaking";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createUnstaked";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createRewards";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+} | {
+    readonly id: "createFrozen";
+    readonly selectorFactory: (createAssetSelector: import("../types.js").CreateAssetSelector, selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("../types.js").Asset | undefined, res2: import("../types.js").State) => import("@exodus/currency").default | undefined>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly selector: "$state";
+    }];
+}))[], {
+    readonly id: "createBalances";
+    readonly selectorFactory: (selfSelector: import("../types.js").Selector<import("../types.js").State>) => (({ assetName, walletAccount }: import("../types.js").Source) => import("reselect").OutputSelector<unknown, import("../../module/types.js").FieldBalances, (res: import("../types.js").State) => import("../../module/types.js").FieldBalances>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly selector: "$state";
+    }];
+}, {
+    readonly id: "getBalances";
+    readonly selectorFactory: (selfSelector: import("../types.js").Selector<import("../types.js").State>) => import("reselect").OutputSelector<unknown, (({ assetName, walletAccount }: import("../types.js").Source) => import("../../module/types.js").FieldBalances | undefined) & import("lodash").MemoizedFunction, (res: import("../types.js").State) => (({ assetName, walletAccount }: import("../types.js").Source) => import("../../module/types.js").FieldBalances | undefined) & import("lodash").MemoizedFunction>;
+    readonly dependencies: readonly [{
+        readonly selector: "$state";
+    }];
+}, {
+    readonly id: "getUnconfirmedBalance";
+    readonly selectorFactory: (getAssetSelector: import("../types.js").Selector<import("../types.js").GetAsset>, createAssetSourceSelector: import("../types.js").Selector<import("../types.js").GetTxs>) => import("reselect").OutputSelector<unknown, (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default) & import("lodash").MemoizedFunction, (res1: import("../types.js").GetAsset, res2: import("../types.js").GetTxs) => (({ assetName, walletAccount }: import("../types.js").Source) => import("@exodus/currency").default) & import("lodash").MemoizedFunction>;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "getAsset";
+    }, {
+        readonly module: "txLog";
+        readonly selector: "createAssetSourceSelectorOld";
+    }];
+}, {
+    readonly id: "createFuelThreshold";
+    readonly selectorFactory: (getFeeDataSelector: import("../types.js").Selector<(name: string) => {
+        fuelThreshold?: import("@exodus/currency").default;
+    } | undefined>, createAssetSelector: import("../types.js").CreateAssetSelector) => ((assetName: string) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | null, (res1: (name: string) => {
+        fuelThreshold?: import("@exodus/currency").default;
+    } | undefined, res2: import("../types.js").Asset | undefined) => import("@exodus/currency").default | null>) & import("lodash").MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "feeData";
+        readonly selector: "getData";
+    }, {
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }];
+}, {
+    readonly id: "createRequiresFuelThreshold";
+    readonly selectorFactory: (isTxLogLoadedSelector: import("../types.js").Selector<(account: string) => boolean>, getAssetBalanceSelector: import("../types.js").Selector<import("../types.js").GetBalance>, assetsSelector: import("../types.js").Selector<Record<string, import("../types.js").Asset>>) => (source: {
+        assetName: string;
+        walletAccount: string;
+    }) => import("reselect").OutputSelector<unknown, boolean, (res1: (account: string) => boolean, res2: import("../types.js").GetBalance, res3: Record<string, import("../types.js").Asset>) => boolean>;
+    readonly dependencies: readonly [{
+        readonly module: "txLog";
+        readonly selector: "createIsWalletAccountLoadedSelectorOld";
+    }, {
+        readonly module: "balances";
+        readonly selector: "getAssetSourceBalanceSelector";
+    }, {
+        readonly module: "availableAssets";
+        readonly selector: "all";
+    }];
+}];
+export default _default;

package/lib/redux/selectors/index.js

@@ -0,0 +1,22 @@
+import byAssetSelectorDefinition from './by-asset.js';
+import createUnconfirmedBalanceSelectorDefinition from './create-unconfirmed-balance.js';
+import getBalanceForFieldSelectorDefinition from './get-balance-for-field.js';
+import getBalanceSelectors from './get-balance-selectors.js';
+import createBalancesSelectorDefinition from './create-balances.js';
+import getBalancesSelectorDefinition from './get-balances.js';
+import createBalancesSelectors from './create-balance-selectors.js';
+import getUnconfirmedBalanceSelectorDefinition from './get-unconfirmed-balance.js';
+import createFuelThresholdSelectorDefinition from './create-fuel-threshold.js';
+import createRequiresFuelThresholdSelectorDefinition from './create-requires-fuel-threshold.js';
+export default [
+    byAssetSelectorDefinition,
+    createUnconfirmedBalanceSelectorDefinition,
+    getBalanceForFieldSelectorDefinition,
+    ...getBalanceSelectors,
+    ...createBalancesSelectors,
+    createBalancesSelectorDefinition,
+    getBalancesSelectorDefinition,
+    getUnconfirmedBalanceSelectorDefinition,
+    createFuelThresholdSelectorDefinition,
+    createRequiresFuelThresholdSelectorDefinition,
+];

package/lib/redux/types.d.ts

@@ -0,0 +1,45 @@
+import type { Selectors } from '@exodus/redux-dependency-injection';
+import type { AccountState, SliceState } from '@exodus/multi-account-redux';
+import type { TxSet } from '@exodus/models';
+import type { BalanceAsset, FieldBalances } from '../module/types.js';
+import type selectorDefinitions from './selectors/index.js';
+import type { helperSelectorDefinitions } from './multi-account-helper.js';
+import type NumberUnit from '@exodus/currency';
+export type Source = {
+    assetName: string;
+    walletAccount: string;
+};
+export type FieldSource = Source & {
+    field: string;
+};
+export type Selector<T> = (state: unknown) => T;
+export type Asset = BalanceAsset & {
+    feeAsset: {
+        currency: BalanceAsset['currency'];
+    };
+};
+export type GetAsset = (name: string) => Asset | undefined;
+export type CreateAssetSelector = (name: string) => Selector<Asset | undefined>;
+export type GetBalances = (source: Source) => FieldBalances | undefined;
+export type GetBalance = (source: Source) => NumberUnit | undefined;
+export type GetBalanceForField = (source: FieldSource) => NumberUnit | undefined;
+export type GetTxs = (source: Source) => TxSet;
+export type AccountBalancesState = AccountState<FieldBalances>;
+export type AccountSlices = SliceState<FieldBalances>;
+export type State = {
+    hasBalance: boolean;
+    [key: string]: AccountBalancesState | boolean;
+};
+export type InitialState = {
+    hasBalance: boolean;
+    exodus_0: AccountBalancesState;
+};
+export type BalancesSelectors<RootState = {
+    balances: InitialState;
+}> = Selectors<{
+    id: 'balances';
+    type: 'redux-module';
+    initialState: InitialState;
+    eventReducers: Record<string, never>;
+    selectorDefinitions: readonly ((typeof helperSelectorDefinitions)[number] | (typeof selectorDefinitions)[number])[];
+}, RootState>['balances'];

package/lib/redux/types.js

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

package/lib/report/index.d.ts

@@ -0,0 +1,34 @@
+import type { BalancesAtom } from '../types.js';
+import type { ReadonlyAtom } from '@exodus/atoms';
+import type { WalletAccount } from '@exodus/models';
+import { SafeError } from '@exodus/errors';
+import { z } from '@exodus/zod';
+declare const balancesReportDefinition: {
+    readonly id: "balancesReport";
+    readonly type: "report";
+    readonly factory: ({ enabledWalletAccountsAtom, balancesAtom, }: {
+        enabledWalletAccountsAtom: ReadonlyAtom<Record<string, WalletAccount>>;
+        balancesAtom: BalancesAtom;
+    }) => {
+        namespace: string;
+        export: ({ walletExists, isLocked }?: ExportParams) => Promise<Record<string, {
+            balances: Record<string, string>;
+        }> | {
+            error: SafeError;
+        } | null>;
+        getSchema: import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<() => z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            balances: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            balances: Record<string, string>;
+        }, {
+            balances: Record<string, string>;
+        }>, z.ZodType<SafeError, z.ZodTypeDef, SafeError>]>>>>;
+    };
+    readonly dependencies: readonly ["enabledWalletAccountsAtom", "balancesAtom"];
+    readonly public: true;
+};
+type ExportParams = {
+    walletExists?: boolean;
+    isLocked?: boolean;
+};
+export default balancesReportDefinition;

package/lib/report/index.js

@@ -0,0 +1,51 @@
+import { SafeError } from '@exodus/errors';
+import { memoize } from '@exodus/basic-utils';
+import { z } from '@exodus/zod';
+const createBalancesReport = ({ enabledWalletAccountsAtom, balancesAtom, }) => ({
+    namespace: 'balances',
+    export: async ({ walletExists, isLocked } = Object.create(null)) => {
+        if (!walletExists || isLocked)
+            return null;
+        let walletAccounts;
+        let balances;
+        try {
+            ;
+            [walletAccounts, { balances }] = await Promise.all([
+                enabledWalletAccountsAtom.get(),
+                balancesAtom.get(),
+            ]);
+        }
+        catch (error) {
+            return { error: SafeError.from(error) };
+        }
+        return Object.keys(walletAccounts)
+            .filter((key) => balances[key] && walletAccounts[key].source !== 'ftx')
+            .reduce((data, key) => {
+            const reportBalances = Object.fromEntries(Object.entries(balances[key])
+                .filter(([_, value]) => !value.balance.isZero)
+                .map(([key, value]) => {
+                return [key, value.balance.toDefaultString({ unit: true })];
+            }));
+            data[key] = { balances: reportBalances };
+            return data;
+        }, {});
+    },
+    getSchema: memoize(() => z
+        .record(z.union([
+        z
+            .object({
+            balances: z.record(z.string(), z.string()),
+        })
+            .strict(),
+        z.instanceof(SafeError),
+    ]))
+        .nullable()),
+});
+const balancesReportDefinition = {
+    id: 'balancesReport',
+    type: 'report',
+    factory: createBalancesReport,
+    dependencies: ['enabledWalletAccountsAtom', 'balancesAtom'],
+    public: true,
+};
+export default balancesReportDefinition;

package/lib/types.d.ts

@@ -0,0 +1,24 @@
+import type { BalanceFieldName, Balances as AssetBalances } from '@exodus/asset-types';
+import type { Atom, ReadonlyAtom } from '@exodus/atoms';
+import type NumberUnit from '@exodus/currency';
+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 type HasBalanceAtom = Omit<Atom<boolean>, 'set'> & {
+    set(value: boolean | undefined): Promise<void>;
+    set(setter: (previous: boolean) => boolean | Promise<boolean>): Promise<void>;
+};
+export type AssetTotalWalletAmountsAtom = ReadonlyAtom<Map<string, NumberUnit>>;
+export type FundedWalletAccountsAtom = ReadonlyAtom<Record<string, boolean>>;
+export {};

package/lib/types.js

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

package/module/balances-utils.d.ts

@@ -0,0 +1 @@
+export { processAssetBalances, validateBalances } from '../lib/module/balances-utils.js'

package/module/balances-utils.js

@@ -1,86 +1 @@
-import { mapValues } from '@exodus/basic-utils'
-
-function resolveFieldBalance({ balances, fieldConfig, zero, processedBalances }) {
-  if (balances[fieldConfig.name]) {
-    return balances[fieldConfig.name]
-  }
-
-  if (fieldConfig.legacyName && balances[fieldConfig.legacyName]) {
-    return balances[fieldConfig.legacyName]
-  }
-
-  if (fieldConfig.default && fieldConfig.default === 'zero') {
-    return zero
-  }
-
-  if (fieldConfig.default && processedBalances[fieldConfig.default] !== null) {
-    if (processedBalances[fieldConfig.default] === undefined) {
-      throw new Error(
-        `Field config "${fieldConfig.default}" must be defined before "${fieldConfig.name}"`
-      )
-    }
-
-    return processedBalances[fieldConfig.default]
-  }
-
-  return null
-}
-
-export const processAssetBalances = ({ balances, zero, balanceFieldsConfig }) => {
-  return balanceFieldsConfig.reduce((processedBalances, fieldConfig) => {
-    const balance = resolveFieldBalance({
-      balances,
-      fieldConfig,
-      zero,
-      processedBalances,
-    })
-    if (balance !== null) {
-      processedBalances[fieldConfig.name] = balance
-      if (fieldConfig.legacyName) {
-        processedBalances[fieldConfig.legacyName] = balance
-      }
-    }
-
-    return processedBalances
-  }, {})
-}
-
-export const validateBalances = ({ balances, asset, logger }) => {
-  const assetName = asset.name
-  const zero = asset.currency.ZERO
-
-  const log = (error) => {
-    logger.warn(error.fn, error.error, error.args)
-  }
-
-  return mapValues(balances, (balance, field) => {
-    if (!balance) {
-      return balance
-    }
-
-    if (!balance.unitType.equals(asset.currency)) {
-      log({
-        fn: 'getAssetBalances',
-        error: `asset.api.getBalances ${assetName} returns different ${field} currency`,
-        args: {
-          balanceUnit: balance.unitType.defaultUnit.unitName,
-          assetUnit: asset.currency.defaultUnit.unitName,
-        },
-      })
-      return zero
-    }
-
-    if (balance.isNegative) {
-      log({
-        fn: 'getAssetBalances',
-        error: `asset.api.getBalances ${assetName} returns negative ${field}`,
-        args: {
-          amount: balance.toDefaultString({ unit: true }),
-        },
-      })
-      return zero
-    }
-
-    return balance
-  })
-}
+export { processAssetBalances, validateBalances } from '../lib/module/balances-utils.js'

package/module/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from '../lib/module/index.js'
+export { cloneBalances } from '../lib/module/index.js'