@exodus/balances 13.16.0 → 13.17.0

package/lib/atoms/index.js

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

package/lib/default-config.d.ts

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

package/lib/default-config.js

@@ -0,0 +1,24 @@
+const balanceFieldsConfig = [
+    { name: 'total', legacyName: 'balance', default: 'zero' },
+    { name: 'spendable', legacyName: 'spendableBalance', default: 'total' },
+    { name: 'unconfirmedSent', default: 'zero' },
+    { name: 'unconfirmedReceived', default: 'zero' },
+    { name: 'unspendable', default: 'zero' },
+    { name: 'walletReserve', default: 'zero' },
+    { name: 'networkReserve', default: 'zero' },
+    { name: 'staking', default: 'zero' },
+    { name: 'staked', default: 'zero' },
+    { name: 'stakeable', default: 'zero' },
+    { name: 'unstaking', default: 'zero' },
+    { name: 'unstaked', default: 'zero' },
+    { name: 'rewards', default: 'zero' },
+    { name: 'frozen', default: 'zero' },
+];
+const config = {
+    balanceFieldsConfig,
+    balanceFields: balanceFieldsConfig
+        .flatMap((fieldConfig) => [fieldConfig.name, fieldConfig.legacyName])
+        .filter((field) => Boolean(field)),
+    assetsToTrackForBalances: [],
+};
+export default config;

package/lib/index.d.ts

@@ -0,0 +1,187 @@
+import type { BalancesConfig } from './module/types.js';
+declare const balances: (walletConfig?: Partial<BalancesConfig>) => {
+    readonly id: import("@exodus/safe-string").SafeString;
+    readonly definitions: readonly [{
+        definition: {
+            readonly id: "balances";
+            readonly type: "module";
+            readonly factory: (opts: {
+                config: {
+                    importReport: import("./types.js").BalancesByAssetSource;
+                };
+                balancesAtom: import("./types.js").BalancesAtom;
+            }) => import("./module/types.js").BalancesModule;
+            readonly dependencies: readonly ["config", "balancesAtom"];
+            readonly public: true;
+        };
+        config: {
+            importReport: import("./types.js").BalancesByAssetSource;
+            balanceFields: string[];
+            assetsToTrackForBalances: {
+                assetName: string;
+                analyticsName: string;
+            }[];
+            balanceFieldsConfig: import("./module/types.js").BalanceFieldConfig[];
+        };
+    } | {
+        definition: {
+            readonly id: "balances";
+            readonly type: "module";
+            readonly factory: (opts: import("./module/types.js").Options) => import("./module/types.js").BalancesModule;
+            readonly dependencies: readonly ["assetsAtom", "availableAssetNamesAtom", "enabledWalletAccountsAtom", "config", "logger", "balancesAtom", "blockchainMetadataAtom", "feeDataAtom", "errorTracking"];
+            readonly public: true;
+        };
+        config: {
+            balanceFields: string[];
+            assetsToTrackForBalances: {
+                assetName: string;
+                analyticsName: string;
+            }[];
+            balanceFieldsConfig: import("./module/types.js").BalanceFieldConfig[];
+            importReport?: import("./types.js").BalancesByAssetSource;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "balancesAtom";
+            readonly type: "atom";
+            readonly factory: () => import("@exodus/atoms").Atom<import("./types.js").BalancesAtomValue>;
+            readonly dependencies: readonly [];
+            readonly public: true;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "assetNamesWithBalanceAtom";
+            readonly type: "atom";
+            readonly factory: ({ balancesAtom }: {
+                balancesAtom: import("./types.js").BalancesAtom;
+            }) => import("@exodus/atoms").ReadonlyAtom<Set<string>>;
+            readonly dependencies: readonly ["balancesAtom"];
+            readonly public: true;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "assetsWithBalanceCountAtom";
+            readonly type: "atom";
+            readonly factory: ({ assetNamesWithBalanceAtom, }: {
+                assetNamesWithBalanceAtom: import("@exodus/atoms").ReadonlyAtom<Set<string>>;
+            }) => import("@exodus/atoms").ReadonlyAtom<number>;
+            readonly dependencies: readonly ["assetNamesWithBalanceAtom"];
+            readonly public: true;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "hasBalanceAtom";
+            readonly type: "atom";
+            readonly factory: ({ balancesAtom, storage, }: {
+                balancesAtom: import("./types.js").BalancesAtom;
+                storage: import("@exodus/storage-interface").Storage<boolean>;
+            }) => import("./types.js").HasBalanceAtom;
+            readonly dependencies: readonly ["balancesAtom", "storage"];
+            readonly public: true;
+        };
+        readonly storage: {
+            readonly namespace: "balances";
+        };
+        readonly aliases: readonly [{
+            readonly implementationId: "unsafeStorage";
+            readonly interfaceId: "storage";
+        }];
+    }, {
+        readonly definition: {
+            readonly id: "fundedWalletAccountsAtom";
+            readonly type: "atom";
+            readonly factory: ({ balancesAtom, enabledWalletAccountsAtom, }: {
+                balancesAtom: import("./types.js").BalancesAtom;
+                enabledWalletAccountsAtom: import("@exodus/atoms").ReadonlyAtom<Record<string, import("@exodus/models").WalletAccount>>;
+            }) => import("./types.js").FundedWalletAccountsAtom;
+            readonly dependencies: readonly ["balancesAtom", "enabledWalletAccountsAtom"];
+            readonly public: true;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "balancesReport";
+            readonly type: "report";
+            readonly factory: ({ enabledWalletAccountsAtom, balancesAtom, }: {
+                enabledWalletAccountsAtom: import("@exodus/atoms").ReadonlyAtom<Record<string, import("@exodus/models").WalletAccount>>;
+                balancesAtom: import("./types.js").BalancesAtom;
+            }) => {
+                namespace: string;
+                export: ({ walletExists, isLocked }?: {
+                    walletExists?: boolean;
+                    isLocked?: boolean;
+                }) => Promise<Record<string, {
+                    balances: Record<string, string>;
+                }> | {
+                    error: import("@exodus/errors").SafeError;
+                } | null>;
+                getSchema: import("@exodus/basic-utils/lib/memoize.js").MemoizedFunction<() => import("@exodus/zod").ZodNullable<import("@exodus/zod").ZodRecord<import("@exodus/zod").ZodString, import("@exodus/zod").ZodUnion<[import("@exodus/zod").ZodObject<{
+                    balances: import("@exodus/zod").ZodRecord<import("@exodus/zod").ZodString, import("@exodus/zod").ZodString>;
+                }, "strict", import("@exodus/zod").ZodTypeAny, {
+                    balances: Record<string, string>;
+                }, {
+                    balances: Record<string, string>;
+                }>, import("@exodus/zod").ZodType<import("@exodus/errors").SafeError, import("@exodus/zod").ZodTypeDef, import("@exodus/errors").SafeError>]>>>>;
+            };
+            readonly dependencies: readonly ["enabledWalletAccountsAtom", "balancesAtom"];
+            readonly public: true;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "balancesLifecyclePlugin";
+            readonly type: "plugin";
+            readonly factory: ({ balancesAtom, port, balances, hasBalanceAtom, }: {
+                balancesAtom: import("./types.js").BalancesAtom;
+                port: import("@exodus/atoms").Port<import("./types.js").BalancesAtomValue | boolean | undefined>;
+                balances: import("./module/types.js").BalancesModule;
+                hasBalanceAtom: import("./types.js").HasBalanceAtom;
+            }) => {
+                onLoad: () => void;
+                onStop: () => void;
+                onClear: () => Promise<void>;
+            };
+            readonly dependencies: readonly ["balancesAtom", "port", "balances", "hasBalanceAtom"];
+            readonly public: true;
+        };
+    }, {
+        readonly definition: {
+            readonly id: "assetsTotalWalletAmountsAtom";
+            readonly type: "atom";
+            readonly factory: ({ balancesAtom, }: {
+                balancesAtom: import("./types.js").BalancesAtom;
+            }) => import("./types.js").AssetTotalWalletAmountsAtom;
+            readonly dependencies: readonly ["balancesAtom"];
+            readonly public: true;
+        };
+    }, {
+        readonly if: {
+            readonly registered: readonly ["analytics"];
+        };
+        readonly definition: {
+            readonly id: "balancesAnalyticsPlugin";
+            readonly type: "plugin";
+            readonly factory: ({ analytics, hasBalanceAtom, assetsWithBalanceCountAtom, assetsTotalWalletAmountsAtom, config: { assetsToTrackForBalances }, }: {
+                analytics: {
+                    requireDefaultEventProperties(keys: string[]): void;
+                    setDefaultEventProperties(properties: Record<string, boolean | number>): void;
+                };
+                hasBalanceAtom: Pick<import("./types.js").HasBalanceAtom, "get" | "observe">;
+                assetsWithBalanceCountAtom: import("@exodus/atoms").ReadonlyAtom<number>;
+                assetsTotalWalletAmountsAtom: import("@exodus/atoms").ReadonlyAtom<Map<string, import("@exodus/currency").default>>;
+                config: Pick<BalancesConfig, "assetsToTrackForBalances">;
+            }) => {
+                onStart: () => void;
+                onStop: () => void;
+            };
+            readonly dependencies: readonly ["analytics", "hasBalanceAtom", "assetsWithBalanceCountAtom", "assetsTotalWalletAmountsAtom", "config?"];
+            readonly public: true;
+        };
+        readonly config: {
+            readonly assetsToTrackForBalances: {
+                assetName: string;
+                analyticsName: string;
+            }[];
+        };
+    }];
+};
+export type * from './types.js';
+export default balances;

