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

package/src/load/speculos.ts

@@ -28,6 +28,7 @@ export { closeAllSpeculosDevices, releaseSpeculosDevice, createSpeculosDevice };
 export type { SpeculosTransport };
 
 const modelMapPriority: Record<string, number> = {
+  stax: 5,
   nanos: 4,
   "nanos+": 3,
   nanox: 2,
@@ -128,6 +129,7 @@ export const findLatestAppCandidate = (
   appCandidates: AppCandidate[],
   search: AppSearch,
 ): AppCandidate | null => {
+  search.firmware = process.env.SPECULOS_FIRMWARE_VERSION;
   let apps = appCandidates.filter(c => appCandidatesMatches(c, search));
   if (apps.length === 0) {
     return null;

package/src/market/hooks/useLargeMoverChartData.ts

@@ -2,7 +2,6 @@ import { useQueries } from "@tanstack/react-query";
 import { fetchCurrencyChartData } from "../api";
 import { QUERY_KEY } from "../utils/queryKeys";
 import { REFETCH_TIME_ONE_MINUTE, BASIC_REFETCH } from "../utils/timers";
-import { MarketCoinDataChart } from "../utils/types";
 
 type UseLargeMoverChartDataParams = {
   ids: string[];
@@ -29,7 +28,7 @@ export const useLargeMoverChartData = ({
 
   const chartDataArray = ids.map((id, index) => ({
     idChartData: id,
-    chartData: chartQueries[index]?.data as MarketCoinDataChart | undefined,
+    chartData: chartQueries[index]?.data,
     isLoading: chartQueries[index]?.isLoading || false,
     isError: chartQueries[index]?.isError || false,
   }));

package/src/market/hooks/useLargeMoverCurrencies.ts

@@ -2,11 +2,8 @@ import { useQueries } from "@tanstack/react-query";
 import { fetchCurrency } from "../api";
 import { QUERY_KEY } from "../utils/queryKeys";
 import { REFETCH_TIME_ONE_MINUTE, BASIC_REFETCH } from "../utils/timers";
-import { MarketItemResponse, CurrencyData } from "../utils/types";
+import { MarketItemResponse } from "../utils/types";
 import { format } from "../utils/currencyFormatter";
-import { listCryptoCurrencies } from "@ledgerhq/cryptoassets/currencies";
-
-const cryptoCurrenciesList = [...listCryptoCurrencies()];
 
 type UseLargeMoverCurrenciesParams = {
   ids: string[];
@@ -23,13 +20,13 @@ export const useLargeMoverCurrencies = ({
       queryFn: () => fetchCurrency({ id, counterCurrency }),
       refetchInterval: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
       staleTime: REFETCH_TIME_ONE_MINUTE * BASIC_REFETCH,
-      select: (data: MarketItemResponse) => format(data, cryptoCurrenciesList),
+      select: (data: MarketItemResponse) => format(data),
     })),
   });
 
   return ids.map((id, index) => ({
     id,
-    data: currencyQueries[index]?.data as CurrencyData | undefined,
+    data: currencyQueries[index]?.data,
     isLoading: currencyQueries[index]?.isLoading || false,
     isError: currencyQueries[index]?.isError || false,
   }));

package/src/market/utils/currencyFormatter.ts

@@ -54,11 +54,11 @@ export function currencyFormatter(
 
 export const format = (
   currency: MarketItemResponse,
-  cryptoCurrenciesList: (CryptoCurrency | TokenCurrency)[],
+  cryptoCurrenciesList?: (CryptoCurrency | TokenCurrency)[],
 ): CurrencyData => {
   const ledgerIdsSet = new Set(currency.ledgerIds.map(id => id.toLowerCase()));
 
-  const internalCurrency = cryptoCurrenciesList.find(({ id }) =>
+  const internalCurrency = cryptoCurrenciesList?.find(({ id }) =>
     ledgerIdsSet.has(id.toLowerCase()),
   );
 

package/src/modularDrawer/hooks/__test__/useAssetAccountCounts.test.ts

@@ -0,0 +1,40 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { useNetworkAccountCounts } from "../useNetworkAccountCounts";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+
+const ethereumCurrency = createFixtureCryptoCurrency("ethereum");
+const ethereumAccountHigh = genAccount("ethereum-account-high", {
+  currency: ethereumCurrency,
+});
+
+describe("useNetworkAccountCounts", () => {
+  it("should return the count for one account", () => {
+    const assetAccountCounts = useNetworkAccountCounts({
+      networks: [ethereumCurrency],
+      nestedAccounts: [ethereumAccountHigh],
+      accountIds: new Map([[ethereumAccountHigh.id, true]]),
+      formatLabel: (count: number) => `${count}`,
+    });
+
+    expect(assetAccountCounts[0].count).toBe(1);
+    expect(assetAccountCounts[0].label).toBe("1");
+  });
+
+  it("should return the count for two accounts on ethereum", () => {
+    const ethereumAccountLow = genAccount("ethereum-account-low", {
+      currency: ethereumCurrency,
+    });
+    const assetAccountCounts = useNetworkAccountCounts({
+      networks: [ethereumCurrency],
+      nestedAccounts: [ethereumAccountHigh, ethereumAccountLow],
+      accountIds: new Map([
+        [ethereumAccountHigh.id, true],
+        [ethereumAccountLow.id, true],
+      ]),
+      formatLabel: (count: number) => `${count}`,
+    });
+
+    expect(assetAccountCounts[0].count).toBe(2);
+    expect(assetAccountCounts[0].label).toBe("2");
+  });
+});

package/src/modularDrawer/hooks/__test__/useCurrenciesUnderFeatureFlag.test.ts

@@ -0,0 +1,59 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useCurrenciesUnderFeatureFlag } from "../useCurrenciesUnderFeatureFlag";
+import { useFeature } from "../../../featureFlags";
+import useEnv from "../../../hooks/useEnv";
+
+jest.mock("../../../featureFlags", () => ({ useFeature: jest.fn() }));
+jest.mock("../../../hooks/useEnv", () => jest.fn());
+
+const mockUseFeature = jest.mocked(useFeature);
+const mockedEnvironment = jest.mocked(useEnv);
+
+describe("useCurrenciesUnderFeatureFlag", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return empty deactivatedCurrencyIds when all features are enabled", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: true });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toEqual(0);
+    expect(result.current.featureFlaggedCurrencies).toBeDefined();
+  });
+
+  it("should include disabled currencies in deactivatedCurrencyIds", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: false });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toBeGreaterThan(0);
+  });
+
+  it("should return empty deactivatedCurrencyIds when MOCK is true", () => {
+    mockedEnvironment.mockReturnValue(true);
+    mockUseFeature.mockReturnValue({ enabled: false });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    expect(result.current.deactivatedCurrencyIds.size).toBe(0);
+  });
+
+  it("should contain currency mappings", () => {
+    mockedEnvironment.mockReturnValue(false);
+    mockUseFeature.mockReturnValue({ enabled: true });
+
+    const { result } = renderHook(() => useCurrenciesUnderFeatureFlag());
+
+    const currencies = result.current.featureFlaggedCurrencies;
+    expect(currencies).toHaveProperty("aptos");
+    expect(currencies).toHaveProperty("stacks");
+    expect(currencies).toHaveProperty("optimism");
+  });
+});

