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

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

@@ -0,0 +1,472 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useDetailedAccountsCore } from "../useDetailedAccountsCore";
+import { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+import { Currency } from "@ledgerhq/types-cryptoassets";
+import { Account, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+// Mock the calculate function
+jest.mock("@ledgerhq/live-countervalues/logic", () => ({
+  calculate: jest.fn(),
+}));
+
+// Mock the derivation function
+jest.mock("@ledgerhq/coin-framework/derivation", () => ({
+  getTagDerivationMode: jest.fn(() => "native_segwit"),
+}));
+
+// Import the mocked functions
+import { calculate } from "@ledgerhq/live-countervalues/logic";
+import { getTagDerivationMode } from "@ledgerhq/coin-framework/derivation";
+const mockCalculate = calculate as jest.MockedFunction<typeof calculate>;
+const mockGetTagDerivationMode = getTagDerivationMode as jest.MockedFunction<
+  typeof getTagDerivationMode
+>;
+
+describe("useDetailedAccountsCore", () => {
+  const mockCounterValuesState = {} as CounterValuesState;
+  const mockCounterValueCurrency = {
+    id: "usd",
+    ticker: "USD",
+    units: [{ name: "USD", code: "USD", magnitude: 2 }],
+  } as Currency;
+
+  const mockAccount = {
+    id: "account1",
+    type: "Account",
+    currency: {
+      id: "ethereum",
+      ticker: "ETH",
+      name: "Ethereum",
+      units: [{ name: "Ethereum", code: "ETH", magnitude: 18 }],
+    },
+    balance: new BigNumber("1000000000000000000"), // 1 ETH
+    freshAddress: "0x123...abc",
+    derivationMode: "ethM",
+  } as Account;
+
+  const mockTokenAccount = {
+    id: "token1",
+    type: "TokenAccount",
+    parentId: "account1",
+    token: {
+      id: "usdc",
+      ticker: "USDC",
+      name: "USD Coin",
+      units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
+      parentCurrency: mockAccount.currency,
+    },
+    balance: new BigNumber("1000000"), // 1 USDC
+  } as TokenAccount;
+
+  beforeEach(() => {
+    mockCalculate.mockClear();
+  });
+
+  it("should calculate fiat value correctly", () => {
+    mockCalculate.mockReturnValue(2500); // Mock fiat value
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const fiatValue = result.current.calculateFiatValue(mockAccount);
+
+    expect(mockCalculate).toHaveBeenCalledWith(mockCounterValuesState, {
+      from: mockAccount.currency,
+      to: mockCounterValueCurrency,
+      value: mockAccount.balance.toNumber(),
+    });
+    expect(fiatValue).toBe(2500);
+  });
+
+  it("should return 0 when mockCalculate returns null", () => {
+    mockCalculate.mockReturnValue(null);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const fiatValue = result.current.calculateFiatValue(mockAccount);
+    expect(fiatValue).toBe(0);
+  });
+
+  it("should create base detailed accounts for regular accounts", () => {
+    mockCalculate.mockReturnValue(2500);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: null }];
+    const accountNameMap = { account1: "My Ethereum Account" };
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts).toHaveLength(1);
+    expect(detailedAccounts[0]).toEqual({
+      id: "account1",
+      name: "My Ethereum Account",
+      ticker: "ETH",
+      balance: mockAccount.balance,
+      balanceUnit: mockAccount.currency.units[0],
+      fiatValue: 2500,
+      address: "0x123...abc",
+      cryptoId: "ethereum",
+    });
+  });
+
+  it("should create base detailed accounts for token accounts", () => {
+    mockCalculate.mockReturnValue(1); // 1 USD for USDC
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: mockTokenAccount }];
+    const accountNameMap = { account1: "My Ethereum Account" };
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockTokenAccount.token,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: true,
+    });
+
+    expect(detailedAccounts).toHaveLength(1);
+    expect(detailedAccounts[0]).toEqual({
+      id: "token1",
+      name: "My Ethereum Account",
+      ticker: "USDC",
+      balance: mockTokenAccount.balance,
+      balanceUnit: mockTokenAccount.token.units[0],
+      fiatValue: 1,
+      address: "0x123...abc",
+      cryptoId: "usdc",
+      parentId: "ethereum",
+    });
+  });
+
+  it("should create extended detailed accounts with account references", () => {
+    mockCalculate.mockReturnValue(2500);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: null }];
+    const accountNameMap = { account1: "My Ethereum Account" };
+
+    const detailedAccounts = result.current.createExtendedDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts).toHaveLength(1);
+    expect(detailedAccounts[0]).toEqual({
+      id: "account1",
+      name: "My Ethereum Account",
+      ticker: "ETH",
+      balance: mockAccount.balance,
+      balanceUnit: mockAccount.currency.units[0],
+      fiatValue: 2500,
+      address: "0x123...abc",
+      cryptoId: "ethereum",
+      account: mockAccount,
+      protocol: "native_segwit",
+    });
+  });
+
+  it("should sort accounts by fiat value in descending order", () => {
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const mockAccount2 = { ...mockAccount, id: "account2" };
+
+    // Mock different fiat values for different accounts
+    mockCalculate
+      .mockReturnValueOnce(1000) // First account
+      .mockReturnValueOnce(5000); // Second account
+
+    const accountTuples = [
+      { account: mockAccount, subAccount: null },
+      { account: mockAccount2, subAccount: null },
+    ];
+    const accountNameMap = {
+      account1: "Account 1",
+      account2: "Account 2",
+    };
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts).toHaveLength(2);
+    expect(detailedAccounts[0].id).toBe("account2"); // Higher fiat value (5000)
+    expect(detailedAccounts[1].id).toBe("account1"); // Lower fiat value (1000)
+  });
+
+  it("should use fallback name when account name is not in map", () => {
+    mockCalculate.mockReturnValue(2500);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: null }];
+    const accountNameMap = {}; // Empty map
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts[0].name).toBe("Ethereum"); // Falls back to currency name
+  });
+
+  it("should handle token accounts with extended detailed accounts", () => {
+    mockCalculate.mockReturnValue(1); // 1 USD for USDC
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: mockTokenAccount }];
+    const accountNameMap = { account1: "My Ethereum Account" };
+
+    const detailedAccounts = result.current.createExtendedDetailedAccounts({
+      asset: mockTokenAccount.token,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: true,
+    });
+
+    expect(detailedAccounts).toHaveLength(1);
+    expect(detailedAccounts[0]).toEqual({
+      id: "token1",
+      name: "My Ethereum Account",
+      ticker: "USDC",
+      balance: mockTokenAccount.balance,
+      balanceUnit: mockTokenAccount.token.units[0],
+      fiatValue: 1,
+      address: "0x123...abc",
+      cryptoId: "usdc",
+      parentId: "ethereum",
+      account: mockTokenAccount,
+      parentAccount: mockAccount,
+    });
+  });
+
+  it("should handle multiple accounts with mixed fiat values including zero", () => {
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const mockAccount2 = { ...mockAccount, id: "account2" };
+    const mockAccount3 = { ...mockAccount, id: "account3" };
+
+    // Mock different fiat values including zero
+    mockCalculate
+      .mockReturnValueOnce(0) // First account - zero value
+      .mockReturnValueOnce(5000) // Second account - high value
+      .mockReturnValueOnce(100); // Third account - low value
+
+    const accountTuples = [
+      { account: mockAccount, subAccount: null },
+      { account: mockAccount2, subAccount: null },
+      { account: mockAccount3, subAccount: null },
+    ];
+    const accountNameMap = {
+      account1: "Account 1",
+      account2: "Account 2",
+      account3: "Account 3",
+    };
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts).toHaveLength(3);
+    // Should be sorted by fiat value descending: 5000, 100, 0
+    expect(detailedAccounts[0].id).toBe("account2"); // 5000
+    expect(detailedAccounts[1].id).toBe("account3"); // 100
+    expect(detailedAccounts[2].id).toBe("account1"); // 0
+    expect(detailedAccounts[2].fiatValue).toBe(0);
+  });
+
+  it("should handle token account fiat value calculation correctly", () => {
+    mockCalculate.mockReturnValue(50); // Mock fiat value for token
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const fiatValue = result.current.calculateFiatValue(mockTokenAccount);
+
+    expect(mockCalculate).toHaveBeenCalledWith(mockCounterValuesState, {
+      from: mockTokenAccount.token,
+      to: mockCounterValueCurrency,
+      value: mockTokenAccount.balance.toNumber(),
+    });
+    expect(fiatValue).toBe(50);
+  });
+
+  it("should handle empty account tuples", () => {
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples: Array<{ account: Account; subAccount: TokenAccount | null }> = [];
+    const accountNameMap = {};
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts).toHaveLength(0);
+  });
+
+  it("should handle accounts with undefined fiat values", () => {
+    mockCalculate.mockReturnValue(undefined); // Simulate undefined return
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const fiatValue = result.current.calculateFiatValue(mockAccount);
+    expect(fiatValue).toBe(0); // Should default to 0
+  });
+
+  it("should preserve account properties in extended detailed accounts", () => {
+    mockCalculate.mockReturnValue(1500);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: null }];
+    const accountNameMap = { account1: "Custom Account Name" };
+
+    const detailedAccounts = result.current.createExtendedDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts[0].account).toBe(mockAccount);
+    expect(detailedAccounts[0].protocol).toBe("native_segwit");
+    expect(detailedAccounts[0].parentAccount).toBeUndefined();
+  });
+
+  it("should use fallback name when parent account name is not in map for token accounts", () => {
+    mockCalculate.mockReturnValue(1);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: mockTokenAccount }];
+    const accountNameMap = {}; // Empty map - no parent account name
+
+    const detailedAccounts = result.current.createBaseDetailedAccounts({
+      asset: mockTokenAccount.token,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: true,
+    });
+
+    expect(detailedAccounts[0].name).toBe("USD Coin"); // Falls back to token name
+  });
+
+  it("should use fallback name when parent account name is not in map for extended token accounts", () => {
+    mockCalculate.mockReturnValue(1);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: mockTokenAccount }];
+    const accountNameMap = {}; // Empty map - no parent account name
+
+    const detailedAccounts = result.current.createExtendedDetailedAccounts({
+      asset: mockTokenAccount.token,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: true,
+    });
+
+    expect(detailedAccounts[0].name).toBe("USD Coin"); // Falls back to token name
+    expect(detailedAccounts[0].account).toBe(mockTokenAccount);
+    expect(detailedAccounts[0].parentAccount).toBe(mockAccount);
+  });
+
+  it("should handle null derivation mode in extended detailed accounts", () => {
+    // Mock getTagDerivationMode to return null
+    mockGetTagDerivationMode.mockReturnValue(null);
+
+    mockCalculate.mockReturnValue(2500);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: null }];
+    const accountNameMap = { account1: "My Account" };
+
+    const detailedAccounts = result.current.createExtendedDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts[0].protocol).toBe(""); // Should fallback to empty string
+
+    // Reset mock for other tests
+    mockGetTagDerivationMode.mockReturnValue("native_segwit");
+  });
+
+  it("should use fallback name when account name is not in map for extended accounts", () => {
+    mockCalculate.mockReturnValue(2500);
+
+    const { result } = renderHook(() =>
+      useDetailedAccountsCore(mockCounterValuesState, mockCounterValueCurrency),
+    );
+
+    const accountTuples = [{ account: mockAccount, subAccount: null }];
+    const accountNameMap = {}; // Empty map - no account name
+
+    const detailedAccounts = result.current.createExtendedDetailedAccounts({
+      asset: mockAccount.currency,
+      accountTuples,
+      accountNameMap,
+      isTokenCurrency: false,
+    });
+
+    expect(detailedAccounts[0].name).toBe("Ethereum"); // Falls back to currency name
+    expect(detailedAccounts[0].account).toBe(mockAccount);
+  });
+});

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

@@ -0,0 +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;
+}