package/lib/index.js

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

package/lib/module/balances-utils.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '@exodus/atoms';
+import type { BalanceAsset, BalanceFieldConfig, FieldBalances } from './types.js';
+import type NumberUnit from '@exodus/currency';
+export declare const processAssetBalances: ({ balances, zero, balanceFieldsConfig, }: {
+    balances: FieldBalances;
+    zero: NumberUnit;
+    balanceFieldsConfig: BalanceFieldConfig[];
+}) => FieldBalances;
+export declare const validateBalances: ({ balances, asset, logger, }: {
+    balances: FieldBalances;
+    asset: BalanceAsset;
+    logger: Pick<Logger, "warn">;
+}) => Record<string, NumberUnit>;

package/lib/module/balances-utils.js

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

package/lib/module/index.d.ts

@@ -0,0 +1,11 @@
+import type { BalancesModule, Options } from './types.js';
+import type { BalancesByAssetSource } from '../types.js';
+export declare const cloneBalances: (balances: BalancesByAssetSource) => BalancesByAssetSource;
+declare const balancesDefinition: {
+    readonly id: "balances";
+    readonly type: "module";
+    readonly factory: (opts: Options) => BalancesModule;
+    readonly dependencies: readonly ["assetsAtom", "availableAssetNamesAtom", "enabledWalletAccountsAtom", "config", "logger", "balancesAtom", "blockchainMetadataAtom", "feeDataAtom", "errorTracking"];
+    readonly public: true;
+};
+export default balancesDefinition;