fix(settings): list hidden native coins in accounts settings

Author: mcayuelas-ledger

.changeset/wild-donkeys-hunt.md

@@ -0,0 +1,7 @@
+---
+"@ledgerhq/live-common": minor
+"ledger-live-desktop": minor
+"live-mobile": minor
+---
+
+Fix hidden assets not appearing in Settings > Accounts. Native coins hidden from the asset detail page are now resolved from the crypto registry and listed alongside hidden tokens, and a single failing token lookup no longer empties the whole list.

apps/ledger-live-desktop/src/renderer/screens/settings/sections/Accounts/BlacklistedTokens.test.tsx

@@ -67,7 +67,7 @@ describe("BlacklistedTokens", () => {
 
     expect(screen.getByText("Hidden tokens")).toBeInTheDocument();
     expect(
-      screen.getByText(/You can hide tokens by going to the parent account then right-clicking/i),
+      screen.getByText(/You can hide an asset from its detail page using the options menu/i),
     ).toBeInTheDocument();
     // When there are no blacklisted tokens, the count should not be displayed
     expect(screen.queryByText(/\d+ token/)).not.toBeInTheDocument();
@@ -153,13 +153,61 @@ describe("BlacklistedTokens", () => {
     expect(mockFindTokenById).toHaveBeenCalledWith("ethereum/erc20/usdt");
   });
 
-  it("handles async loading errors gracefully", async () => {
-    mockFindTokenById.mockRejectedValue(new Error("Token not found"));
+  it("renders a native coin row resolved from the registry without a CAL lookup", async () => {
+    render(<BlacklistedTokens />, {
+      initialState: { settings: { blacklistedTokenIds: ["bitcoin"] } },
+    });
+
+    // Native coins are resolved from the crypto registry, not via CAL
+    expect(mockFindTokenById).not.toHaveBeenCalled();
+
+    await waitFor(() => {
+      expect(screen.getByText("1 token")).toBeInTheDocument();
+    });
+
+    // Toggle visibility to reveal the Bitcoin row
+    fireEvent.click(screen.getByText("1 token"));
+
+    await waitFor(() => {
+      expect(screen.getAllByText("Bitcoin").length).toBeGreaterThan(0);
+    });
+  });
+
+  it("isolates a failing token lookup without discarding the rest of the list", async () => {
+    mockFindTokenById.mockImplementation(async (tokenId: string) => {
+      if (tokenId === "ethereum/erc20/invalid") throw new Error("Token not found");
+      return mockUsdtToken;
+    });
+
+    render(<BlacklistedTokens />, {
+      initialState: {
+        settings: { blacklistedTokenIds: ["ethereum/erc20/invalid", "ethereum/erc20/usdt"] },
+      },
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText("2 tokens")).toBeInTheDocument();
+    });
+
+    fireEvent.click(screen.getByText("2 tokens"));
+
+    // The failing id is dropped, the resolvable token still renders
+    await waitFor(() => {
+      expect(screen.getByText("Tether USD")).toBeInTheDocument();
+    });
+  });
+
+  it("logs a warning and renders no rows when loading rejects", async () => {
+    // A synchronous throw from the store escapes the helper's per-id `.catch`,
+    // so the whole load rejects and the component falls back to an empty list.
+    mockFindTokenById.mockImplementation(() => {
+      throw new Error("Store unavailable");
+    });
 
     const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
 
     render(<BlacklistedTokens />, {
-      initialState: { settings: { blacklistedTokenIds: ["ethereum/erc20/invalid"] } },
+      initialState: { settings: { blacklistedTokenIds: ["ethereum/erc20/usdt"] } },
     });
 
     await waitFor(() => {
@@ -169,6 +217,9 @@ describe("BlacklistedTokens", () => {
       );
     });
 
+    fireEvent.click(screen.getByText("1 token"));
+    expect(screen.queryByText("Tether USD")).not.toBeInTheDocument();
+
     consoleWarnSpy.mockRestore();
   });
 });

apps/ledger-live-desktop/src/renderer/screens/settings/sections/Accounts/BlacklistedTokens.tsx

@@ -14,11 +14,11 @@ import { useBridgeSync } from "@ledgerhq/live-common/bridge/react/index";
 import Track from "~/renderer/analytics/Track";
 import IconAngleDown from "~/renderer/icons/AngleDown";
 import type { CryptoCurrency } from "@domain/entity-currency-crypto";
-import type { TokenCurrency } from "@domain/entity-currency-token";
+import type { CryptoOrTokenCurrency } from "@domain/entity-currency";
 
 type BlacklistedTokenSection = {
   parentCurrency: CryptoCurrency;
-  tokens: TokenCurrency[];
+  assets: CryptoOrTokenCurrency[];
 };
 
 export default function BlacklistedTokens() {
@@ -103,17 +103,17 @@ export default function BlacklistedTokens() {
 
       {sectionVisible && (
         <div>
-          {sections.map(({ parentCurrency, tokens }) => (
+          {sections.map(({ parentCurrency, assets }) => (
             <Box key={parentCurrency.id}>
               <BlacklistedTokensSectionHeader>
                 <Text ff="Inter|Bold" fontSize={2} color="neutral.c60">
                   {parentCurrency.name}
                 </Text>
               </BlacklistedTokensSectionHeader>
               <Body>
-                {tokens.map((token: TokenCurrency) => (
-                  <BlacklistedTokenRow key={token.id}>
-                    <CryptoCurrencyIcon currency={token} size={28} />
+                {assets.map((asset: CryptoOrTokenCurrency) => (
+                  <BlacklistedTokenRow key={asset.id}>
+                    <CryptoCurrencyIcon currency={asset} size={28} />
                     <Text
                       style={{
                         marginLeft: 10,
@@ -123,9 +123,9 @@ export default function BlacklistedTokens() {
                       color="neutral.c100"
                       fontSize={3}
                     >
-                      {token.name}
+                      {asset.name}
                     </Text>
-                    <IconContainer onClick={() => onShowToken(token.id)}>
+                    <IconContainer onClick={() => onShowToken(asset.id)}>
                       <IconCross size={16} />
                     </IconContainer>
                   </BlacklistedTokenRow>

apps/ledger-live-desktop/static/i18n/en/app.json

@@ -5511,7 +5511,7 @@
       },
       "tokenBlacklist": {
         "title": "Hidden tokens",
-        "desc": "You can hide tokens by going to the parent account then right-clicking on the token and selecting 'Hide token'.",
+        "desc": "You can hide an asset from its detail page using the options menu, or hide a token by going to the parent account then right-clicking on the token and selecting 'Hide token'.",
         "count": "1 token",
         "count_other": "{{count}} tokens"
       },

apps/ledger-live-mobile/src/screens/Settings/Accounts/index.test.tsx

@@ -203,7 +203,11 @@ describe("AccountsSettings - BlacklistedTokens", () => {
   });
 
   it("handles async loading errors gracefully", async () => {
-    mockFindTokenById.mockRejectedValue(new Error("Token not found"));
+    // A synchronous throw from the store escapes the helper's per-id `.catch`,
+    // so the whole load rejects and the component falls back to an empty list.
+    mockFindTokenById.mockImplementation(() => {
+      throw new Error("Store unavailable");
+    });
     const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
 
     render(<AccountsSettings navigation={mockNavigation} route={mockRoute} />, {

apps/ledger-live-mobile/src/screens/Settings/Accounts/index.tsx

@@ -4,7 +4,7 @@ import { useSelector, useDispatch } from "~/context/hooks";
 import { TouchableOpacity, View, StyleSheet, SectionList } from "react-native";
 import { loadBlacklistedTokenSections as loadBlacklistedTokenSectionsBase } from "@ledgerhq/live-common/account/index";
 import { CryptoCurrency } from "@domain/entity-currency-crypto";
-import { TokenCurrency } from "@domain/entity-currency-token";
+import { CryptoOrTokenCurrency } from "@domain/entity-currency";
 import { DefaultTheme, useTheme } from "styled-components/native";
 import SettingsRow from "~/components/SettingsRow";
 import { showToken } from "~/actions/settings";
@@ -24,7 +24,7 @@ import { StackNavigatorProps } from "~/components/RootNavigator/types/helpers";
 type BlacklistedTokenSection = {
   key: string;
   parentCurrency: CryptoCurrency;
-  data: TokenCurrency[];
+  data: CryptoOrTokenCurrency[];
 };
 
 async function loadBlacklistedTokenSections(
@@ -34,7 +34,7 @@ async function loadBlacklistedTokenSections(
   return sections.map(section => ({
     key: section.parentCurrency.id,
     parentCurrency: section.parentCurrency,
-    data: section.tokens,
+    data: section.assets,
   }));
 }
 
@@ -59,14 +59,14 @@ export default function AccountsSettings({
   );
 
   const renderItem = useCallback(
-    ({ item: token }: { item: TokenCurrency }) => (
+    ({ item: asset }: { item: CryptoOrTokenCurrency }) => (
       <View style={styles.row}>
         <View style={styles.rowIconContainer}>
-          <CurrencyIcon currency={token} size={20} />
+          <CurrencyIcon currency={asset} size={20} />
         </View>
-        <LText style={styles.rowTitle}>{token.name}</LText>
+        <LText style={styles.rowTitle}>{asset.name}</LText>
         <TouchableOpacity
-          onPress={() => dispatch(showToken(token.id))}
+          onPress={() => dispatch(showToken(asset.id))}
           style={styles.cta}
           hitSlop={hitSlop}
         >
@@ -77,7 +77,7 @@ export default function AccountsSettings({
     [colors, dispatch],
   );
 
-  const keyExtractor = useCallback((token: TokenCurrency) => token.id, []);
+  const keyExtractor = useCallback((asset: CryptoOrTokenCurrency) => asset.id, []);
 
   const renderHeader = useCallback(
     () => (

libs/ledger-live-common/src/account/helpers.test.ts

@@ -131,7 +131,7 @@ describe("loadBlacklistedTokenSections", () => {
 
     expect(result).toHaveLength(1);
     expect(result[0].parentCurrency.id).toBe("ethereum");
-    expect(result[0].tokens).toEqual([mockUsdtToken]);
+    expect(result[0].assets).toEqual([mockUsdtToken]);
   });
 
   it("should group multiple tokens from the same parent currency", async () => {
@@ -145,8 +145,8 @@ describe("loadBlacklistedTokenSections", () => {
 
     expect(result).toHaveLength(1);
     expect(result[0].parentCurrency.id).toBe("ethereum");
-    expect(result[0].tokens).toHaveLength(2);
-    expect(result[0].tokens).toEqual([mockUsdtToken, mockUsdcToken]);
+    expect(result[0].assets).toHaveLength(2);
+    expect(result[0].assets).toEqual([mockUsdtToken, mockUsdcToken]);
   });
 
   it("should create separate sections for different parent currencies", async () => {
@@ -160,9 +160,9 @@ describe("loadBlacklistedTokenSections", () => {
 
     expect(result).toHaveLength(2);
     expect(result[0].parentCurrency.id).toBe("ethereum");
-    expect(result[0].tokens).toEqual([mockUsdtToken]);
+    expect(result[0].assets).toEqual([mockUsdtToken]);
     expect(result[1].parentCurrency.id).toBe("polygon");
-    expect(result[1].tokens).toEqual([mockMaticUsdtToken]);
+    expect(result[1].assets).toEqual([mockMaticUsdtToken]);
   });
 
   it("should filter out null/undefined tokens", async () => {
@@ -178,8 +178,8 @@ describe("loadBlacklistedTokenSections", () => {
 
     expect(result).toHaveLength(1);
     expect(result[0].parentCurrency.id).toBe("ethereum");
-    expect(result[0].tokens).toHaveLength(2);
-    expect(result[0].tokens).toEqual([mockUsdtToken, mockUsdcToken]);
+    expect(result[0].assets).toHaveLength(2);
+    expect(result[0].assets).toEqual([mockUsdtToken, mockUsdcToken]);
   });
 
   it("should handle complex scenario with mixed parent currencies and null tokens", async () => {
@@ -197,11 +197,11 @@ describe("loadBlacklistedTokenSections", () => {
 
     expect(result).toHaveLength(2);
     expect(result[0].parentCurrency.id).toBe("ethereum");
-    expect(result[0].tokens).toHaveLength(2);
-    expect(result[0].tokens).toEqual([mockUsdtToken, mockUsdcToken]);
+    expect(result[0].assets).toHaveLength(2);
+    expect(result[0].assets).toEqual([mockUsdtToken, mockUsdcToken]);
     expect(result[1].parentCurrency.id).toBe("polygon");
-    expect(result[1].tokens).toHaveLength(1);
-    expect(result[1].tokens).toEqual([mockMaticUsdtToken]);
+    expect(result[1].assets).toHaveLength(1);
+    expect(result[1].assets).toEqual([mockMaticUsdtToken]);
   });
 
   it("should call findTokenById for all token IDs in parallel", async () => {
@@ -215,4 +215,42 @@ describe("loadBlacklistedTokenSections", () => {
     expect(mockFindTokenById).toHaveBeenCalledWith("token2");
     expect(mockFindTokenById).toHaveBeenCalledWith("token3");
   });
+
+  it("should resolve a native coin id from the registry without a CAL lookup", async () => {
+    const result = await loadBlacklistedTokenSections(["bitcoin"]);
+
+    expect(mockFindTokenById).not.toHaveBeenCalled();
+    expect(result).toHaveLength(1);
+    expect(result[0].parentCurrency.id).toBe("bitcoin");
+    expect(result[0].assets).toHaveLength(1);
+    expect(result[0].assets[0].id).toBe("bitcoin");
+  });
+
+  it("should merge a native coin and a token sharing the same parent currency", async () => {
+    mockFindTokenById.mockResolvedValueOnce(mockUsdtToken);
+
+    const result = await loadBlacklistedTokenSections(["ethereum", "ethereum/erc20/usdt"]);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].parentCurrency.id).toBe("ethereum");
+    expect(result[0].assets).toHaveLength(2);
+    expect(result[0].assets[0].id).toBe("ethereum");
+    expect(result[0].assets[1]).toEqual(mockUsdtToken);
+  });
+
+  it("should isolate a failing token lookup without discarding the other entries", async () => {
+    mockFindTokenById.mockResolvedValueOnce(mockUsdtToken);
+    mockFindTokenById.mockRejectedValueOnce(new Error("CAL unavailable"));
+    mockFindTokenById.mockResolvedValueOnce(mockUsdcToken);
+
+    const result = await loadBlacklistedTokenSections([
+      "ethereum/erc20/usdt",
+      "ethereum/erc20/unknown",
+      "ethereum/erc20/usdc",
+    ]);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].parentCurrency.id).toBe("ethereum");
+    expect(result[0].assets).toEqual([mockUsdtToken, mockUsdcToken]);
+  });
 });

libs/ledger-live-common/src/account/helpers.ts

@@ -1,6 +1,6 @@
 import type { CryptoCurrency } from "@domain/entity-currency-crypto";
-import { getCryptoCurrencyById } from "@domain/entity-currency-crypto";
-import type { TokenCurrency } from "@domain/entity-currency-token";
+import { findCryptoCurrencyById } from "@domain/entity-currency-crypto";
+import type { CryptoOrTokenCurrency } from "@domain/entity-currency";
 import { getCryptoAssetsStore } from "@ledgerhq/ledger-wallet-framework/cryptoAssetsStore";
 
 export { filterAccountsExcludingBlacklisted } from "./filterAccountsExcludingBlacklisted";
@@ -24,31 +24,42 @@ export {
 } from "@ledgerhq/ledger-wallet-framework/account/index";
 
 /**
- * Load blacklisted tokens and organize them into sections by parent currency
- * @param tokenIds - Array of token IDs to load
- * @returns Array of sections with parent currency and tokens
+ * Load blacklisted (hidden) assets and organize them into sections by parent currency.
+ * Hidden ids can be native coins (grouped under themselves) as well as tokens (grouped
+ * under their parent). Token lookups are isolated so one failure keeps the rest of the list.
  */
 export async function loadBlacklistedTokenSections(
-  tokenIds: string[],
-): Promise<Array<{ parentCurrency: CryptoCurrency; tokens: TokenCurrency[] }>> {
-  const tokens = await Promise.all(
-    tokenIds.map(tokenId => getCryptoAssetsStore().findTokenById(tokenId)),
+  assetIds: string[],
+): Promise<Array<{ parentCurrency: CryptoCurrency; assets: CryptoOrTokenCurrency[] }>> {
+  const resolved = await Promise.all(
+    assetIds.map(async (assetId): Promise<CryptoOrTokenCurrency | undefined> => {
+      const coin = findCryptoCurrencyById(assetId);
+      if (coin) {
+        return coin;
+      }
+      return getCryptoAssetsStore()
+        .findTokenById(assetId)
+        .catch(() => undefined);
+    }),
   );
 
-  const sections: Array<{ parentCurrency: CryptoCurrency; tokens: TokenCurrency[] }> = [];
-
-  for (const token of tokens) {
-    if (token) {
-      const parentCurrency = getCryptoCurrencyById(token.parentCurrencyId);
-      const index = sections.findIndex(s => s.parentCurrency === parentCurrency);
-      if (index < 0) {
-        sections.push({
-          parentCurrency,
-          tokens: [token],
-        });
-      } else {
-        sections[index].tokens.push(token);
-      }
+  const sections: Array<{ parentCurrency: CryptoCurrency; assets: CryptoOrTokenCurrency[] }> = [];
+
+  for (const asset of resolved) {
+    if (!asset) continue;
+
+    const parentCurrency =
+      asset.type === "TokenCurrency" ? findCryptoCurrencyById(asset.parentCurrencyId) : asset;
+    if (!parentCurrency) continue;
+
+    const index = sections.findIndex(s => s.parentCurrency === parentCurrency);
+    if (index < 0) {
+      sections.push({
+        parentCurrency,
+        assets: [asset],
+      });
+    } else {
+      sections[index].assets.push(asset);
     }
   }