@ledgerhq/live-common 34.51.0-nightly.9 → 34.51.0

package/src/e2e/speculosAppVersion.ts

@@ -1,86 +0,0 @@
-import { HttpManagerApiRepository, ApplicationV2Entity } from "@ledgerhq/device-core";
-import { version } from "@ledgerhq/device-core/package.json";
-import { getEnv } from "@ledgerhq/live-env";
-import { DeviceModelId } from "@ledgerhq/devices";
-import { Device as CryptoWallet } from "./enum/Device";
-import * as fs from "fs";
-import * as path from "path";
-
-export function getSpeculosModel(): DeviceModelId {
-  const speculosDevice = process.env.SPECULOS_DEVICE;
-  switch (speculosDevice) {
-    case CryptoWallet.LNS.name:
-      return DeviceModelId.nanoS;
-    case CryptoWallet.LNX.name:
-      return DeviceModelId.nanoX;
-    case CryptoWallet.LNSP.name:
-    default:
-      return DeviceModelId.nanoSP;
-  }
-}
-
-function getDeviceTargetId(device: DeviceModelId): number {
-  const modelToTargetIdMap = {
-    [DeviceModelId.nanoS]: CryptoWallet.LNS.targetId,
-    [DeviceModelId.nanoX]: CryptoWallet.LNX.targetId,
-    [DeviceModelId.nanoSP]: CryptoWallet.LNSP.targetId,
-  };
-  return modelToTargetIdMap[device];
-}
-
-export async function getNanoAppCatalog(
-  device: DeviceModelId,
-  deviceFirmware: string,
-): Promise<ApplicationV2Entity[]> {
-  const repository = new HttpManagerApiRepository(getEnv("MANAGER_API_BASE"), version);
-  const targetId = getDeviceTargetId(device);
-  return await repository.catalogForDevice({
-    provider: 1,
-    targetId: targetId,
-    firmwareVersion: deviceFirmware,
-  });
-}
-
-function getDeviceFirmwareVersion(): string {
-  const firmwareVersion = process.env.SPECULOS_FIRMWARE_VERSION;
-  if (!firmwareVersion) {
-    throw new Error("SPECULOS_FIRMWARE_VERSION environment variable is not set");
-  }
-  return firmwareVersion;
-}
-
-export async function createNanoAppJsonFile(nanoAppFilePath: string): Promise<void> {
-  try {
-    const device = getSpeculosModel();
-    const firmware = getDeviceFirmwareVersion();
-    const appCatalog = await getNanoAppCatalog(device, firmware);
-    const jsonFilePath = path.join(process.cwd(), nanoAppFilePath);
-    const dirPath = path.dirname(jsonFilePath);
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
-    }
-    fs.writeFileSync(jsonFilePath, JSON.stringify(appCatalog, null, 2), "utf8");
-  } catch (error) {
-    console.error("Unable to create app version file:", error);
-  }
-}
-
-export async function getAppVersionFromCatalog(
-  currency: string,
-  nanoAppFilePath: string,
-): Promise<string | undefined> {
-  try {
-    await createNanoAppJsonFile(nanoAppFilePath);
-    const rootDir = process.cwd();
-    const jsonFilePath = path.join(rootDir, nanoAppFilePath);
-    type CatalogApp = { versionDisplayName: string; version: string };
-    const raw = fs.readFileSync(jsonFilePath, "utf8");
-    const catalog: CatalogApp[] = JSON.parse(raw);
-
-    const app = catalog.find(entry => entry.versionDisplayName === currency);
-
-    return app?.version ?? "";
-  } catch (error) {
-    console.error(`Unable to get app version for ${currency} from catalog:`, error);
-  }
-}

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

@@ -1,40 +0,0 @@
-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

