@ledgerhq/live-common 34.47.0-nightly.7 → 34.47.0

package/src/modularDrawer/data/entities/interestRateSelectors.ts

@@ -1,39 +0,0 @@
-import { createSelector } from "@reduxjs/toolkit";
-import { InterestRate } from "../entities";
-
-interface ApiState {
-  assetsDataApi?: {
-    queries?: Record<string, QueryCacheEntry>;
-  };
-}
-
-interface QueryCacheEntry {
-  data?: {
-    pages?: Array<{
-      interestRates?: Record<string, InterestRate>;
-    }>;
-  };
-}
-
-export const selectInterestRateByCurrency: (
-  state: ApiState,
-  currencyId: string,
-) => InterestRate | undefined = createSelector(
-  [
-    (state: ApiState) => state.assetsDataApi?.queries ?? {},
-    (_state: ApiState, currencyId: string) => currencyId,
-  ],
-  (queries, currencyId): InterestRate | undefined => {
-    for (const query of Object.values(queries)) {
-      const pages = query.data?.pages;
-      if (!pages) continue;
-
-      for (const page of pages) {
-        const rate = page.interestRates?.[currencyId];
-        if (rate) return rate;
-      }
-    }
-
-    return undefined;
-  },
-);

package/src/modularDrawer/data/state-manager/types.ts

@@ -1,28 +0,0 @@
-import { AssetsData } from "../entities";
-
-export enum AssetsDataTags {
-  Assets = "Assets",
-}
-
-export enum AssetsAdditionalData {
-  Apy = "apy",
-  MarketTrend = "marketTrend",
-}
-
-export interface GetAssetsDataParams {
-  search?: string;
-  currencyIds?: string[];
-  useCase?: string;
-  product: "llm" | "lld";
-  version: string;
-}
-
-export interface PageParam {
-  cursor?: string;
-}
-
-export interface AssetsDataWithPagination extends AssetsData {
-  pagination: {
-    nextCursor?: string;
-  };
-}

package/src/modularDrawer/hooks/useLeftAccounts.tsx

@@ -1,23 +0,0 @@
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { ReactNode } from "react";
-import { AccountModuleParams, AccountDataItem } from "../utils/type";
-
-export const createUseLeftAccountsModule = ({
-  useAccountData,
-  accountsCount,
-}: {
-  useAccountData: (params: AccountModuleParams) => AccountDataItem[];
-  accountsCount: (args: { label: string }) => ReactNode;
-}) => {
-  return function useLeftAccountsModule(
-    params: AccountModuleParams,
-  ): Array<CryptoOrTokenCurrency & { leftElement?: ReactNode; count: number }> {
-    const accountData = useAccountData(params);
-
-    return accountData.map(({ asset, label, count }) => ({
-      ...asset,
-      leftElement: count > 0 ? accountsCount({ label }) : undefined,
-      count,
-    }));
-  };
-};

package/src/modularDrawer/hooks/useLeftAccountsApy.tsx

@@ -1,28 +0,0 @@
-import {
-  AccountDataItem,
-  AccountModuleParams,
-  CreateAccountsCountAndApy,
-  NetworkWithCount,
-} from "../utils/type";
-
-export const createUseLeftAccountsApyModule = ({
-  useAccountData,
-  accountsCountAndApy,
-}: {
-  useAccountData: (params: AccountModuleParams) => AccountDataItem[];
-  accountsCountAndApy: CreateAccountsCountAndApy;
-}) => {
-  return function useLeftAccountsApyModule(params: AccountModuleParams): NetworkWithCount[] {
-    const accountData = useAccountData(params);
-
-    return accountData.map(({ asset, label, count }) => {
-      const value = 5.11; // TODO to be retrieved from DADA
-      const type = "APY"; // TODO to be retrieved from DADA
-      return {
-        ...asset,
-        leftElement: count > 0 ? accountsCountAndApy({ label, value, type }) : undefined,
-        count,
-      };
-    });
-  };
-};

