@ledgerhq/live-common 34.46.0 → 34.47.0-nightly.1

package/src/modularDrawer/utils/counterValueFormatter.ts

@@ -0,0 +1,165 @@
+import { rangeDataTable } from "../../market/utils/rangeDataTable";
+import { TFunction } from "i18next";
+
+export const RANGES = Object.keys(rangeDataTable).filter(key => key !== "1h");
+
+const indexes: [string, number][] = [
+  ["d", 1],
+  ["K", 1000],
+  ["M", 1000000],
+  ["B", 1000000000],
+  ["T", 1000000000000],
+  ["Q", 1000000000000000],
+  ["Qn", 1000000000000000000],
+];
+
+const formatters: Record<string, { [key: string]: Intl.NumberFormat }> = {};
+
+const getSanitizedValue = (currency: string | undefined, locale: string): string => {
+  if (currency) {
+    return `${formatters[locale][currency]
+      ?.format(0)
+      .replace(/[0-9,.]+/, "***")
+      .trim()}`;
+  }
+  return "***";
+};
+
+const shouldReturnDash = (
+  value: number,
+  allowZeroValue: boolean,
+  discreetMode: boolean,
+): boolean => {
+  return !discreetMode && (isNaN(value) || (!value && !allowZeroValue));
+};
+
+const ensureFormatterExists = (
+  locale: string,
+  currency: string | undefined,
+  decimalPlaces: number,
+): void => {
+  if (!formatters[locale]) formatters[locale] = {};
+
+  if (currency && !formatters[locale]?.[currency]) {
+    createCurrencyFormatter(locale, currency, decimalPlaces);
+  } else if (!currency && !formatters[locale]?.[`decimal_${decimalPlaces}`]) {
+    createDecimalFormatter(locale, decimalPlaces);
+  }
+};
+
+const createCurrencyFormatter = (locale: string, currency: string, decimalPlaces: number): void => {
+  try {
+    formatters[locale][currency] = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency,
+    });
+  } catch {
+    formatters[locale][currency] = new Intl.NumberFormat(locale, {
+      style: "decimal",
+      minimumFractionDigits: decimalPlaces,
+      maximumFractionDigits: 8,
+    });
+  }
+};
+
+const createDecimalFormatter = (locale: string, decimalPlaces: number): void => {
+  formatters[locale][`decimal_${decimalPlaces}`] = new Intl.NumberFormat(locale, {
+    style: "decimal",
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces,
+  });
+};
+
+const getFormatter = (
+  currency: string | undefined,
+  locale: string,
+  shorten: boolean | undefined,
+  decimalPlaces: number,
+): Intl.NumberFormat | undefined => {
+  if (currency) {
+    return formatters[locale][currency];
+  }
+
+  if (shorten) {
+    return new Intl.NumberFormat(locale, {
+      notation: "compact",
+      maximumFractionDigits: 3,
+      minimumFractionDigits: Math.min(decimalPlaces, 3),
+    });
+  }
+
+  return formatters[locale][`decimal_${decimalPlaces}`];
+};
+
+const formatShortenedValue = (
+  value: number,
+  formatter: Intl.NumberFormat,
+  t: TFunction,
+): string => {
+  const sign = value > 0 ? "" : "-";
+  const v = Math.abs(value);
+  const index = Math.floor(Math.log10(v) / 3) || 0;
+  const [i, n] = indexes[index] || ["", 1];
+  const roundedValue = Math.round((v / n) * 1000) / 1000;
+  const number = formatter.format(roundedValue);
+  const I = t(`numberCompactNotation.${i}`);
+  const formattedNumber = number.replace(/([0-9,. ]+)/, `${sign}$1 ${I}`);
+  return formattedNumber.trim();
+};
+
+const formatRegularValue = (
+  value: number,
+  formatter: Intl.NumberFormat,
+  ticker: string,
+  currency: string | undefined,
+  locale: string,
+  discreetMode: boolean,
+): string => {
+  if (discreetMode) {
+    return getSanitizedValue(currency, locale);
+  }
+
+  const formattedValue = formatter.format(value);
+  const upperCaseTicker = ticker?.trim()?.toLocaleUpperCase();
+  return `${formattedValue} ${upperCaseTicker}`.trim();
+};
+
+export const counterValueFormatter = ({
+  currency,
+  value,
+  shorten,
+  locale,
+  t,
+  allowZeroValue = false,
+  ticker = "",
+  discreetMode = false,
+  decimalPlaces = 2,
+}: {
+  currency?: string;
+  value: number;
+  shorten?: boolean;
+  locale: string;
+  t?: TFunction;
+  allowZeroValue?: boolean;
+  ticker?: string;
+  discreetMode?: boolean;
+  decimalPlaces?: number;
+}): string => {
+  if (shouldReturnDash(value, allowZeroValue, discreetMode)) {
+    return "-";
+  }
+
+  ensureFormatterExists(locale, currency, decimalPlaces);
+
+  const formatter = getFormatter(currency, locale, shorten, decimalPlaces);
+
+  if (!formatter) {
+    return String(value);
+  }
+
+  if (shorten && t) {
+    return formatShortenedValue(value, formatter, t);
+  }
+
+  return formatRegularValue(value, formatter, ticker, currency, locale, discreetMode);
+};