package/src/modularDrawer/hooks/__tests__/useAcceptedCurrency.test.ts

@@ -0,0 +1,176 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useAcceptedCurrency } from "../useAcceptedCurrency";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { useCurrenciesUnderFeatureFlag } from "../useCurrenciesUnderFeatureFlag";
+import { isCurrencySupported } from "@ledgerhq/coin-framework/currencies/support";
+
+// Mock dependencies
+jest.mock("../useCurrenciesUnderFeatureFlag");
+jest.mock("@ledgerhq/coin-framework/currencies/support");
+
+const mockUseCurrenciesUnderFeatureFlag = useCurrenciesUnderFeatureFlag as jest.MockedFunction<
+  typeof useCurrenciesUnderFeatureFlag
+>;
+const mockIsCurrencySupported = isCurrencySupported as jest.MockedFunction<
+  typeof isCurrencySupported
+>;
+
+describe("useAcceptedCurrency", () => {
+  const mockCryptoCurrency: CryptoCurrency = {
+    id: "bitcoin",
+    name: "Bitcoin",
+    ticker: "BTC",
+    type: "CryptoCurrency",
+  } as CryptoCurrency;
+
+  const mockDeactivatedCurrency: CryptoCurrency = {
+    id: "ethereum",
+    name: "Ethereum",
+    ticker: "ETH",
+    type: "CryptoCurrency",
+  } as CryptoCurrency;
+
+  const mockTokenCurrency: TokenCurrency = {
+    id: "usdc",
+    name: "USD Coin",
+    ticker: "USDC",
+    type: "TokenCurrency",
+    parentCurrency: mockCryptoCurrency,
+  } as TokenCurrency;
+
+  const mockTokenWithDeactivatedParent: TokenCurrency = {
+    id: "weth",
+    name: "Wrapped Ethereum",
+    ticker: "WETH",
+    type: "TokenCurrency",
+    parentCurrency: mockDeactivatedCurrency,
+  } as TokenCurrency;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return true for a supported and non-deactivated currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockCryptoCurrency);
+
+    expect(isAccepted).toBe(true);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should return false for a deactivated currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["ethereum"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockDeactivatedCurrency);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockDeactivatedCurrency);
+  });
+
+  it("should return false for an unsupported currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(false);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockCryptoCurrency);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should return true for a token with an accepted parent currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockTokenCurrency);
+
+    expect(isAccepted).toBe(true);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should return false for a token with a deactivated parent currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["ethereum"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockTokenWithDeactivatedParent);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockDeactivatedCurrency);
+  });
+
+  it("should return false for a token with an unsupported parent currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(false);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockTokenCurrency);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should update when deactivatedCurrencyIds changes", () => {
+    const { result, rerender } = renderHook(() => useAcceptedCurrency());
+
+    // First render - currency is accepted
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+    rerender();
+    expect(result.current(mockCryptoCurrency)).toBe(true);
+
+    // Second render - currency is deactivated
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["bitcoin"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    rerender();
+    expect(result.current(mockCryptoCurrency)).toBe(false);
+  });
+
+  it("should handle multiple currencies in deactivated set", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["ethereum", "cardano", "polkadot"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+
+    // Bitcoin should be accepted (not in deactivated set)
+    expect(result.current(mockCryptoCurrency)).toBe(true);
+
+    // Ethereum should be rejected (in deactivated set)
+    expect(result.current(mockDeactivatedCurrency)).toBe(false);
+  });
+});

