@exodus/balances 13.16.1 → 13.17.0

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

@@ -0,0 +1,13 @@
+import lodash from 'lodash';
+import { createSelector } from 'reselect';
+import { MY_STATE } from '@exodus/redux-dependency-injection';
+const { memoize } = lodash;
+const EMPTY_BALANCES = Object.create(null);
+const selectorFactory = (selfSelector) => memoize(({ assetName, walletAccount }) => createSelector(selfSelector, (balances) => balances[walletAccount]?.data[assetName] ??
+    EMPTY_BALANCES), ({ assetName, walletAccount }) => [assetName, walletAccount].join('-'));
+const createBalancesSelectorDefinition = {
+    id: 'createBalances',
+    selectorFactory,
+    dependencies: [{ selector: MY_STATE }],
+};
+export default createBalancesSelectorDefinition;

package/lib/redux/selectors/create-fuel-threshold.d.ts

@@ -0,0 +1,19 @@
+import type { Selector, CreateAssetSelector } from '../types.js';
+import type NumberUnit from '@exodus/currency';
+import lodash from 'lodash';
+declare const createFuelThresholdSelectorDefinition: {
+    readonly id: "createFuelThreshold";
+    readonly selectorFactory: (getFeeDataSelector: Selector<(name: string) => {
+        fuelThreshold?: NumberUnit;
+    } | undefined>, createAssetSelector: CreateAssetSelector) => ((assetName: string) => import("reselect").OutputSelector<unknown, NumberUnit | null, (res1: (name: string) => {
+        fuelThreshold?: NumberUnit;
+    } | undefined, res2: import("../types.js").Asset | undefined) => NumberUnit | null>) & lodash.MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "feeData";
+        readonly selector: "getData";
+    }, {
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }];
+};
+export default createFuelThresholdSelectorDefinition;

package/lib/redux/selectors/create-fuel-threshold.js

@@ -0,0 +1,22 @@
+import lodash from 'lodash';
+import { createSelector } from 'reselect';
+import { isNumberUnit } from '@exodus/currency';
+const { memoize } = lodash;
+const selectorFactory = (getFeeDataSelector, createAssetSelector) => memoize((assetName) => createSelector(getFeeDataSelector, createAssetSelector(assetName), (getFeeData, asset) => {
+    if (!asset) {
+        return null;
+    }
+    const feeData = getFeeData(asset.baseAsset.name);
+    return isNumberUnit(feeData?.fuelThreshold)
+        ? feeData.fuelThreshold
+        : asset.feeAsset.currency.ZERO;
+}));
+const createFuelThresholdSelectorDefinition = {
+    id: 'createFuelThreshold',
+    selectorFactory,
+    dependencies: [
+        { module: 'feeData', selector: 'getData' },
+        { module: 'assets', selector: 'createAssetSelector' },
+    ],
+};
+export default createFuelThresholdSelectorDefinition;

package/lib/redux/selectors/create-requires-fuel-threshold.d.ts