package/src/modularDrawer/utils/getBalanceAndFiatValueByAssets.ts

@@ -0,0 +1,76 @@
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/lib-es/currencies/formatCurrencyUnit";
+import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
+import { groupAccountsByAsset, type GroupedAccount } from "./groupAccountsByAsset";
+import { AssetType } from "./type";
+import { AccountLike } from "@ledgerhq/types-live";
+import { counterValueFormatter } from "./counterValueFormatter";
+
+interface ExtendedAssetType extends AssetType {
+  balance?: string;
+  fiatValue?: string;
+}
+
+export const getBalanceAndFiatValueByAssets = (
+  accounts: AccountLike[],
+  assets: CryptoOrTokenCurrency[],
+  counterValuesState: CounterValuesState,
+  targetCurrency: Currency,
+  isDiscreetMode: boolean = false,
+  userLocale: string,
+): ExtendedAssetType[] => {
+  const groupedAccountsByAsset = groupAccountsByAsset(
+    accounts,
+    counterValuesState,
+    targetCurrency,
+    isDiscreetMode,
+  );
+
+  return assets.map(asset => {
+    const assetGroup = groupedAccountsByAsset[asset.id];
+
+    if (assetGroup) {
+      return formatAssetDetails(assetGroup, asset, targetCurrency, isDiscreetMode, userLocale);
+    }
+
+    return {
+      id: asset.id,
+      name: asset.name,
+      ticker: asset.ticker,
+    };
+  });
+};
+
+const formatAssetDetails = (
+  assetGroup: GroupedAccount,
+  asset: CryptoOrTokenCurrency,
+  targetCurrency: Currency,
+  isDiscreetMode: boolean,
+  userLocale: string,
+): ExtendedAssetType => {
+  const assetDetails =
+    assetGroup.accounts[0].type === "Account"
+      ? assetGroup.accounts[0].currency
+      : assetGroup.accounts[0].token;
+
+  const formattedBalance = formatCurrencyUnit(assetDetails.units[0], assetGroup.totalBalance, {
+    showCode: true,
+    discreet: isDiscreetMode,
+  });
+
+  const formattedFiatValue = counterValueFormatter({
+    currency: targetCurrency.ticker,
+    value: assetGroup.totalFiatValue.toNumber(),
+    locale: userLocale,
+    allowZeroValue: true,
+    discreetMode: isDiscreetMode,
+  });
+
+  return {
+    id: asset.id,
+    name: asset.name,
+    ticker: asset.ticker,
+    balance: formattedBalance,
+    fiatValue: formattedFiatValue,
+  };
+};

package/src/modularDrawer/utils/getProviderCurrency.ts

@@ -0,0 +1,13 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getTokenOrCryptoCurrencyById } from "../../deposit/helper";
+
+export const getProviderCurrency = (
+  mainCurrency: CryptoOrTokenCurrency,
+  currencies: CryptoOrTokenCurrency[],
+) => {
+  try {
+    return getTokenOrCryptoCurrencyById(mainCurrency.id);
+  } catch {
+    return getTokenOrCryptoCurrencyById(currencies[0].id);
+  }
+};

