@exodus/balances 13.16.1 → 13.17.0

package/lib/redux/initial-state.d.ts

@@ -0,0 +1,3 @@
+import type { InitialState } from './types.js';
+declare const initialState: InitialState;
+export default initialState;

package/lib/redux/initial-state.js

@@ -0,0 +1,6 @@
+import helper from './multi-account-helper.js';
+const initialState = {
+    hasBalance: false,
+    ...helper.createInitialState(),
+};
+export default initialState;

package/lib/redux/multi-account-helper.d.ts

@@ -0,0 +1,463 @@
+import type { BalanceAsset, FieldBalances } from '../module/types.js';
+declare const helper: {
+    createInitialState: () => import("@exodus/multi-account-redux").SliceState<FieldBalances>;
+    getAccount: (state: import("@exodus/multi-account-redux").SliceState<FieldBalances>, walletAccount: string) => import("@exodus/multi-account-redux").AccountState<FieldBalances> | undefined;
+    updateAccount: <TAssetData_1 = unknown>(state: import("@exodus/multi-account-redux").SliceState<TAssetData_1>, walletAccount: string, update: Partial<import("@exodus/multi-account-redux").AccountState<TAssetData_1>>) => import("@exodus/multi-account-redux").SliceState<TAssetData_1>;
+    mergeAccountsData: <TAssetData_1 = unknown>(state: import("@exodus/multi-account-redux").SliceState<TAssetData_1>, payload: Record<string, import("@exodus/multi-account-redux").PerAssetData<TAssetData_1>>) => import("@exodus/multi-account-redux").SliceState<TAssetData_1>;
+    setAccounts: <TAssetData_1 = unknown>(state: import("@exodus/multi-account-redux").SliceState<TAssetData_1>, valuesByAccount: Record<string, import("@exodus/multi-account-redux").PerAssetData<TAssetData_1>>) => import("@exodus/multi-account-redux").SliceState<TAssetData_1>;
+    resetAccount: (state: import("@exodus/multi-account-redux").SliceState<FieldBalances>, walletAccount: string) => import("@exodus/multi-account-redux").SliceState<FieldBalances>;
+    setLoaded: <TAssetData_1 = unknown>(state: import("@exodus/multi-account-redux").SliceState<TAssetData_1>, walletAccount: string, data?: import("@exodus/multi-account-redux").PerAssetData<TAssetData_1>) => import("@exodus/multi-account-redux").SliceState<TAssetData_1>;
+    setLoading: <TAssetData_1 = unknown>(state: import("@exodus/multi-account-redux").SliceState<TAssetData_1>, walletAccount: string) => import("@exodus/multi-account-redux").SliceState<TAssetData_1>;
+    setLoadingError: (state: import("@exodus/multi-account-redux").SliceState<FieldBalances>, walletAccount: string, error: unknown) => import("@exodus/multi-account-redux").SliceState<FieldBalances>;
+    getAssets: (state: import("@exodus/multi-account-redux").SliceState<FieldBalances>, walletAccount: string) => import("@exodus/multi-account-redux").PerAssetData<FieldBalances> | undefined;
+    getAsset: (state: import("@exodus/multi-account-redux").SliceState<FieldBalances>, walletAccount: string, asset: import("@exodus/multi-account-redux").AssetInstance | undefined) => FieldBalances | null | undefined;
+    setAsset: <TAssetData_1 = unknown>(state: import("@exodus/multi-account-redux").SliceState<TAssetData_1>, walletAccount: string, assetName: string, value: TAssetData_1) => import("@exodus/multi-account-redux").SliceState<TAssetData_1>;
+    resetAsset: (state: import("@exodus/multi-account-redux").SliceState<FieldBalances>, walletAccount: string, asset: BalanceAsset) => import("@exodus/multi-account-redux").SliceState<FieldBalances>;
+    selectorDefinitions: readonly [{
+        readonly id: "createAssetSourceSelector";
+        readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<FieldBalances>, getAssetInstanceSelector: (state: TState) => (assetName: string) => BalanceAsset) => (source: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => (state: TState) => 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<FieldBalances>, activeWalletAccount: string, getAssetInstance: (assetName: string) => BalanceAsset) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ walletAccount, assetName }: Omit<{
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }, "walletAccount"> & {
+            walletAccount?: string;
+        }) => 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<FieldBalances>, getAssetInstanceSelector: (state: TState) => (assetName: string) => BalanceAsset) => (source: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => (state: TState) => 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<FieldBalances>, activeWalletAccount: string, getAssetInstance: (assetName: string) => BalanceAsset) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ walletAccount, assetName }: {
+            walletAccount: string;
+            assetName: string;
+            network?: string;
+        }) => 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) => BalanceAsset, myState: import("@exodus/multi-account-redux").SliceState<FieldBalances>) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<(assetName: string) => 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) => BalanceAsset, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<FieldBalances>) => (assetName: string) => (state: TState) => 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) => BalanceAsset, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<FieldBalances>) => (assetName: string) => (state: TState) => 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<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<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<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<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<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<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<FieldBalances>) => (walletAccount: string) => (state: TState) => import("@exodus/multi-account-redux").PerAssetData<FieldBalances> | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, {
+        readonly id: "activeAccountAssetsSelector";
+        readonly resultFunction: (myState: import("@exodus/multi-account-redux").SliceState<FieldBalances>, activeAccount: string) => import("@exodus/multi-account-redux").PerAssetData<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<FieldBalances>) => (walletAccount: string) => import("@exodus/multi-account-redux").PerAssetData<FieldBalances> | undefined;
+        readonly dependencies: readonly [{
+            readonly selector: "$state";
+        }];
+    }, ...({
+        readonly id: "createAccountAssetsBalanceSelector";
+        readonly selectorFactory: <TState>(createAccountAssetsSelector: (walletAccount: string) => (state: TState) => import("@exodus/multi-account-redux").PerAssetData<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<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<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) => 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) => 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;
+        }) => 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";
+        }];
+    })[]];
+};
+export declare const helperSelectorDefinitions: readonly [{
+    readonly id: "createAssetSourceSelector";
+    readonly selectorFactory: <TState>(myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<FieldBalances>, getAssetInstanceSelector: (state: TState) => (assetName: string) => BalanceAsset) => (source: {
+        walletAccount: string;
+        assetName: string;
+        network?: string;
+    }) => (state: TState) => 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<FieldBalances>, activeWalletAccount: string, getAssetInstance: (assetName: string) => BalanceAsset) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ walletAccount, assetName }: Omit<{
+        walletAccount: string;
+        assetName: string;
+        network?: string;
+    }, "walletAccount"> & {
+        walletAccount?: string;
+    }) => 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<FieldBalances>, getAssetInstanceSelector: (state: TState) => (assetName: string) => BalanceAsset) => (source: {
+        walletAccount: string;
+        assetName: string;
+        network?: string;
+    }) => (state: TState) => 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<FieldBalances>, activeWalletAccount: string, getAssetInstance: (assetName: string) => BalanceAsset) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<({ walletAccount, assetName }: {
+        walletAccount: string;
+        assetName: string;
+        network?: string;
+    }) => 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) => BalanceAsset, myState: import("@exodus/multi-account-redux").SliceState<FieldBalances>) => import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<(assetName: string) => 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) => BalanceAsset, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<FieldBalances>) => (assetName: string) => (state: TState) => 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) => BalanceAsset, myStateSelector: (state: TState) => import("@exodus/multi-account-redux").SliceState<FieldBalances>) => (assetName: string) => (state: TState) => 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<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<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<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<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<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<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<FieldBalances>) => (walletAccount: string) => (state: TState) => import("@exodus/multi-account-redux").PerAssetData<FieldBalances> | undefined;
+    readonly dependencies: readonly [{
+        readonly selector: "$state";
+    }];
+}, {
+    readonly id: "activeAccountAssetsSelector";
+    readonly resultFunction: (myState: import("@exodus/multi-account-redux").SliceState<FieldBalances>, activeAccount: string) => import("@exodus/multi-account-redux").PerAssetData<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<FieldBalances>) => (walletAccount: string) => import("@exodus/multi-account-redux").PerAssetData<FieldBalances> | undefined;
+    readonly dependencies: readonly [{
+        readonly selector: "$state";
+    }];
+}, ...({
+    readonly id: "createAccountAssetsBalanceSelector";
+    readonly selectorFactory: <TState>(createAccountAssetsSelector: (walletAccount: string) => (state: TState) => import("@exodus/multi-account-redux").PerAssetData<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<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<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) => 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) => 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;
+    }) => 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";
+    }];
+})[]];
+export default helper;