package/src/modularDrawer/hooks/useLeftApy.tsx

@@ -1,19 +0,0 @@
-import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { ReactNode } from "react";
-import { ApyType } from "../utils/type";
-
-export const createUseLeftApyModule = ({
-  ApyIndicator,
-}: {
-  ApyIndicator: (args: { value: number; type: ApyType }) => ReactNode;
-}) => {
-  return (assets: CryptoOrTokenCurrency[]) => {
-    const value = 5.11; // TODO: fetch DADA
-    const type: ApyType = "APY"; // TODO: fetch DADA
-
-    return assets.map(asset => ({
-      ...asset,
-      leftElement: ApyIndicator({ value, type }),
-    }));
-  };
-};

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -1,140 +0,0 @@
-import { useMemo } from "react";
-import type { ReactNode } from "react";
-import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
-import BigNumber from "bignumber.js";
-import { counterValueFormatter } from "../utils/counterValueFormatter";
-import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { UseBalanceDeps } from "../utils/type";
-import { buildProviderCurrenciesMap } from "../utils/buildProviderCurrenciesMap";
-import { CurrenciesByProviderId } from "../../deposit/type";
-import { calculateProviderTotals } from "../utils/calculateProviderTotal";
-import { getProviderCurrency } from "../utils/getProviderCurrency";
-import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
-import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
-
-export type AssetDeps = {
-  useBalanceDeps: UseBalanceDeps;
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
-};
-
-export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem }: AssetDeps) {
-  const formatProviderResult = (
-    providerCurrency: CryptoOrTokenCurrency,
-    totalBalance: BigNumber,
-    totalFiatValue: BigNumber,
-    counterValueCurrency: Currency,
-    locale: string,
-    discreet: boolean,
-  ) => {
-    const unit = providerCurrency.units?.[0];
-    const balance = unit
-      ? formatCurrencyUnit(unit, totalBalance, { showCode: true, discreet })
-      : `${totalBalance.toFixed()} ${providerCurrency.ticker ?? providerCurrency.symbol}`;
-    const fiatValue = counterValueFormatter({
-      currency: counterValueCurrency.ticker,
-      value: totalFiatValue.toNumber(),
-      locale,
-      allowZeroValue: true,
-    });
-    return { balance, fiatValue };
-  };
-
-  return function useRightBalanceAsset(
-    assets: CryptoOrTokenCurrency[],
-    currenciesByProvider: CurrenciesByProviderId[],
-  ) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
-
-    const grouped = useMemo(
-      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency, discreet),
-      [flattenedAccounts, state, counterValueCurrency, discreet],
-    );
-
-    const providerMap = useMemo(
-      () => buildProviderCurrenciesMap(currenciesByProvider),
-      [currenciesByProvider],
-    );
-
-    return useMemo(() => {
-      if (!providerMap) {
-        const allBalance = getBalanceAndFiatValueByAssets(
-          flattenedAccounts,
-          assets,
-          state,
-          counterValueCurrency,
-          discreet,
-          locale,
-        );
-        const balanceMap = new Map(allBalance.map(b => [b.id, b]));
-        const assetsWithBalanceData = assets.map(asset => {
-          const balanceData = balanceMap.get(asset.id) || {};
-          return {
-            asset,
-            balanceData,
-          };
-        });
-
-        assetsWithBalanceData.sort((a, b) =>
-          compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-        );
-
-        return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-          ...asset,
-          rightElement: balanceItem(balanceData),
-        }));
-      }
-
-      const assetsSet = new Set(assets.map(a => a.id));
-      const providerResultsMap = new Map<string, { balance?: string; fiatValue?: string }>();
-
-      for (const [, { currencies, mainCurrency }] of providerMap) {
-        if (!assetsSet.has(mainCurrency.id)) continue;
-        const providerCurrency = getProviderCurrency(mainCurrency, currencies);
-        if (!providerCurrency) continue;
-
-        const { totalBalance, totalFiatValue, hasAccounts } = calculateProviderTotals(
-          currencies,
-          grouped,
-        );
-        if (!hasAccounts) continue;
-
-        const { balance, fiatValue } = formatProviderResult(
-          providerCurrency,
-          totalBalance,
-          totalFiatValue,
-          counterValueCurrency,
-          locale,
-          discreet,
-        );
-        providerResultsMap.set(mainCurrency.id, { balance, fiatValue });
-      }
-
-      const assetsWithBalanceData = assets.map(asset => {
-        const balanceData = providerResultsMap.get(asset.id) || {};
-        return {
-          asset,
-          balanceData,
-        };
-      });
-
-      assetsWithBalanceData.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-      );
-
-      return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-        ...asset,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [
-      assets,
-      providerMap,
-      flattenedAccounts,
-      state,
-      counterValueCurrency,
-      discreet,
-      locale,
-      grouped,
-    ]);
-  };
-}

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,116 +0,0 @@
-import { useMemo, type ReactNode } from "react";
-import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { BalanceUI, UseBalanceDeps } from "../utils/type";
-import { CurrenciesByProviderId } from "../../deposit/type";
-import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
-
-export type NetworkDeps = {
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
-  useBalanceDeps: UseBalanceDeps;
-};
-
-type Params = {
-  assets: CryptoOrTokenCurrency[];
-  selectedAssetId: string;
-  currenciesByProvider: CurrenciesByProviderId[];
-};
-
-export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({
-    assets: networks,
-    selectedAssetId,
-    currenciesByProvider,
-  }: Params) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
-
-    return useMemo(() => {
-      if (currenciesByProvider && currenciesByProvider.length > 0) {
-        const providerOfSelectedAsset = currenciesByProvider.find(provider =>
-          provider.currenciesByNetwork.some(currency => currency.id === selectedAssetId),
-        );
-
-        if (providerOfSelectedAsset) {
-          const pairs = networks.map(network => ({
-            network,
-            asset: providerOfSelectedAsset.currenciesByNetwork.find(currency =>
-              currency.type === "TokenCurrency"
-                ? currency.parentCurrency.id === network.id
-                : currency.id === network.id,
-            ),
-          }));
-
-          const validAssets = pairs.filter(p => p.asset).map(p => p.asset!);
-
-          const allBalanceData =
-            validAssets.length > 0
-              ? getBalanceAndFiatValueByAssets(
-                  flattenedAccounts,
-                  validAssets,
-                  state,
-                  counterValueCurrency,
-                  discreet,
-                  locale,
-                )
-              : [];
-
-          const balanceMap = new Map(allBalanceData.map(b => [b.id, b]));
-
-          const networkWithBalanceData = pairs.map(({ network, asset }) => {
-            const balanceData: BalanceUI = asset ? balanceMap.get(asset.id) || {} : {};
-            return {
-              network,
-              balanceData,
-            };
-          });
-
-          networkWithBalanceData.sort((a, b) =>
-            compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-          );
-
-          return networkWithBalanceData.map(({ network, balanceData }) => ({
-            ...network,
-            rightElement: balanceItem(balanceData),
-          }));
-        }
-      }
-
-      const networkBalanceData = getBalanceAndFiatValueByAssets(
-        flattenedAccounts,
-        networks,
-        state,
-        counterValueCurrency,
-        discreet,
-        locale,
-      );
-
-      const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
-
-      const networksWithBalance = networks.map(network => {
-        const balanceData = balanceMap.get(network.id) || {};
-        return {
-          network,
-          balanceData,
-        };
-      });
-
-      networksWithBalance.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-      );
-
-      return networksWithBalance.map(({ network, balanceData }) => ({
-        ...network,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [
-      networks,
-      selectedAssetId,
-      currenciesByProvider,
-      flattenedAccounts,
-      state,
-      counterValueCurrency,
-      discreet,
-      locale,
-    ]);
-  };
-}

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -1,61 +0,0 @@
-import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { AssetType, CreateAssetConfigurationHook, AssetConfigurationDeps } from "../utils/type";
-import { CurrenciesByProviderId } from "../../deposit/type";
-import { composeHooks } from "../../utils/composeHooks";
-import { createUseLeftApyModule } from "../hooks/useLeftApy";
-import { createUseRightBalanceAsset } from "../hooks/useRightBalanceAsset";
-
-const getRightElement =
-  (AssetConfigurationDeps: AssetConfigurationDeps) => (rightElement: string) => {
-    switch (rightElement) {
-      case "balance":
-        return createUseRightBalanceAsset({
-          useBalanceDeps: AssetConfigurationDeps.useBalanceDeps,
-          balanceItem: AssetConfigurationDeps.balanceItem,
-        });
-      case "marketTrend":
-      case "undefined":
-      default:
-        return undefined;
-    }
-  };
-
-const getLeftElement =
-  (AssetConfigurationDeps: AssetConfigurationDeps) => (leftElement: string) => {
-    switch (leftElement) {
-      case "apy":
-        return createUseLeftApyModule({ ApyIndicator: AssetConfigurationDeps.ApyIndicator });
-      case "priceVariation":
-      case "undefined":
-      default:
-        return undefined;
-    }
-  };
-
-const createAssetConfigurationHook: CreateAssetConfigurationHook =
-  deps =>
-  ({ assetsConfiguration, currenciesByProvider }) => {
-    const { rightElement = "undefined", leftElement = "undefined" } = assetsConfiguration ?? {};
-
-    const rightHook = getRightElement(deps)(rightElement);
-    const leftHook = getLeftElement(deps)(leftElement);
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const hooks = [rightHook, leftHook].filter(Boolean) as Array<
-      (
-        assets: CryptoOrTokenCurrency[],
-        currenciesByProvider?: CurrenciesByProviderId[],
-      ) => AssetType[]
-    >;
-
-    return (assets: CryptoOrTokenCurrency[]) => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(
-        ...hooks.map(
-          hook => (assets: CryptoOrTokenCurrency[]) => hook(assets, currenciesByProvider),
-        ),
-      );
-      return composedHook(assets);
-    };
-  };
-
-export default createAssetConfigurationHook;

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -1,79 +0,0 @@
-import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { createUseLeftAccountsModule } from "../hooks/useLeftAccounts";
-import { createUseLeftAccountsApyModule } from "../hooks/useLeftAccountsApy";
-import { createUseRightBalanceNetwork } from "../hooks/useRightBalanceNetwork";
-import {
-  CreateNetworkConfigurationHookProps,
-  NetworkConfigurationDeps,
-  LeftElementKind,
-  Network,
-  NetworkHook,
-  RightElementKind,
-} from "../utils/type";
-import { composeHooks } from "../../utils/composeHooks";
-
-export const getLeftElement =
-  (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  (leftElement: LeftElementKind): NetworkHook | undefined => {
-    switch (leftElement) {
-      case "numberOfAccounts":
-        return createUseLeftAccountsModule({
-          useAccountData: NetworkConfigurationDeps.useAccountData,
-          accountsCount: NetworkConfigurationDeps.accountsCount,
-        });
-      case "numberOfAccountsAndApy":
-        return createUseLeftAccountsApyModule({
-          useAccountData: NetworkConfigurationDeps.useAccountData,
-          accountsCountAndApy: NetworkConfigurationDeps.accountsCountAndApy,
-        });
-      case "undefined":
-      default:
-        return undefined;
-    }
-  };
-
-export const getRightElement =
-  (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  (rightElement: RightElementKind): NetworkHook | undefined => {
-    switch (rightElement) {
-      case "balance":
-        return createUseRightBalanceNetwork({
-          useBalanceDeps: NetworkConfigurationDeps.useBalanceDeps,
-          balanceItem: NetworkConfigurationDeps.balanceItem,
-        });
-      case "undefined":
-      default:
-        return undefined;
-    }
-  };
-
-export const createNetworkConfigurationHook =
-  (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  ({
-    networksConfig,
-    selectedAssetId,
-    currenciesByProvider,
-    accounts$,
-  }: CreateNetworkConfigurationHookProps) => {
-    const { leftElement = "undefined", rightElement = "undefined" } = networksConfig ?? {};
-    const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
-    const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const hooks = [rightHook, leftHook].filter(Boolean) as NetworkHook[];
-
-    return (assets: CryptoOrTokenCurrency[]): Array<CryptoOrTokenCurrency & Network> => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, Network>(
-        ...hooks.map(
-          hook => (assets: CryptoOrTokenCurrency[]) =>
-            hook({
-              assets,
-              selectedAssetId,
-              currenciesByProvider: currenciesByProvider || [],
-              accounts$,
-            }),
-        ),
-      );
-      return composedHook(assets);
-    };
-  };

package/src/modularDrawer/utils/buildProviderCurrenciesMap.tsx

@@ -1,25 +0,0 @@
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-export const buildProviderCurrenciesMap = (
-  currenciesByProvider?: Array<{
-    providerId: string;
-    currenciesByNetwork?: CryptoOrTokenCurrency[];
-  }>,
-) => {
-  if (!currenciesByProvider?.length) return null;
-
-  const map = new Map<
-    string,
-    { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
-  >();
-
-  currenciesByProvider.forEach(({ providerId, currenciesByNetwork = [] }) => {
-    if (currenciesByNetwork.length > 0) {
-      const mainCurrency =
-        currenciesByNetwork.find(c => c.id === providerId) ?? currenciesByNetwork[0];
-      map.set(providerId, { mainCurrency, currencies: currenciesByNetwork });
-    }
-  });
-
-  return map;
-};

package/src/modularDrawer/utils/getLoadingStatus.ts

@@ -1,24 +0,0 @@
-import { LoadingStatus } from "../../deposit/type";
-import { SerializedError } from "@reduxjs/toolkit";
-import { FetchBaseQueryError } from "@reduxjs/toolkit/query";
-
-export const getLoadingStatus = ({
-  isLoading,
-  isSuccess,
-  error,
-}: {
-  isLoading: boolean;
-  isSuccess: boolean;
-  error?: FetchBaseQueryError | SerializedError;
-}): LoadingStatus => {
-  if (isLoading) {
-    return LoadingStatus.Pending;
-  }
-  if (error) {
-    return LoadingStatus.Error;
-  }
-  if (isSuccess) {
-    return LoadingStatus.Success;
-  }
-  return LoadingStatus.Idle;
-};

package/src/modularDrawer/utils/sortByBalance.tsx

@@ -1,32 +0,0 @@
-import { BalanceUI } from "./type";
-
-export const parseFiatValue = (value?: string, discreet?: boolean) => {
-  if (!value || discreet) return -1;
-  return parseFloat(value.replace(/[^0-9.-]+/g, "")) || -1;
-};
-
-export function toFiatString(x?: BalanceUI): string | undefined {
-  return x && "fiatValue" in x ? String(x.fiatValue) : undefined;
-}
-
-export function hasBalance(balanceData?: BalanceUI): boolean {
-  return (
-    !!balanceData &&
-    (("fiatValue" in balanceData && !!balanceData.fiatValue) ||
-      ("balance" in balanceData && !!balanceData.balance))
-  );
-}
-
-export function compareByBalanceThenFiat(
-  a: BalanceUI | undefined,
-  b: BalanceUI | undefined,
-  discreet: boolean,
-): number {
-  const ah = hasBalance(a);
-  const bh = hasBalance(b);
-  if (ah && !bh) return -1;
-  if (!ah && bh) return 1;
-  const af = parseFiatValue(toFiatString(a), discreet);
-  const bf = parseFiatValue(toFiatString(b), discreet);
-  return bf - af;
-}