package/src/modularDrawer/utils/groupAccountsByAsset.ts

@@ -0,0 +1,51 @@
+import { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
+import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+import { Currency } from "@ledgerhq/types-cryptoassets";
+import { AccountLike } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { parseToBigNumber } from "./parseToBigNumber";
+
+export type GroupedAccount = {
+  totalBalance: BigNumber;
+  totalFiatValue: BigNumber;
+  accounts: AccountLike[];
+};
+
+export const groupAccountsByAsset = (
+  accounts: AccountLike[],
+  counterValuesState: CounterValuesState,
+  targetCurrency: Currency,
+  isDiscreetMode: boolean,
+): Record<string, GroupedAccount> => {
+  const initialGroupedAccounts: Record<string, GroupedAccount> = {};
+
+  return accounts.reduce((groupedAccounts, account) => {
+    const assetId = account.type === "Account" ? account.currency.id : account.token.id;
+
+    if (!groupedAccounts[assetId]) {
+      groupedAccounts[assetId] = {
+        totalBalance: new BigNumber(0),
+        totalFiatValue: new BigNumber(0),
+        accounts: [],
+      };
+    }
+
+    const { fiatValue } = getBalanceAndFiatValue(
+      account,
+      counterValuesState,
+      targetCurrency,
+      isDiscreetMode,
+      false,
+    );
+    const balance = account.balance;
+
+    const parsedFiatValue = parseToBigNumber(fiatValue ?? "0");
+
+    groupedAccounts[assetId].totalBalance = groupedAccounts[assetId].totalBalance.plus(balance);
+    groupedAccounts[assetId].totalFiatValue =
+      groupedAccounts[assetId].totalFiatValue.plus(parsedFiatValue);
+    groupedAccounts[assetId].accounts.push(account);
+
+    return groupedAccounts;
+  }, initialGroupedAccounts);
+};

package/src/modularDrawer/utils/parseToBigNumber.ts

@@ -0,0 +1,17 @@
+import BigNumber from "bignumber.js";
+
+/**
+ *
+ * @param value - The value to parse into a BigNumber. It can be a string, number, or an existing BigNumber instance.
+ * @template T - The type of the value, which can be string, number, or BigNumber.
+ * @returns  A BigNumber instance representing the parsed value.
+ */
+export const parseToBigNumber = <T extends string | number | BigNumber>(value: T): BigNumber => {
+  if (value instanceof BigNumber) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new BigNumber(value.replace(/,/g, ""));
+  }
+  return new BigNumber(value);
+};

package/src/modularDrawer/utils/type.ts

@@ -0,0 +1,22 @@
+export type AssetType = {
+  name: string;
+  ticker: string;
+  id: string;
+  leftElement?: React.ReactNode;
+  rightElement?: React.ReactNode;
+};
+
+export type ProviderBalanceAsset = {
+  id: string;
+  name: string;
+  ticker: string;
+  balance: string;
+  fiatValue: string;
+  sortValue: number;
+};
+
+export type ProviderBalanceResultsMap = Map<string, ProviderBalanceAsset>;
+
+export type AssetWithBalance = AssetType & {
+  sortValue?: number;
+};

package/src/utils/__tests__/getAccountTuplesForCurrency.test.ts

@@ -1,5 +1,5 @@
 import { getCryptoCurrencyById, getTokenById } from "@ledgerhq/cryptoassets";
-import { genAccount } from "@ledgerhq/live-common/mock/account";
+import { genAccount } from "../../mock/account";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Account, TokenAccount } from "@ledgerhq/types-live";
 import { getAccountTuplesForCurrency } from "../getAccountTuplesForCurrency";

package/src/wallet-api/Exchange/error.ts

@@ -24,6 +24,16 @@ export function createWrongSellParams(params: unknown): ExchangeErrorData {
   };
 }
 