package/lib/redux/multi-account-helper.js

@@ -0,0 +1,23 @@
+import { memoize } from '@exodus/basic-utils';
+import { createReduxModuleHelper } from '@exodus/multi-account-redux';
+import id from './id.js';
+const createInitialPerAssetData = memoize(({ asset }) => ({
+    balance: asset.currency.ZERO,
+    total: asset.currency.ZERO,
+}), ({ asset }) => asset.name);
+const helper = createReduxModuleHelper({
+    slice: id,
+    createInitialPerAssetData,
+    assetSourceDataSelectors: [
+        {
+            name: 'balance',
+            selector: (assetData) => {
+                if (!assetData)
+                    throw new Error('balances: no data for asset');
+                return assetData.total;
+            },
+        },
+    ],
+});
+export const helperSelectorDefinitions = helper.selectorDefinitions;
+export default helper;

package/lib/redux/selectors/by-asset.d.ts

@@ -0,0 +1,12 @@
+import type NumberUnit from '@exodus/currency';
+declare const byAssetSelector: {
+    readonly id: "byAsset";
+    readonly resultFunction: (walletAccounts: string[], getAssetBalances: (account: string) => Record<string, NumberUnit>) => Record<string, NumberUnit>;
+    readonly dependencies: readonly [{
+        readonly module: "walletAccounts";
+        readonly selector: "enabled";
+    }, {
+        readonly selector: "getAccountAssetsBalanceSelector";
+    }];
+};
+export default byAssetSelector;