@@ -1,59 +0,0 @@
-/**
- * @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

@@ -1,176 +0,0 @@
-/**
- * @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/useAcceptedCurrency.ts

@@ -1,28 +0,0 @@
-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/modules/__test__/createAssetConfiguration.test.tsx

@@ -1,250 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import React from "react";
-import { renderHook } from "@testing-library/react";
-import { mockEthCryptoCurrency } from "../../__mocks__/currencies.mock";
-import { groupCurrenciesByProvider } from "../../utils";
-import createAssetConfigurationHook from "../createAssetConfiguration";
-import { BigNumber } from "bignumber.js";
-import { genAccount, genTokenAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
-import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
-import { CounterValuesState } from "@ledgerhq/live-countervalues/lib/types";
-import { CryptoCurrency, FiatCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { Provider } from "react-redux";
-import { configureStore } from "@reduxjs/toolkit";
-
-export const makeUsdcToken = (
-  parentCurrency: CryptoCurrency,
-  contractAddress: string,
-  tokenType: string = "erc20",
-  name: string = "USD Coin",
-  explicitId?: string,
-) => {
-  const id = explicitId ?? `${parentCurrency.id}/${tokenType}/usdc`;
-  return {
-    type: "TokenCurrency" as const,
-    parentCurrency,
-    tokenType,
-    id,
-    contractAddress,
-    ticker: "USDC",
-    name,
-    units: [
-      {
-        name: "USD Coin",
-        code: "USDC",
-        magnitude: 6,
-      },
-    ],
-  };
-};
-
-const ApyIndicator = () => null;
-const MarketPercentIndicator = () => null;
-const MarketPriceIndicator = jest.fn(() => null);
-
-const ethereumCurrencyMagnitude = 18;
-const fiatCurrencyMagnitude = 2;
-const fiatConversion = 4589;
-
-const ethereumCurrency = createFixtureCryptoCurrency("ethereum");
-ethereumCurrency.id = "ethereum";
-ethereumCurrency.units[0].magnitude = ethereumCurrencyMagnitude;
-const ethereumAccountHigh = genAccount("ethereum-account-high", {
-  currency: ethereumCurrency,
-});
-
-ethereumAccountHigh.balance = new BigNumber("1000000000000000000000");
-ethereumAccountHigh.spendableBalance = ethereumAccountHigh.balance;
-
-const ethereumUsdcToken: TokenCurrency = makeUsdcToken(ethereumCurrency, "erc20", "USD Coin");
-const ethereumUsdcTokenAccount = genTokenAccount(0, ethereumAccountHigh, ethereumUsdcToken);
-ethereumUsdcTokenAccount.balance = new BigNumber("1000000000");
-ethereumAccountHigh.subAccounts = [ethereumUsdcTokenAccount];
-
-const mockFiatCurrency: FiatCurrency = {
-  type: "FiatCurrency",
-  ticker: "USD",
-  name: "US Dollar",
-  symbol: "$",
-  units: [
-    {
-      code: "$",
-      name: "US Dollar",
-      magnitude: fiatCurrencyMagnitude,
-      showAllDigits: true,
-      prefixCode: true,
-    },
-  ],
-};
-
-const useBalanceDeps = () => {
-  const mockCounterValuesState: CounterValuesState = {
-    cache: {
-      "USD ethereum": {
-        map: new Map([["latest", fiatConversion]]),
-        stats: {
-          oldest: "2024-09-12",
-          earliest: "2025-10-02T13",
-          oldestDate: new Date(),
-          earliestDate: new Date(),
-          earliestStableDate: new Date(),
-        },
-      },
-    },
-    data: {},
-    status: {},
-  };
-
-  return {
-    counterValueCurrency: mockFiatCurrency,
-    flattenedAccounts: [ethereumAccountHigh],
-    state: mockCounterValuesState,
-    locale: "en-US",
-  };
-};
-
-const balanceItem = jest.fn(() => null);
-
-const assetConfigurationDeps = {
-  useBalanceDeps,
-  balanceItem,
-  ApyIndicator,
-  MarketPercentIndicator,
-  MarketPriceIndicator,
-  assetsMap: groupCurrenciesByProvider([
-    {
-      asset: {
-        id: "ethereum",
-        ticker: "ETH",
-        name: "Ethereum",
-        assetsIds: {
-          ethereum: "ethereum",
-          arbitrum: "arbitrum",
-        },
-        metaCurrencyId: "ethereum",
-      },
-      networks: [mockEthCryptoCurrency],
-    },
-  ]),
-};
-
-describe("createAssetConfiguration", () => {
-  it("should call balanceItem with correct BalanceUI objects for each asset", () => {
-    renderHook(() =>
-      createAssetConfigurationHook(assetConfigurationDeps)({
-        assetsConfiguration: { rightElement: "balance" },
-      })([ethereumCurrency]),
-    );
-
-    expect(balanceItem).toHaveBeenCalledTimes(1);
-    expect(balanceItem).toHaveBeenNthCalledWith(1, {
-      currency: ethereumCurrency,
-      balance: ethereumAccountHigh.balance,
-      fiatValue: ethereumAccountHigh.balance
-        .shiftedBy(fiatCurrencyMagnitude - ethereumCurrencyMagnitude)
-        .multipliedBy(fiatConversion)
-        .toNumber(),
-    });
-  });
-
-  const store = configureStore({
-    reducer: {
-      assetsDataApi: (state = {}, _action) => state,
-    },
-    preloadedState: {
-      assetsDataApi: {
-        queries: {
-          mockMarketsQuery: {
-            data: {
-              pages: [
-                {
-                  markets: {
-                    ethereum: {
-                      price: 2500.5,
-                      priceChangePercentage24h: 5.25,
-                      marketCap: 300000000000,
-                      ticker: "ETH",
-                      name: "Ethereum",
-                    },
-                  },
-                  interestRates: {
-                    ethereum: {
-                      currencyId: "ethereum",
-                      rate: 0.045,
-                      type: "APY",
-                      fetchAt: "2024-10-13T10:00:00Z",
-                    },
-                  },
-                },
-              ],
-            },
-          },
-        },
-      },
-    },
-  });
-
-  it("should generate market trend right element with correct market trend data", () => {
-    const {
-      result: { current },
-    } = renderHook(
-      () =>
-        createAssetConfigurationHook(assetConfigurationDeps)({
-          assetsConfiguration: { rightElement: "marketTrend" },
-        })([ethereumCurrency]),
-      {
-        wrapper: ({ children }) => <Provider store={store}>{children}</Provider>,
-      },
-    );
-
-    const rightElement = current[0]?.rightElement;
-    expect(rightElement).toBeDefined();
-    expect(React.isValidElement(rightElement)).toBe(true);
-    if (React.isValidElement(rightElement)) {
-      expect(rightElement.props).toEqual({
-        percent: 5.25,
-        price: "$2,500.50",
-      });
-    }
-  });
-
-  it("should generate apy left element when leftElement is 'apy'", () => {
-    const {
-      result: { current },
-    } = renderHook(
-      () =>
-        createAssetConfigurationHook(assetConfigurationDeps)({
-          assetsConfiguration: { leftElement: "apy" },
-        })([ethereumCurrency]),
-      {
-        wrapper: ({ children }) => <Provider store={store}>{children}</Provider>,
-      },
-    );
-
-    expect((current[0]?.leftElement as React.ReactElement).props).toEqual({
-      value: 4.5,
-      type: "APY",
-    });
-  });
-
-  it("should generate market trend left element when leftElement is 'marketTrend'", () => {
-    const {
-      result: { current },
-    } = renderHook(
-      () =>
-        createAssetConfigurationHook(assetConfigurationDeps)({
-          assetsConfiguration: { leftElement: "marketTrend" },
-        })([ethereumCurrency]),
-      {
-        wrapper: ({ children }) => <Provider store={store}>{children}</Provider>,
-      },
-    );
-
-    expect((current[0]?.leftElement as React.ReactElement).props).toEqual({
-      percent: 5.25,
-    });
-  });
-});