@@ -0,0 +1,19 @@
+import type { Selector, Asset, GetBalance } from '../types.js';
+declare const createRequiresFuelThresholdSelectorDefinition: {
+    readonly id: "createRequiresFuelThreshold";
+    readonly selectorFactory: (isTxLogLoadedSelector: Selector<(account: string) => boolean>, getAssetBalanceSelector: Selector<GetBalance>, assetsSelector: Selector<Record<string, Asset>>) => (source: {
+        assetName: string;
+        walletAccount: string;
+    }) => import("reselect").OutputSelector<unknown, boolean, (res1: (account: string) => boolean, res2: GetBalance, res3: Record<string, 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 createRequiresFuelThresholdSelectorDefinition;

package/lib/redux/selectors/create-requires-fuel-threshold.js

@@ -0,0 +1,29 @@
+import { createSelector } from 'reselect';
+import { memoizeByAssetSource } from '@exodus/core-selectors/utils/memoize.js';
+const selectorFactory = (isTxLogLoadedSelector, getAssetBalanceSelector, assetsSelector) => memoizeByAssetSource(({ assetName, walletAccount }) => createSelector(isTxLogLoadedSelector, getAssetBalanceSelector, assetsSelector, (isTxLogLoaded, getAssetBalance, assets) => {
+    if (!isTxLogLoaded(walletAccount))
+        return false;
+    const asset = assets[assetName];
+    if (!asset) {
+        return false;
+    }
+    const baseAssetName = asset.baseAsset.name;
+    const relatedAssets = Object.values(assets).filter((asset) => asset.baseAsset.name === baseAssetName && asset.name !== assetName);
+    return relatedAssets.some((token) => {
+        const balance = getAssetBalance({
+            assetName: token.name,
+            walletAccount,
+        });
+        return balance && !balance.isZero;
+    });
+}));
+const createRequiresFuelThresholdSelectorDefinition = {
+    id: 'createRequiresFuelThreshold',
+    selectorFactory,
+    dependencies: [
+        { module: 'txLog', selector: 'createIsWalletAccountLoadedSelectorOld' },
+        { module: 'balances', selector: 'getAssetSourceBalanceSelector' },
+        { module: 'availableAssets', selector: 'all' },
+    ],
+};
+export default createRequiresFuelThresholdSelectorDefinition;

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

@@ -0,0 +1,15 @@
+import type { TxSet } from '@exodus/models';
+import type { Source, Selector, CreateAssetSelector } from '../types.js';
+import lodash from 'lodash';
+declare const createUnconfirmedBalanceSelectorDefinition: {
+    readonly id: "createUnconfirmedBalance";
+    readonly selectorFactory: (createAssetSelector: CreateAssetSelector, createAssetSourceSelector: (source: Source) => Selector<TxSet>) => (({ assetName, walletAccount }: Source) => import("reselect").OutputSelector<unknown, import("@exodus/currency").default, (res1: import("../types.js").Asset | undefined, res2: TxSet) => import("@exodus/currency").default>) & lodash.MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "createAssetSelector";
+    }, {
+        readonly module: "txLog";
+        readonly selector: "createAssetSourceSelector";
+    }];
+};
+export default createUnconfirmedBalanceSelectorDefinition;

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

@@ -0,0 +1,14 @@
+import lodash from 'lodash';
+import { createSelector } from 'reselect';
+import { getUnconfirmedBalance } from './get-unconfirmed-balance.js';
+const { memoize } = lodash;
+const selectorFactory = (createAssetSelector, createAssetSourceSelector) => memoize(({ assetName, walletAccount }) => createSelector(createAssetSelector(assetName), createAssetSourceSelector({ assetName, walletAccount }), (asset, txs) => getUnconfirmedBalance({ asset: asset, txs })), ({ assetName, walletAccount }) => [assetName, walletAccount].join('-'));
+const createUnconfirmedBalanceSelectorDefinition = {
+    id: 'createUnconfirmedBalance',
+    selectorFactory,
+    dependencies: [
+        { module: 'assets', selector: 'createAssetSelector' },
+        { module: 'txLog', selector: 'createAssetSourceSelector' },
+    ],
+};
+export default createUnconfirmedBalanceSelectorDefinition;

package/lib/redux/selectors/get-balance-for-field.d.ts

@@ -0,0 +1,14 @@
+import type { FieldSource, GetAsset, GetBalances } from '../types.js';
+import lodash from 'lodash';
+declare const getBalanceForFieldSelectorDefinition: {
+    readonly id: "getBalanceForField";
+    readonly resultFunction: (getAsset: GetAsset, getBalances: GetBalances) => (({ assetName, walletAccount, field }: FieldSource) => import("@exodus/currency").default | undefined) & lodash.MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "getAsset";
+    }, {
+        readonly module: "balances";
+        readonly selector: "getBalances";
+    }];
+};
+export default getBalanceForFieldSelectorDefinition;

package/lib/redux/selectors/get-balance-for-field.js

