@ledgerhq/live-common 34.50.0 → 34.51.0-nightly.0

package/src/modularDrawer/hooks/useCurrenciesUnderFeatureFlag.ts

@@ -0,0 +1,231 @@
+import { useMemo } from "react";
+import { CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
+import { Feature } from "@ledgerhq/types-live";
+import { useFeature } from "../../featureFlags";
+import useEnv from "../../hooks/useEnv";
+
+export function useCurrenciesUnderFeatureFlag() {
+  const mock = useEnv("MOCK");
+
+  const aptos = useFeature("currencyAptos");
+  const aptosTestnet = useFeature("currencyAptosTestnet");
+  const axelar = useFeature("currencyAxelar");
+  const stargaze = useFeature("currencyStargaze");
+  const secretNetwork = useFeature("currencySecretNetwork");
+  const umee = useFeature("currencyUmee");
+  const desmos = useFeature("currencyDesmos");
+  const dydx = useFeature("currencyDydx");
+  const onomy = useFeature("currencyOnomy");
+  const seiNetwork = useFeature("currencySeiNetwork");
+  const quicksilver = useFeature("currencyQuicksilver");
+  const persistence = useFeature("currencyPersistence");
+  const avaxCChain = useFeature("currencyAvalancheCChain");
+  const stacks = useFeature("currencyStacks");
+  const optimism = useFeature("currencyOptimism");
+  const optimismSepolia = useFeature("currencyOptimismSepolia");
+  const arbitrum = useFeature("currencyArbitrum");
+  const arbitrumSepolia = useFeature("currencyArbitrumSepolia");
+  const rsk = useFeature("currencyRsk");
+  const bittorrent = useFeature("currencyBittorrent");
+  const energyWeb = useFeature("currencyEnergyWeb");
+  const astar = useFeature("currencyAstar");
+  const metis = useFeature("currencyMetis");
+  const boba = useFeature("currencyBoba");
+  const moonriver = useFeature("currencyMoonriver");
+  const velasEvm = useFeature("currencyVelasEvm");
+  const syscoin = useFeature("currencySyscoin");
+  const internetComputer = useFeature("currencyInternetComputer");
+  const telosEvm = useFeature("currencyTelosEvm");
+  const coreum = useFeature("currencyCoreum");
+  const polygonZkEvm = useFeature("currencyPolygonZkEvm");
+  const polygonZkEvmTestnet = useFeature("currencyPolygonZkEvmTestnet");
+  const base = useFeature("currencyBase");
+  const baseSepolia = useFeature("currencyBaseSepolia");
+  const klaytn = useFeature("currencyKlaytn");
+  const injective = useFeature("currencyInjective");
+  const vechain = useFeature("currencyVechain");
+  const casper = useFeature("currencyCasper");
+  const neonEvm = useFeature("currencyNeonEvm");
+  const lukso = useFeature("currencyLukso");
+  const linea = useFeature("currencyLinea");
+  const lineaSepolia = useFeature("currencyLineaSepolia");
+  const blast = useFeature("currencyBlast");
+  const blastSepolia = useFeature("currencyBlastSepolia");
+  const scroll = useFeature("currencyScroll");
+  const scrollSepolia = useFeature("currencyScrollSepolia");
+  const icon = useFeature("currencyIcon");
+  const ton = useFeature("currencyTon");
+  const etherlink = useFeature("currencyEtherlink");
+  const zksync = useFeature("currencyZkSync");
+  const zksyncSepolia = useFeature("currencyZkSyncSepolia");
+  const mantra = useFeature("currencyMantra");
+  const xion = useFeature("currencyXion");
+  const zenrock = useFeature("currencyZenrock");
+  const sonic = useFeature("currencySonic");
+  const sonicBlaze = useFeature("currencySonicBlaze");
+  const sui = useFeature("currencySui");
+  const mina = useFeature("currencyMina");
+  const babylon = useFeature("currencyBabylon");
+  const seiNetworkEvm = useFeature("currencySeiNetworkEvm");
+  const berachain = useFeature("currencyBerachain");
+  const hyperevm = useFeature("currencyHyperevm");
+  const canton = useFeature("currencyCantonNetwork");
+  const kaspa = useFeature("currencyKaspa");
+  const core = useFeature("currencyCore");
+  const ethereumHoodi = useFeature("currencyEthereumHoodi");
+
+  const featureFlaggedCurrencies = useMemo(
+    (): Partial<Record<CryptoCurrencyId, Feature<unknown> | null>> => ({
+      aptos,
+      aptos_testnet: aptosTestnet,
+      axelar,
+      stargaze,
+      secret_network: secretNetwork,
+      umee,
+      desmos,
+      dydx,
+      onomy,
+      sei_network: seiNetwork,
+      quicksilver,
+      persistence,
+      avalanche_c_chain: avaxCChain,
+      stacks,
+      optimism,
+      optimism_sepolia: optimismSepolia,
+      arbitrum,
+      arbitrum_sepolia: arbitrumSepolia,
+      rsk,
+      bittorrent,
+      energy_web: energyWeb,
+      astar,
+      metis,
+      boba,
+      moonriver,
+      velas_evm: velasEvm,
+      syscoin,
+      internet_computer: internetComputer,
+      telos_evm: telosEvm,
+      sei_network_evm: seiNetworkEvm,
+      berachain: berachain,
+      hyperevm: hyperevm,
+      coreum,
+      polygon_zk_evm: polygonZkEvm,
+      polygon_zk_evm_testnet: polygonZkEvmTestnet,
+      base,
+      base_sepolia: baseSepolia,
+      klaytn,
+      injective,
+      vechain,
+      casper,
+      neon_evm: neonEvm,
+      lukso,
+      linea,
+      ton,
+      linea_sepolia: lineaSepolia,
+      blast,
+      blast_sepolia: blastSepolia,
+      scroll,
+      scroll_sepolia: scrollSepolia,
+      icon,
+      etherlink,
+      zksync,
+      zksync_sepolia: zksyncSepolia,
+      mantra,
+      xion,
+      zenrock,
+      sonic,
+      sonic_blaze: sonicBlaze,
+      sui,
+      mina,
+      babylon,
+      canton_network: canton,
+      kaspa,
+      core,
+      ethereum_hoodi: ethereumHoodi,
+    }),
+    [
+      aptos,
+      aptosTestnet,
+      axelar,
+      stargaze,
+      secretNetwork,
+      umee,
+      desmos,
+      dydx,
+      onomy,
+      seiNetwork,
+      quicksilver,
+      persistence,
+      avaxCChain,
+      stacks,
+      optimism,
+      optimismSepolia,
+      arbitrum,
+      arbitrumSepolia,
+      rsk,
+      bittorrent,
+      energyWeb,
+      astar,
+      metis,
+      boba,
+      moonriver,
+      velasEvm,
+      syscoin,
+      internetComputer,
+      telosEvm,
+      seiNetworkEvm,
+      berachain,
+      hyperevm,
+      coreum,
+      polygonZkEvm,
+      polygonZkEvmTestnet,
+      base,
+      baseSepolia,
+      klaytn,
+      injective,
+      vechain,
+      casper,
+      neonEvm,
+      lukso,
+      linea,
+      ton,
+      lineaSepolia,
+      blast,
+      blastSepolia,
+      scroll,
+      scrollSepolia,
+      icon,
+      etherlink,
+      zksync,
+      zksyncSepolia,
+      mantra,
+      xion,
+      zenrock,
+      sonic,
+      sonicBlaze,
+      sui,
+      mina,
+      babylon,
+      canton,
+      kaspa,
+      core,
+      ethereumHoodi,
+    ],
+  );
+
+  const deactivatedCurrencyIds = useMemo(
+    () =>
+      new Set(
+        mock
+          ? [] // mock mode: all currencies are available for playwrigth tests
+          : Object.entries(featureFlaggedCurrencies)
+              .filter(([, feature]) => !feature?.enabled)
+              .map(([id]) => id),
+      ),
+    [mock, featureFlaggedCurrencies],
+  );
+  return {
+    featureFlaggedCurrencies,
+    deactivatedCurrencyIds,
+  };
+}

package/src/modularDrawer/hooks/useLeftAccountsApy.tsx

@@ -4,7 +4,7 @@ import {
   CreateAccountsCountAndApy,
   NetworkWithCount,
 } from "../utils/type";
-import { useInterestRatesByCurrencies } from "../hooks/useInterestRatesByCurrencies";
+import { useInterestRatesByCurrencies } from "../../dada-client/hooks/useInterestRatesByCurrencies";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { getInterestRateForAsset } from "../utils/getInterestRateForAsset";
 

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -1,20 +1,14 @@
 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 type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 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 { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { calculateProviderTotals } from "../utils/calculateProviderTotal";
-import { getProviderCurrency } from "../utils/getProviderCurrency";
 import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
 
 export type AssetDeps = {
   useBalanceDeps: UseBalanceDeps;
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   assetsMap: Map<
     string,
     { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
@@ -26,120 +20,50 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
     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 {
+      currency: providerCurrency,
+      balance: totalBalance,
+      fiatValue: totalFiatValue.toNumber(),
+    };
   };
 
-  return function useRightBalanceAsset(
-    assets: CryptoOrTokenCurrency[],
-    currenciesByProvider: CurrenciesByProviderId[],
-  ) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+  return function useRightBalanceAsset(assets: CryptoOrTokenCurrency[]) {
+    const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
     const grouped = useMemo(
-      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency, discreet),
-      [flattenedAccounts, state, counterValueCurrency, discreet],
-    );
-
-    const providerMap = useMemo(
-      () => buildProviderCurrenciesMap(currenciesByProvider),
-      [currenciesByProvider],
+      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency),
+      [flattenedAccounts, state, counterValueCurrency],
     );
 
     return useMemo(() => {
-      if (!providerMap) {
-        const balanceMap = new Map();
-
-        for (const [, { currencies, mainCurrency }] of assetsMap) {
-          const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
-
-          const { balance, fiatValue } = formatProviderResult(
-            mainCurrency,
-            totalBalance,
-            totalFiatValue,
-            counterValueCurrency,
-            locale,
-            discreet,
-          );
-
-          balanceMap.set(mainCurrency.id, {
-            balance: balance,
-            fiatValue: fiatValue,
-          });
-        }
+      const balanceMap = new Map();
 
-        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(
+      for (const [, { currencies, mainCurrency }] of assetsMap) {
+        const { totalBalance, totalFiatValue, referenceCurrency } = calculateProviderTotals(
           currencies,
           grouped,
         );
-        if (!hasAccounts) continue;
 
-        const { balance, fiatValue } = formatProviderResult(
-          providerCurrency,
-          totalBalance,
-          totalFiatValue,
-          counterValueCurrency,
-          locale,
-          discreet,
-        );
-        providerResultsMap.set(mainCurrency.id, { balance, fiatValue });
+        // Use referenceCurrency from actual accounts if available, fallback to mainCurrency
+        const currencyToUse = referenceCurrency || mainCurrency;
+        const balanceData = formatProviderResult(currencyToUse, totalBalance, totalFiatValue);
+
+        balanceMap.set(mainCurrency.id, balanceData);
       }
 
       const assetsWithBalanceData = assets.map(asset => {
-        const balanceData = providerResultsMap.get(asset.id) || {};
+        const balanceData = balanceMap.get(asset.id) || {};
         return {
-          asset,
+          ...asset,
           balanceData,
+          rightElement: balanceItem(balanceData),
         };
       });
 
-      assetsWithBalanceData.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+      return assetsWithBalanceData.sort((a, b) =>
+        compareByBalanceThenFiat(a.balanceData, b.balanceData),
       );
-
-      return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-        ...asset,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [providerMap, assets, grouped, counterValueCurrency, locale, discreet]);
+    }, [assets, grouped]);
   };
 }

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,118 +1,37 @@
-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 { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 
 export type NetworkDeps = {
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   useBalanceDeps: UseBalanceDeps;
 };
 
 type Params = {
-  assets: CryptoOrTokenCurrency[];
   networks: CryptoOrTokenCurrency[];
-  selectedAssetId: string;
-  currenciesByProvider: CurrenciesByProviderId[];
 };
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({
-    assets: networks,
-    selectedAssetId,
-    currenciesByProvider,
-    networks: actualNetworks,
-  }: Params) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+  return function useRightBalanceNetwork({ networks }: Params) {
+    const { flattenedAccounts, state, counterValueCurrency } = 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,
-        actualNetworks,
-        state,
-        counterValueCurrency,
-        discreet,
-        locale,
-      );
-
-      const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
-
-      const networksWithBalance = actualNetworks.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,
+    const networkBalanceData = getBalanceAndFiatValueByAssets(
       flattenedAccounts,
+      networks,
       state,
       counterValueCurrency,
-      discreet,
-      locale,
-    ]);
+    );
+
+    const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
+
+    return networks.map(network => {
+      const balanceData = balanceMap.get(network.id) || {};
+      const details = network.type === "TokenCurrency" ? network.parentCurrency : network;
+      return {
+        ...details,
+        rightElement: balanceItem(balanceData),
+        balanceData: balanceData,
+      };
+    });
   };
 }

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -1,6 +1,5 @@
 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 { useLeftApyModule } from "../hooks/modules/useLeftApyModule";
 import { createUseRightBalanceAsset } from "../hooks/useRightBalanceAsset";