package/src/modularDrawer/hooks/index.ts

@@ -1 +1,2 @@
 export { useDetailedAccountsCore } from "./useDetailedAccountsCore";
+export { useAcceptedCurrency } from "./useAcceptedCurrency";

package/src/modularDrawer/hooks/useAcceptedCurrency.ts

@@ -0,0 +1,28 @@
+import { useCallback } from "react";
+import { CryptoCurrency, CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { isCurrencySupported } from "@ledgerhq/coin-framework/currencies/support";
+import { useCurrenciesUnderFeatureFlag } from "./useCurrenciesUnderFeatureFlag";
+
+/**
+ * Hook that returns a predicate function to check if a currency or token is accepted.
+ * A currency is accepted if:
+ * - It is supported by the platform (via isCurrencySupported)
+ * - It is not deactivated by a feature flag
+ *
+ * For tokens, the parent currency is checked instead.
+ */
+export function useAcceptedCurrency() {
+  const { deactivatedCurrencyIds } = useCurrenciesUnderFeatureFlag();
+
+  const isAcceptedCurrency = useCallback(
+    (currencyOrToken: CryptoOrTokenCurrency): boolean => {
+      const currency: CryptoCurrency =
+        currencyOrToken.type === "TokenCurrency" ? currencyOrToken.parentCurrency : currencyOrToken;
+
+      return isCurrencySupported(currency) && !deactivatedCurrencyIds.has(currency.id);
+    },
+    [deactivatedCurrencyIds],
+  );
+
+  return isAcceptedCurrency;
+}

package/src/modularDrawer/hooks/useLeftAccounts.tsx

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

package/src/modularDrawer/hooks/useLeftAccountsApy.tsx

@@ -5,15 +5,14 @@ import {
   NetworkWithCount,
 } from "../utils/type";
 import { useInterestRatesByCurrencies } from "../../dada-client/hooks/useInterestRatesByCurrencies";
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { getInterestRateForAsset } from "../utils/getInterestRateForAsset";
 
 export function useLeftAccountsApyModule(
   params: AccountModuleParams,
   useAccountData: (params: AccountModuleParams) => AccountDataItem[],
   accountsCountAndApy: CreateAccountsCountAndApy,
-  networks: CryptoOrTokenCurrency[],
-): NetworkWithCount[] {
+): Array<NetworkWithCount> {
+  const { networks } = params;
   const accountData = useAccountData(params);
   const interestRates = useInterestRatesByCurrencies(networks);
 
@@ -27,12 +26,10 @@ export function useLeftAccountsApyModule(
 
     if ((!interestRate || interestRatePercentageRounded <= 0) && count <= 0) {
       return {
-        ...asset,
         count,
       };
     }
     return {
-      ...asset,
       leftElement: accountsCountAndApy({
         label: count > 0 ? label : undefined,
         value: interestRatePercentageRounded,

package/src/modularDrawer/hooks/{useAssetAccountCounts.tsx → useNetworkAccountCounts.tsx}

@@ -5,26 +5,27 @@ import type { Account } from "@ledgerhq/types-live";
 import { WalletAPIAccount } from "../../wallet-api/types";
 
 type AccountModuleParams = {
-  assets: CryptoOrTokenCurrency[];
+  networks: CryptoOrTokenCurrency[];
   nestedAccounts: Account[];
   accountIds: Map<string, boolean> | undefined;
   formatLabel: (count: number) => string;
   accounts$?: Observable<WalletAPIAccount[]>;
 };
 
-export type AssetCountItem = {
+export type NetworkCountItem = {
   asset: CryptoOrTokenCurrency;
   label: string;
   count: number;
 };
 
-export const useAssetAccountCounts = ({
-  assets,
+export const useNetworkAccountCounts = ({
+  networks,
   nestedAccounts,
   accountIds,
   formatLabel,
-}: AccountModuleParams): AssetCountItem[] =>
-  assets.map(asset => {
+}: AccountModuleParams): NetworkCountItem[] =>
+  networks.map(network => {
+    const asset = network.type === "TokenCurrency" ? network.parentCurrency : network;
     const { length } = getAccountTuplesForCurrency(asset, nestedAccounts, accountIds);
     return {
       asset,

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,5 +1,5 @@
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
+import { UseBalanceDeps, CreateBalanceItem, BalanceUI } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 import BigNumber from "bignumber.js";
 
@@ -13,7 +13,10 @@ type Params = {
 };
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({ networks }: Params) {
+  return function useRightBalanceNetwork({ networks }: Params): Array<{
+    rightElement?: React.ReactNode;
+    balanceData?: BalanceUI;
+  }> {
     const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
     const networkBalanceData = getBalanceAndFiatValueByAssets(
@@ -34,7 +37,6 @@ export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: Ne
       };
 
       return {
-        ...currency,
         rightElement: balanceItem(balanceData),
         balanceData,
       };