@@ -0,0 +1,19 @@
+import lodash from 'lodash';
+import defaultConfig from '../../default-config.js';
+const { memoize } = lodash;
+const { balanceFields } = defaultConfig;
+const resultFunction = (getAsset, getBalances) => memoize(({ assetName, walletAccount, field }) => {
+    if (!balanceFields.includes(field)) {
+        throw new Error(`Value '${field}' is not one of the valid fields '${balanceFields.join(', ')}'`);
+    }
+    return (getBalances({ assetName, walletAccount })?.[field] ?? getAsset(assetName)?.currency.ZERO);
+}, ({ assetName, walletAccount, field }) => [assetName, walletAccount, field].join('-'));
+const getBalanceForFieldSelectorDefinition = {
+    id: 'getBalanceForField',
+    resultFunction,
+    dependencies: [
+        { module: 'assets', selector: 'getAsset' },
+        { module: 'balances', selector: 'getBalances' },
+    ],
+};
+export default getBalanceForFieldSelectorDefinition;

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

@@ -0,0 +1,68 @@
+import type { Source, GetBalanceForField } from '../types.js';
+import lodash from 'lodash';
+declare const getBalanceSelectorFactory: <const Id extends string>({ field, id, }: {
+    field: string;
+    id: Id;
+}) => {
+    readonly id: Id;
+    readonly resultFunction: (getBalanceForField: GetBalanceForField) => (({ assetName, walletAccount }: Source) => import("@exodus/currency").default | undefined) & lodash.MemoizedFunction;
+    readonly dependencies: readonly [{
+        readonly module: "balances";
+        readonly selector: "getBalanceForField";
+    }];
+};
+declare const fieldDefinitions: readonly [{
+    readonly id: "getTotal";
+    readonly field: "total";
+}, {
+    readonly id: "getBalance";
+    readonly field: "balance";
+}, {
+    readonly id: "getSpendable";
+    readonly field: "spendable";
+}, {
+    readonly id: "getSpendableBalance";
+    readonly field: "spendableBalance";
+}, {
+    readonly id: "getUnconfirmedSent";
+    readonly field: "unconfirmedSent";
+}, {
+    readonly id: "getUnconfirmedReceived";
+    readonly field: "unconfirmedReceived";
+}, {
+    readonly id: "getUnspendable";
+    readonly field: "unspendable";
+}, {
+    readonly id: "getWalletReserve";
+    readonly field: "walletReserve";
+}, {
+    readonly id: "getNetworkReserve";
+    readonly field: "networkReserve";
+}, {
+    readonly id: "getStaking";
+    readonly field: "staking";
+}, {
+    readonly id: "getStaked";
+    readonly field: "staked";
+}, {
+    readonly id: "getStakeable";
+    readonly field: "stakeable";
+}, {
+    readonly id: "getUnstaking";
+    readonly field: "unstaking";
+}, {
+    readonly id: "getUnstaked";
+    readonly field: "unstaked";
+}, {
+    readonly id: "getRewards";
+    readonly field: "rewards";
+}, {
+    readonly id: "getFrozen";
+    readonly field: "frozen";
+}];
+type FieldId = (typeof fieldDefinitions)[number]['id'];
+type FieldDefinition = {
+    [Id in FieldId]: ReturnType<typeof getBalanceSelectorFactory<Id>>;
+}[FieldId];
+declare const getBalanceSelectors: FieldDefinition[];
+export default getBalanceSelectors;

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

@@ -0,0 +1,32 @@
+import lodash from 'lodash';
+const { memoize } = lodash;
+const createResultFunction = (field) => (getBalanceForField) => memoize(({ assetName, walletAccount }) => {
+    return getBalanceForField({ assetName, walletAccount, field });
+}, ({ assetName, walletAccount }) => [assetName, walletAccount].join('-'));
+const getBalanceSelectorFactory = ({ field, id, }) => {
+    return {
+        id,
+        resultFunction: createResultFunction(field),
+        dependencies: [{ module: 'balances', selector: 'getBalanceForField' }],
+    };
+};
+const fieldDefinitions = [
+    { id: 'getTotal', field: 'total' },
+    { id: 'getBalance', field: 'balance' },
+    { id: 'getSpendable', field: 'spendable' },
+    { id: 'getSpendableBalance', field: 'spendableBalance' },
+    { id: 'getUnconfirmedSent', field: 'unconfirmedSent' },
+    { id: 'getUnconfirmedReceived', field: 'unconfirmedReceived' },
+    { id: 'getUnspendable', field: 'unspendable' },
+    { id: 'getWalletReserve', field: 'walletReserve' },
+    { id: 'getNetworkReserve', field: 'networkReserve' },
+    { id: 'getStaking', field: 'staking' },
+    { id: 'getStaked', field: 'staked' },
+    { id: 'getStakeable', field: 'stakeable' },
+    { id: 'getUnstaking', field: 'unstaking' },
+    { id: 'getUnstaked', field: 'unstaked' },
+    { id: 'getRewards', field: 'rewards' },
+    { id: 'getFrozen', field: 'frozen' },
+];
+const getBalanceSelectors = fieldDefinitions.map(getBalanceSelectorFactory);
+export default getBalanceSelectors;

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

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

