@exodus/balances 13.16.0 → 13.17.0

package/lib/redux/index.d.ts

@@ -0,0 +1,588 @@
+import type { State, AccountBalancesState } from './types.js';
+import type { BalancesAtomValue } from '../types.js';
+import lodash from 'lodash';
+declare const balancesReduxDefinition: {
+    readonly id: "balances";
+    readonly type: "redux-module";
+    readonly initialState: import("./types.js").InitialState;
+    readonly eventReducers: {
+        readonly balances: (state: State, payload: BalancesAtomValue) => {
+            [x: string]: boolean | AccountBalancesState | {
+                loaded: boolean;
+                error: null;
+                data: Record<string, Record<import("@exodus/asset-types").BalanceFieldName, import("@exodus/currency").default>>;
+            } | {
+                data: import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> & Record<string, Record<import("@exodus/asset-types").BalanceFieldName, import("@exodus/currency").default>>;
+                error: unknown;
+                loaded: boolean;
+                loading?: boolean;
+            };
+            hasBalance: boolean;
+        };
+        readonly hasBalance: (state: State, payload: boolean) => {
+            hasBalance: boolean;
+        };
+    };
+    readonly selectorDefinitions: readonly [{
+        readonly id: "createAssetSourceSelector";
+        readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>, getAssetInstanceSelector: (state: TState) => (assetName: string) => import("../module/types.js").BalanceAsset) => (source: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => (state: TState) => import("../module/types.js").FieldBalances | null | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }];
+    }, {
+        readonly id: "createAssetSourceSelectorOld";
+        readonly resultFunction: (myState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>, activeWalletAccount: string, getAssetInstance: (assetName: string) => import("../module/types.js").BalanceAsset) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ walletAccount, assetName }: Omit<{
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }, "walletAccount"> & {
+            walletAccount?: string;
+        }) => import("../module/types.js").FieldBalances | null | undefined>;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }, {
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }];
+    }, {
+        readonly id: "createBaseAssetSourceSelector";
+        readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>, getAssetInstanceSelector: (state: TState) => (assetName: string) => import("../module/types.js").BalanceAsset) => (source: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => (state: TState) => import("../module/types.js").FieldBalances | null | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }];
+    }, {
+        readonly id: "createBaseAssetSourceSelectorOld";
+        readonly resultFunction: (myState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>, activeWalletAccount: string, getAssetInstance: (assetName: string) => import("../module/types.js").BalanceAsset) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ walletAccount, assetName }: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => import("../module/types.js").FieldBalances | null | undefined>;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }, {
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }];
+    }, {
+        readonly id: "createActiveAssetSourceSelectorOld";
+        readonly resultFunction: (activeWalletAccount: string, getAssetInstance: (assetName: string) => import("../module/types.js").BalanceAsset, myState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<(assetName: string) => import("../module/types.js").FieldBalances | null | undefined>;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createActiveAssetSourceSelector";
+        readonly selectorFactory: <TState>(activeWalletAccountSelector: (state: TState) => string, getAssetInstanceSelector: (state: TState) => (assetName: string) => import("../module/types.js").BalanceAsset, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (assetName: string) => (state: TState) => import("../module/types.js").FieldBalances | null | undefined;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createActiveBaseAssetSourceSelector";
+        readonly selectorFactory: <TState>(activeWalletAccountSelector: (state: TState) => string, getAssetInstanceSelector: (state: TState) => (assetName: string) => import("../module/types.js").BalanceAsset, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (assetName: string) => (state: TState) => import("../module/types.js").FieldBalances | null | undefined;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly module: "assets";
+            readonly selector: "getAsset";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createIsWalletAccountLoadingSelectorOld";
+        readonly selectorFactory: <TState>(activeWalletAccountSelector: (state: TState) => string, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (state: TState) => (walletAccount?: string) => boolean;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createIsWalletAccountLoadingSelector";
+        readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (walletAccount: string) => (state: TState) => boolean;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createIsWalletAccountLoadedSelectorOld";
+        readonly resultFunction: (activeWalletAccount: string, subState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (walletAccount?: string) => boolean;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createIsWalletAccountLoadedSelector";
+        readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (walletAccount: string) => (state: TState) => boolean;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "isActiveWalletAccountLoading";
+        readonly resultFunction: (activeWalletAccount: string, subState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => boolean;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "isActiveWalletAccountLoaded";
+        readonly resultFunction: (activeWalletAccount: string, subState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => boolean;
+        readonly dependencies: readonly [{
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }, {
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "createAccountAssetsSelector";
+        readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (walletAccount: string) => (state: TState) => import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "activeAccountAssetsSelector";
+        readonly resultFunction: (myState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>, activeAccount: string) => import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }, {
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }];
+    }, {
+        readonly id: "getAccountAssetsSelector";
+        readonly resultFunction: (myState: import("@exodus/multi-account-redux").SliceState<import("../module/types.js").FieldBalances>) => (walletAccount: string) => import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, ...({
+        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>) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & 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<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default | undefined, (res1: import("./types.js").Asset | undefined, res2: State) => import("@exodus/currency").default | undefined>) & lodash.MemoizedFunction;
+        readonly dependencies: readonly [{
+            readonly module: "assets";
+            readonly selector: "createAssetSelector";
+        }, {
+            readonly selector: "$state";
+        }];
+    }) | {
+        readonly id: "createAccountAssetsBalanceSelector";
+        readonly selectorFactory: <TState>(createAccountAssetsSelector: (walletAccount: string) => (state: TState) => import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> | undefined) => (walletAccount: string) => (state: TState) => Record<string, import("@exodus/currency").default | undefined>;
+        readonly dependencies: readonly [{
+            readonly selector: "createAccountAssetsSelector";
+        }];
+    } | {
+        readonly id: "activeAccountAssetsBalanceSelector";
+        readonly resultFunction: (accountAssets: import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> | undefined) => Record<string, import("@exodus/currency").default | undefined>;
+        readonly dependencies: readonly [{
+            readonly selector: "activeAccountAssetsSelector";
+        }];
+    } | {
+        readonly id: "getAccountAssetsBalanceSelector";
+        readonly resultFunction: (getAccountAssets: (walletAccount: string) => import("@exodus/multi-account-redux").PerAssetData<import("../module/types.js").FieldBalances> | undefined) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<(walletAccount: string) => Record<string, import("@exodus/currency").default | undefined>>;
+        readonly dependencies: readonly [{
+            readonly selector: "getAccountAssetsSelector";
+        }];
+    } | {
+        readonly id: "createAssetSourceBalanceSelector";
+        readonly selectorFactory: <TState>(createAssetSourceSelector: (key: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => (state: TState) => import("../module/types.js").FieldBalances | null | undefined) => (source: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => (state: TState) => import("@exodus/currency").default | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "createAssetSourceSelector";
+        }];
+    } | {
+        readonly id: "createActiveAssetSourceBalanceSelector";
+        readonly selectorFactory: <TState>(createActiveAssetSourceSelector: (assetName: string) => (state: TState) => import("../module/types.js").FieldBalances | null | undefined) => (assetName: string) => (state: TState) => import("@exodus/currency").default | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "createActiveAssetSourceSelector";
+        }];
+    } | {
+        readonly id: "getAssetSourceBalanceSelector";
+        readonly resultFunction: (getAssetSource: (key: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => import("../module/types.js").FieldBalances | null | undefined, activeWalletAccount: string) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ assetName, walletAccount }: Omit<{
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }, "walletAccount"> & {
+            walletAccount?: string;
+        }) => import("@exodus/currency").default | undefined>;
+        readonly dependencies: readonly [{
+            readonly selector: "createAssetSourceSelectorOld";
+        }, {
+            readonly module: "walletAccounts";
+            readonly selector: "active";
+        }];
+    })[], {
+        readonly id: "createBalances";
+        readonly selectorFactory: (selfSelector: import("./types.js").Selector<State>) => (({ assetName, walletAccount }: import("./types.js").Source) => import("reselect").OutputSelector<unknown, import("../module/types.js").FieldBalances, (res: State) => import("../module/types.js").FieldBalances>) & lodash.MemoizedFunction;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "getBalances";
+        readonly selectorFactory: (selfSelector: import("./types.js").Selector<State>) => import("reselect").OutputSelector<unknown, (({ assetName, walletAccount }: import("./types.js").Source) => import("../module/types.js").FieldBalances | undefined) & lodash.MemoizedFunction, (res: State) => (({ assetName, walletAccount }: import("./types.js").Source) => import("../module/types.js").FieldBalances | undefined) & 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) & lodash.MemoizedFunction, (res1: import("./types.js").GetAsset, res2: import("./types.js").GetTxs) => (({ assetName, walletAccount }: import("./types.js").Source) => import("@exodus/currency").default) & 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>) & 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 type { BalancesSelectors, State as BalancesState } from './types.js';
+export default balancesReduxDefinition;

package/lib/redux/index.js

@@ -0,0 +1,53 @@
+import id from './id.js';
+import initialState from './initial-state.js';
+import selectorDefinitions from './selectors/index.js';
+import { mapValues } from '@exodus/basic-utils';
+import lodash from 'lodash';
+import { helperSelectorDefinitions } from './multi-account-helper.js';
+import { setAccounts } from '@exodus/multi-account-redux';
+const { merge } = lodash;
+const mergeChanges = (balancesState, changesByWalletAccount) => {
+    return {
+        ...balancesState,
+        ...mapValues(changesByWalletAccount, (changesByAsset, walletAccount) => {
+            const accountState = balancesState?.[walletAccount];
+            if (!accountState) {
+                return {
+                    loaded: true,
+                    error: null,
+                    data: mapValues(changesByAsset, (changesByField) => mapValues(changesByField, (balanceField) => balanceField.to)),
+                };
+            }
+            const updatedData = mapValues(changesByAsset, (changesByField) => mapValues(changesByField, (balanceField) => balanceField.to));
+            return {
+                ...accountState,
+                data: merge({}, accountState.data, updatedData),
+            };
+        }),
+    };
+};
+const balancesReduxDefinition = {
+    id,
+    type: 'redux-module',
+    initialState,
+    eventReducers: {
+        balances: (state, payload) => {
+            const { hasBalance, ...walletAccountBalances } = state;
+            const accountSlices = walletAccountBalances;
+            const balancesLoaded = Object.values(accountSlices).every((value) => value.loaded);
+            if (balancesLoaded && payload.changes && Object.keys(payload.changes).length > 0) {
+                return mergeChanges(state, payload.changes);
+            }
+            return {
+                hasBalance,
+                ...setAccounts(state, payload.balances),
+            };
+        },
+        hasBalance: (state, payload) => ({
+            ...state,
+            hasBalance: payload,
+        }),
+    },
+    selectorDefinitions: [...helperSelectorDefinitions, ...selectorDefinitions],
+};
+export default balancesReduxDefinition;