+export function createWrongFundParams(params: unknown): ExchangeErrorData {
+  return {
+    code: "WRONG_FUND_PARAMS",
+    message: "fund params are not correctly set",
+    data: {
+      params,
+    },
+  };
+}
+
 export function createAccounIdNotFound(accountId: string): ExchangeErrorData {
   return {
     code: "ACCOUNT_ID_NOT_FOUND",

package/src/wallet-api/Exchange/server.test.ts

@@ -3,6 +3,7 @@ import {
   ExchangeStartParams,
   ExchangeStartSellParams,
   ExchangeStartSwapParams,
+  ExchangeStartFundParams,
 } from "@ledgerhq/wallet-api-exchange-module";
 import { WalletContext, WalletHandlers } from "@ledgerhq/wallet-api-server";
 import { of } from "rxjs";
@@ -153,8 +154,10 @@ describe("handlers", () => {
         uiHooks: mockUiHooks,
       });
 
-      const params: ExchangeStartParams = {
+      const params: ExchangeStartFundParams = {
         exchangeType: "FUND",
+        provider: "TestFundProvider",
+        fromAccountId: accounts[0].id,
       };
       const { request, context, walletHandlers } = prepareSellRequest(params);
 
@@ -170,6 +173,7 @@ describe("handlers", () => {
       expect(mockUiStartExchange).toHaveBeenCalledTimes(1);
       const receivedParams = mockUiStartExchange.mock.calls[0][0].exchangeParams;
       expect(receivedParams.exchangeType).toBe("FUND");
+      expect(receivedParams.provider).toBe("TestFundProvider");
       expect(mockUiCompleteExchange).not.toHaveBeenCalled();
     });
   });

package/src/wallet-api/Exchange/server.ts

@@ -22,6 +22,7 @@ import {
   ExchangeStartResult,
   ExchangeStartSellParams,
   ExchangeStartSwapParams,
+  ExchangeStartFundParams,
   ExchangeSwapParams,
   ExchangeType,
   SwapLiveError,
@@ -44,6 +45,7 @@ import {
   createAccounIdNotFound,
   createWrongSellParams,
   createWrongSwapParams,
+  createWrongFundParams,
   ExchangeError,
 } from "./error";
 import { TrackingAPI } from "./tracking";
@@ -82,6 +84,8 @@ export type CompleteExchangeUiRequest = {
 };
 type FundStartParamsUiRequest = {
   exchangeType: "FUND";
+  provider: string;
+  exchange: Partial<Exchange> | undefined;
 };
 
 type SellStartParamsUiRequest = {
@@ -158,8 +162,6 @@ export const handlers = ({
         }
 
         const trackingParams = {
-          // @ts-expect-error ExchangeStartFundParams does not yet have the provider. Will be added in another iteration after a bugfix is confirmed
-          // TODO: expect-error to be deleted after
           provider: params.provider,
           exchangeType: params.exchangeType,
         };
@@ -174,9 +176,7 @@ export const handlers = ({
         } else if (params.exchangeType == "SELL") {
           exchangeParams = extractSellStartParam(params, accounts);
         } else {
-          exchangeParams = {
-            exchangeType: params.exchangeType,
-          };
+          exchangeParams = extractFundStartParam(params, accounts);
         }
 
         return new Promise((resolve, reject) =>
@@ -711,6 +711,45 @@ function extractSellStartParam(
   };
 }
 
+function extractFundStartParam(
+  params: ExchangeStartFundParams,
+  accounts: AccountLike[],
+): ExchangeStartParamsUiRequest {
+  if (!("provider" in params)) {
+    throw new ExchangeError(createWrongFundParams(params));
+  }
+
+  if (!params.fromAccountId) {
+    return {
+      exchangeType: params.exchangeType,
+      provider: params.provider,
+    } as ExchangeStartParamsUiRequest;
+  }
+
+  const realFromAccountId = getAccountIdFromWalletAccountId(params?.fromAccountId);
+
+  if (!realFromAccountId) {
+    throw new ExchangeError(createAccounIdNotFound(params.fromAccountId));
+  }
+
+  const fromAccount = accounts?.find(acc => acc.id === realFromAccountId);
+
+  if (!fromAccount) {
+    throw new ServerError(createAccountNotFound(params.fromAccountId));
+  }
+
+  const fromParentAccount = getParentAccount(fromAccount, accounts);
+
+  return {
+    exchangeType: params.exchangeType,
+    provider: params.provider,
+    exchange: {
+      fromAccount,
+      fromParentAccount,
+    },
+  };
+}
+
 async function getToCurrency(
   binaryPayload: string,
   toAccount: AccountLike,