package/lib/redux/selectors/get-balances.js

@@ -0,0 +1,13 @@
+import lodash from 'lodash';
+import { createSelector } from 'reselect';
+import { MY_STATE } from '@exodus/redux-dependency-injection';
+const { memoize } = lodash;
+const selectorFactory = (selfSelector) => createSelector(selfSelector, (balances) => memoize(({ assetName, walletAccount }) => {
+    return (balances[walletAccount]?.data[assetName]);
+}, ({ assetName, walletAccount }) => [assetName, walletAccount].join('-')));
+const getBalancesSelectorDefinition = {
+    id: 'getBalances',
+    selectorFactory,
+    dependencies: [{ selector: MY_STATE }],
+};
+export default getBalancesSelectorDefinition;

package/lib/redux/selectors/get-unconfirmed-balance.d.ts

@@ -0,0 +1,19 @@
+import type { TxSet } from '@exodus/models';
+import type { Source, Selector, Asset, GetAsset, GetTxs } from '../types.js';
+import lodash from 'lodash';
+export declare const getUnconfirmedBalance: ({ asset, txs }: {
+    asset: Asset;
+    txs: TxSet;
+}) => import("@exodus/currency").default;
+declare const getUnconfirmedBalanceSelectorDefinition: {
+    readonly id: "getUnconfirmedBalance";
+    readonly selectorFactory: (getAssetSelector: Selector<GetAsset>, createAssetSourceSelector: Selector<GetTxs>) => import("reselect").OutputSelector<unknown, (({ assetName, walletAccount }: Source) => import("@exodus/currency").default) & lodash.MemoizedFunction, (res1: GetAsset, res2: GetTxs) => (({ assetName, walletAccount }: Source) => import("@exodus/currency").default) & lodash.MemoizedFunction>;
+    readonly dependencies: readonly [{
+        readonly module: "assets";
+        readonly selector: "getAsset";
+    }, {
+        readonly module: "txLog";
+        readonly selector: "createAssetSourceSelectorOld";
+    }];
+};
+export default getUnconfirmedBalanceSelectorDefinition;

package/lib/redux/selectors/get-unconfirmed-balance.js

@@ -0,0 +1,27 @@
+import lodash from 'lodash';
+import { createSelector } from 'reselect';
+const { memoize } = lodash;
+export const getUnconfirmedBalance = ({ asset, txs }) => {
+    let result = asset.currency.ZERO;
+    for (const tx of txs) {
+        const isIncommingTX = !tx.sent;
+        const isUnconfirmed = !tx.failed && tx.pending;
+        if (isUnconfirmed && isIncommingTX) {
+            result = result.add(tx.coinAmount);
+        }
+    }
+    return result;
+};
+const selectorFactory = (getAssetSelector, createAssetSourceSelector) => createSelector(getAssetSelector, createAssetSourceSelector, (getAsset, getTxs) => memoize(({ assetName, walletAccount }) => getUnconfirmedBalance({
+    asset: getAsset(assetName),
+    txs: getTxs({ assetName, walletAccount }),
+}), ({ assetName, walletAccount }) => [assetName, walletAccount].join('-')));
+const getUnconfirmedBalanceSelectorDefinition = {
+    id: 'getUnconfirmedBalance',
+    selectorFactory,
+    dependencies: [
+        { module: 'assets', selector: 'getAsset' },
+        { module: 'txLog', selector: 'createAssetSourceSelectorOld' },
+    ],
+};
+export default getUnconfirmedBalanceSelectorDefinition;