package/lib/redux/selectors/by-asset.js

@@ -0,0 +1,19 @@
+const resultFunction = (walletAccounts, getAssetBalances) => walletAccounts.reduce((all, walletAccount) => {
+    for (const [assetName, balance] of Object.entries(getAssetBalances(walletAccount))) {
+        if (!all[assetName]) {
+            all[assetName] = balance;
+            continue;
+        }
+        all[assetName] = all[assetName].add(balance);
+    }
+    return all;
+}, {});
+const byAssetSelector = {
+    id: 'byAsset',
+    resultFunction,
+    dependencies: [
+        { module: 'walletAccounts', selector: 'enabled' },
+        { selector: 'getAccountAssetsBalanceSelector' },
+    ],
+};
+export default byAssetSelector;

package/lib/redux/selectors/create-balance-selectors.d.ts

@@ -0,0 +1,70 @@
+import type { Source, Selector, CreateAssetSelector, State } from '../types.js';
+import lodash from 'lodash';
+declare const createBalanceSelectorFactory: <const Id extends string>({ field, id, }: {
+    field: string;
+    id: Id;
+}) => {
+    readonly id: Id;
+    readonly selectorFactory: (createAssetSelector: CreateAssetSelector, selfSelector: Selector<State>) => (({ assetName, walletAccount }: 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";
+    }];
+};
+declare const fieldDefinitions: readonly [{
+    readonly id: "createTotal";
+    readonly field: "total";
+}, {
+    readonly id: "createBalance";
+    readonly field: "balance";
+}, {
+    readonly id: "createSpendable";
+    readonly field: "spendable";
+}, {
+    readonly id: "createSpendableBalance";
+    readonly field: "spendableBalance";
+}, {
+    readonly id: "createUnconfirmedSent";
+    readonly field: "unconfirmedSent";
+}, {
+    readonly id: "createUnconfirmedReceived";
+    readonly field: "unconfirmedReceived";
+}, {
+    readonly id: "createUnspendable";
+    readonly field: "unspendable";
+}, {
+    readonly id: "createWalletReserve";
+    readonly field: "walletReserve";
+}, {
+    readonly id: "createNetworkReserve";
+    readonly field: "networkReserve";
+}, {
+    readonly id: "createStaking";
+    readonly field: "staking";
+}, {
+    readonly id: "createStaked";
+    readonly field: "staked";
+}, {
+    readonly id: "createStakeable";
+    readonly field: "stakeable";
+}, {
+    readonly id: "createUnstaking";
+    readonly field: "unstaking";
+}, {
+    readonly id: "createUnstaked";
+    readonly field: "unstaked";
+}, {
+    readonly id: "createRewards";
+    readonly field: "rewards";
+}, {
+    readonly id: "createFrozen";
+    readonly field: "frozen";
+}];
+type FieldId = (typeof fieldDefinitions)[number]['id'];
+type FieldDefinition = {
+    [Id in FieldId]: ReturnType<typeof createBalanceSelectorFactory<Id>>;
+}[FieldId];
+declare const createBalanceSelectors: FieldDefinition[];
+export default createBalanceSelectors;