@@ -46,7 +45,7 @@ const getLeftElement =
 
 const createAssetConfigurationHook: CreateAssetConfigurationHook =
   deps =>
-  ({ assetsConfiguration, currenciesByProvider }) => {
+  ({ assetsConfiguration }) => {
     const { rightElement, leftElement } = assetsConfiguration ?? {};
 
     const rightHook = getRightElement(deps)(rightElement);
@@ -54,18 +53,11 @@ const createAssetConfigurationHook: CreateAssetConfigurationHook =
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const hooks = [rightHook, leftHook].filter(Boolean) as Array<
-      (
-        assets: CryptoOrTokenCurrency[],
-        currenciesByProvider?: CurrenciesByProviderId[],
-      ) => AssetType[]
+      (assets: CryptoOrTokenCurrency[]) => AssetType[]
     >;
 
     return (assets: CryptoOrTokenCurrency[]) => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(
-        ...hooks.map(
-          hook => (assets: CryptoOrTokenCurrency[]) => hook(assets, currenciesByProvider),
-        ),
-      );
+      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(...hooks);
       return composedHook(assets);
     };
   };

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -10,8 +10,10 @@ import {
   NetworkHook,
   RightElementKind,
   AccountModuleParams,
+  BalanceUI,
 } from "../utils/type";
 import { composeHooks } from "../../utils/composeHooks";