package/lib/redux/selectors/create-balance-selectors.js

@@ -0,0 +1,32 @@
+import lodash from 'lodash';
+import { MY_STATE } from '@exodus/redux-dependency-injection';
+import { createSelector } from 'reselect';
+const { memoize } = lodash;
+const createBalanceSelectorFactory = ({ field, id, }) => {
+    const selectorFactory = (createAssetSelector, selfSelector) => memoize(({ assetName, walletAccount }) => createSelector(createAssetSelector(assetName), selfSelector, (asset, balances) => balances[walletAccount]?.data[assetName]?.[field] ?? asset?.currency.ZERO), ({ assetName, walletAccount, field }) => [assetName, walletAccount, field].join('-'));
+    return {
+        id,
+        selectorFactory,
+        dependencies: [{ module: 'assets', selector: 'createAssetSelector' }, { selector: MY_STATE }],
+    };
+};
+const fieldDefinitions = [
+    { id: 'createTotal', field: 'total' },
+    { id: 'createBalance', field: 'balance' },
+    { id: 'createSpendable', field: 'spendable' },
+    { id: 'createSpendableBalance', field: 'spendableBalance' },
+    { id: 'createUnconfirmedSent', field: 'unconfirmedSent' },
+    { id: 'createUnconfirmedReceived', field: 'unconfirmedReceived' },
+    { id: 'createUnspendable', field: 'unspendable' },
+    { id: 'createWalletReserve', field: 'walletReserve' },
+    { id: 'createNetworkReserve', field: 'networkReserve' },
+    { id: 'createStaking', field: 'staking' },
+    { id: 'createStaked', field: 'staked' },
+    { id: 'createStakeable', field: 'stakeable' },
+    { id: 'createUnstaking', field: 'unstaking' },
+    { id: 'createUnstaked', field: 'unstaked' },
+    { id: 'createRewards', field: 'rewards' },
+    { id: 'createFrozen', field: 'frozen' },
+];
+const createBalanceSelectors = fieldDefinitions.map(createBalanceSelectorFactory);
+export default createBalanceSelectors;

package/lib/redux/selectors/create-balances.d.ts

@@ -0,0 +1,11 @@
+import type { FieldBalances } from '../../module/types.js';
+import type { Source, Selector, State } from '../types.js';
+import lodash from 'lodash';
+declare const createBalancesSelectorDefinition: {
+    readonly id: "createBalances";
+    readonly selectorFactory: (selfSelector: Selector<State>) => (({ assetName, walletAccount }: Source) => import("reselect").OutputSelector<unknown, FieldBalances, (res: State) => FieldBalances>) & lodash.MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly selector: "$state";
+    }];
+};
+export default createBalancesSelectorDefinition;