+import { compareByBalanceThenFiat } from "../utils/sortByBalance";
 
 export const getLeftElement =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
@@ -53,12 +55,7 @@ export const getRightElement =
 
 export const createNetworkConfigurationHook =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  ({
-    networksConfig,
-    selectedAssetId,
-    currenciesByProvider,
-    accounts$,
-  }: CreateNetworkConfigurationHookProps) => {
+  ({ networksConfig, accounts$ }: CreateNetworkConfigurationHookProps) => {
     const { leftElement, rightElement } = networksConfig ?? {};
     const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
     const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
@@ -70,18 +67,37 @@ export const createNetworkConfigurationHook =
       assets: CryptoOrTokenCurrency[],
       networks: CryptoOrTokenCurrency[],
     ): Array<CryptoOrTokenCurrency & Network> => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, Network>(
+      const composedHook = composeHooks<
+        CryptoOrTokenCurrency,
+        Network & { balanceData?: BalanceUI; count?: number }
+      >(
         ...hooks.map(
           hook => () =>
             hook({
               assets,
-              selectedAssetId,
-              currenciesByProvider: currenciesByProvider || [],
               accounts$,
               networks,
             }),
         ),
       );
-      return composedHook(assets);
+
+      const result = composedHook(assets);
+
+      if (
+        leftElement === "numberOfAccounts" ||
+        leftElement === "numberOfAccountsAndApy" ||
+        leftElement === undefined // default
+      ) {
+        result.sort((a, b) => (b?.count || 0) - (a?.count || 0));
+      }
+
+      if (
+        rightElement === "balance" ||
+        rightElement === undefined // default
+      ) {
+        result.sort((a, b) => compareByBalanceThenFiat(a?.balanceData, b?.balanceData));
+      }
+
+      return result;
     };
   };