@ledgerhq/live-common 34.51.0-nightly.1 → 34.51.0-nightly.11

package/src/modularDrawer/modules/__test__/createNetworkConfiguration.test.ts

@@ -0,0 +1,342 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { BigNumber } from "bignumber.js";
+import { genAccount, genTokenAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+import { createNetworkConfigurationHook } from "../createNetworkConfiguration";
+import { renderHook } from "@testing-library/react";
+import { CounterValuesState } from "@ledgerhq/live-countervalues/lib/types";
+import { FiatCurrency, TokenCurrency, CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { makeUsdcToken } from "./createAssetConfiguration.test";
+
+const bscCurrency = createFixtureCryptoCurrency("bsc");
+const bscAccount = genAccount("bsc-account", { currency: bscCurrency });
+const bscUsdcToken: TokenCurrency = makeUsdcToken(
+  bscCurrency,
+  "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+  "bep20",
+  "USD Coin",
+  "bsc/erc20/usdc",
+);
+const bscUsdcTokenAccount = genTokenAccount(0, bscAccount, bscUsdcToken);
+bscAccount.subAccounts = [bscUsdcTokenAccount];
+
+const baseCurrency = createFixtureCryptoCurrency("base");
+const baseAccount = genAccount("base-account", { currency: baseCurrency });
+const baseUsdcToken: TokenCurrency = makeUsdcToken(
+  baseCurrency,
+  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "erc20",
+  "USD Coin",
+  "base/erc20/usd_coin",
+);
+const baseUsdcTokenAccount = genTokenAccount(0, baseAccount, baseUsdcToken);
+baseAccount.subAccounts = [baseUsdcTokenAccount];
+
+const ethereumCurrency = createFixtureCryptoCurrency("ethereum");
+const ethereumAccountHigh = genAccount("ethereum-account-high", {
+  currency: ethereumCurrency,
+});
+
+ethereumAccountHigh.balance = new BigNumber("1000000000000000000000");
+ethereumAccountHigh.spendableBalance = ethereumAccountHigh.balance;
+
+const ethereumUsdcToken: TokenCurrency = makeUsdcToken(
+  ethereumCurrency,
+  "0xA0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+  "erc20",
+
+  "USD Coin",
+);
+const ethereumUsdcTokenAccount = genTokenAccount(0, ethereumAccountHigh, ethereumUsdcToken);
+ethereumAccountHigh.subAccounts = [ethereumUsdcTokenAccount];
+
+const ethereumAccountLow = genAccount("ethereum-account-low", {
+  currency: ethereumCurrency,
+});
+ethereumAccountLow.balance = new BigNumber("100000000000000000");
+ethereumAccountLow.spendableBalance = ethereumAccountLow.balance;
+
+const ethereumAccountZero = genAccount("ethereum-account-zero", {
+  currency: ethereumCurrency,
+});
+ethereumAccountZero.balance = new BigNumber("0");
+ethereumAccountZero.spendableBalance = ethereumAccountZero.balance;
+
+const polygonCurrency = createFixtureCryptoCurrency("polygon");
+const polygonAccountMedium = genAccount("polygon-account-medium", {
+  currency: polygonCurrency,
+});
+polygonAccountMedium.balance = new BigNumber("500000000000000000000");
+polygonAccountMedium.spendableBalance = polygonAccountMedium.balance;
+
+const polygonUsdcToken: TokenCurrency = makeUsdcToken(
+  polygonCurrency,
+  "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+  "erc20",
+  "USD Coin",
+);
+const polygonUsdcTokenAccount = genTokenAccount(0, polygonAccountMedium, polygonUsdcToken);
+polygonAccountMedium.subAccounts = [polygonUsdcTokenAccount];
+
+const makeAccountData = (asset, count) => ({
+  asset,
+  label: `${count} account`,
+  count,
+});
+
+const useAccountData = () => {
+  return [
+    makeAccountData(createFixtureCryptoCurrency("ethereum"), 3),
+    makeAccountData(createFixtureCryptoCurrency("polygon"), 1),
+    makeAccountData(createFixtureCryptoCurrency("bsc"), 2),
+    makeAccountData(createFixtureCryptoCurrency("base"), 1),
+    makeAccountData(createFixtureCryptoCurrency("avalanche_c_chain"), 0),
+  ];
+};
+
+const mockFiatCurrency: FiatCurrency = {
+  type: "FiatCurrency",
+  ticker: "USD",
+  name: "US Dollar",
+  symbol: "$",
+  units: [
+    {
+      code: "$",
+      name: "US Dollar",
+      magnitude: 2,
+      showAllDigits: true,
+      prefixCode: true,
+    },
+  ],
+};
+
+const accountsCount = jest.fn(() => null);
+const accountsCountAndApy = () => null;
+const useBalanceDeps = () => {
+  const mockCounterValuesState: CounterValuesState = {
+    cache: {
+      "USD testCoinId": {
+        fallback: 2354.213,
+        map: new Map(),
+        stats: {
+          oldest: "2024-09-12",
+          earliest: "2025-10-02T13",
+          oldestDate: new Date(),
+          earliestDate: new Date(),
+          earliestStableDate: new Date(),
+        },
+      },
+    },
+    data: {},
+    status: {},
+  };
+
+  return {
+    counterValueCurrency: mockFiatCurrency,
+    flattenedAccounts: [
+      bscAccount,
+      bscUsdcTokenAccount,
+      baseAccount,
+      baseUsdcTokenAccount,
+      ethereumAccountHigh,
+      ethereumUsdcTokenAccount,
+      ethereumAccountLow,
+      ethereumAccountZero,
+      polygonAccountMedium,
+      polygonUsdcTokenAccount,
+    ],
+    state: mockCounterValuesState,
+    locale: "en-US",
+  };
+};
+const balanceItem = jest.fn(() => null);
+
+const networkConfigurationDeps = {
+  useAccountData,
+  accountsCount,
+  accountsCountAndApy,
+  useBalanceDeps,
+  balanceItem,
+};
+
+describe("createNetworkConfiguration", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call balanceItem with correct BalanceUI objects for each network", () => {
+    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
+    const res = result.current({ networksConfig: { rightElement: "balance" } });
+    res([baseUsdcToken, bscUsdcToken]);
+
+    expect(balanceItem).toHaveBeenCalledTimes(2);
+    expect(balanceItem).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ balance: baseUsdcTokenAccount.balance }),
+    );
+    expect(balanceItem).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ balance: bscUsdcTokenAccount.balance }),
+    );
+  });
+
+  it("account count", () => {
+    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
+    const res = result.current({ networksConfig: { leftElement: "numberOfAccounts" } });
+    res([baseUsdcToken, bscUsdcToken]);
+
+    expect(accountsCount).toHaveBeenCalledTimes(4);
+    expect(accountsCount).toHaveBeenNthCalledWith(1, { label: "3 account" });
+  });
+
+  it("should order by balance (highest first) when only balance element is present", () => {
+    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
+    const res = result.current({
+      networksConfig: { rightElement: "balance" },
+    });
+
+    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken, bscUsdcToken]);
+
+    expect(orderedResult).toHaveLength(3);
+
+    // Should be ordered by balance amount (highest first)
+    expect(orderedResult[0].id).toBe(ethereumCurrency.id); // 1000 ETH
+    expect(orderedResult[1].id).toBe(polygonCurrency.id); // 500 MATIC
+    expect(orderedResult[2].id).toBe(bscCurrency.id); // Lower balance
+  });
+
+  it("should order by account count (highest first) when only account count element is present", () => {
+    const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
+    const res = result.current({
+      networksConfig: { leftElement: "numberOfAccounts" },
+    });
+
+    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken, bscUsdcToken]);
+
+    expect(orderedResult).toHaveLength(3);
+
+    // Should be ordered by account count (highest first)
+    expect(orderedResult[0].id).toBe(ethereumCurrency.id); // 3 accounts
+    expect(orderedResult[1].id).toBe(bscCurrency.id); // 2 accounts
+    expect(orderedResult[2].id).toBe(polygonCurrency.id); // 1 account
+  });
+
+  it("should handle networks with zero balances by ordering them by account count", () => {
+    const zeroBalanceEth = { ...ethereumAccountZero };
+    const zeroBalancePoly = {
+      ...polygonAccountMedium,
+      balance: new BigNumber("0"),
+      spendableBalance: new BigNumber("0"),
+    };
+
+    const mockUseBalanceDepsZero = () => ({
+      counterValueCurrency: {
+        type: "FiatCurrency" as const,
+        ticker: "USD",
+        name: "US Dollar",
+        symbol: "$",
+        units: [
+          { code: "$", name: "US Dollar", magnitude: 2, showAllDigits: true, prefixCode: true },
+        ],
+      },
+      flattenedAccounts: [zeroBalanceEth, zeroBalancePoly],
+      state: { cache: {}, data: {}, status: {} },
+      locale: "en-US",
+    });
+
+    const { result } = renderHook(() =>
+      createNetworkConfigurationHook({
+        ...networkConfigurationDeps,
+        useBalanceDeps: mockUseBalanceDepsZero,
+      }),
+    );
+    const res = result.current({
+      networksConfig: { leftElement: "numberOfAccounts", rightElement: "balance" },
+    });
+
+    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken]);
+
+    expect(orderedResult).toHaveLength(2);
+
+    // When both have zero balance, should order by account count
+    expect(orderedResult[0].id).toBe(ethereumCurrency.id); // 3 accounts
+    expect(orderedResult[1].id).toBe(polygonCurrency.id); // 1 account
+  });
+
+  it("should prioritise non-zero balances over account count", () => {
+    const testEthereumCurrency: CryptoCurrency = createFixtureCryptoCurrency("ethereum");
+    const testPolygonCurrency: CryptoCurrency = createFixtureCryptoCurrency("polygon");
+    const testAvalancheCurrency: CryptoCurrency = createFixtureCryptoCurrency("avalanche_c_chain");
+    const testArbitrumCurrency: CryptoCurrency = createFixtureCryptoCurrency("arbitrum");
+
+    const testEthereumAccount = genAccount("test-ethereum-account", {
+      currency: testEthereumCurrency,
+    });
+    testEthereumAccount.balance = new BigNumber("1000000000000000000000");
+    testEthereumAccount.spendableBalance = testEthereumAccount.balance;
+
+    const testPolygonAccount = genAccount("test-polygon-account", {
+      currency: testPolygonCurrency,
+    });
+    testPolygonAccount.balance = new BigNumber("500000000000000000000");
+    testPolygonAccount.spendableBalance = testPolygonAccount.balance;
+
+    const testEthereumUsdcToken = makeUsdcToken(
+      testEthereumCurrency,
+      "0xA0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    );
+    const testPolygonUsdcToken = makeUsdcToken(
+      testPolygonCurrency,
+      "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    );
+    const testAvalancheUsdcToken = makeUsdcToken(
+      testAvalancheCurrency,
+      "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    );
+    const testArbitrumUsdcToken = makeUsdcToken(
+      testArbitrumCurrency,
+      "0xFF970A61A04b1cA14834A43f5de4533eBDDB5CC8",
+    );
+
+    const testUseBalanceDeps = () => ({
+      counterValueCurrency: mockFiatCurrency,
+      flattenedAccounts: [testEthereumAccount, testPolygonAccount],
+      state: { cache: {}, data: {}, status: {} },
+      locale: "en-US",
+    });
+
+    const testUseAccountData = () => [
+      makeAccountData(testEthereumCurrency, 3),
+      makeAccountData(testPolygonCurrency, 1),
+      makeAccountData(testAvalancheCurrency, 1),
+      makeAccountData(testArbitrumCurrency, 2),
+    ];
+
+    const { result } = renderHook(() =>
+      createNetworkConfigurationHook({
+        ...networkConfigurationDeps,
+        useAccountData: testUseAccountData,
+        useBalanceDeps: testUseBalanceDeps,
+      }),
+    );
+
+    const res = result.current({
+      networksConfig: { leftElement: "numberOfAccounts", rightElement: "balance" },
+    });
+
+    const orderedResult = res([
+      testEthereumUsdcToken,
+      testPolygonUsdcToken,
+      testAvalancheUsdcToken,
+      testArbitrumUsdcToken,
+    ]);
+
+    expect(orderedResult[0].id).toBe(testEthereumCurrency.id); // 1000 ETH balance, 3 accounts
+    expect(orderedResult[1].id).toBe(testPolygonCurrency.id); // 500 MATIC balance, 1 account
+    expect(orderedResult[2].id).toBe(testArbitrumCurrency.id); // (0 balance, 2 accounts)
+    expect(orderedResult[3].id).toBe(testAvalancheCurrency.id); // (0 balance, 1 account)
+  });
+});

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -5,29 +5,27 @@ import { createUseRightBalanceNetwork } from "../hooks/useRightBalanceNetwork";
 import {
   CreateNetworkConfigurationHookProps,
   NetworkConfigurationDeps,
-  LeftElementKind,
   Network,
   NetworkHook,
-  RightElementKind,
   AccountModuleParams,
   BalanceUI,
+  NetworkLeftElementKind,
+  NetworkRightElementKind,
 } from "../utils/type";
-import { composeHooks } from "../../utils/composeHooks";
 import { compareByBalanceThenFiat } from "../utils/sortByBalance";
 
-export const getLeftElement =
+const getLeftElement =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  (leftElement?: LeftElementKind): NetworkHook | undefined => {
+  (leftElement?: NetworkLeftElementKind): NetworkHook | undefined => {
     switch (leftElement) {
       case "undefined":
         return undefined;
       case "numberOfAccountsAndApy":
-        return (params: AccountModuleParams & { networks: CryptoOrTokenCurrency[] }) =>
+        return (params: AccountModuleParams) =>
           useLeftAccountsApyModule(
             params,
             NetworkConfigurationDeps.useAccountData,
             NetworkConfigurationDeps.accountsCountAndApy,
-            params.networks,
           );
       case "numberOfAccounts":
       default:
@@ -38,21 +36,46 @@ export const getLeftElement =
     }
   };
 
-export const getRightElement =
+const getRightElement =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  (rightElement?: RightElementKind): NetworkHook | undefined => {
+  (rightElement?: NetworkRightElementKind): NetworkHook | undefined => {
     switch (rightElement) {
       case "undefined":
         return undefined;
       case "balance":
       default:
-        return createUseRightBalanceNetwork({
-          useBalanceDeps: NetworkConfigurationDeps.useBalanceDeps,
-          balanceItem: NetworkConfigurationDeps.balanceItem,
-        });
+        return (params: { networks: CryptoOrTokenCurrency[] }) =>
+          createUseRightBalanceNetwork({
+            useBalanceDeps: NetworkConfigurationDeps.useBalanceDeps,
+            balanceItem: NetworkConfigurationDeps.balanceItem,
+          })({ networks: params.networks });
     }
   };
 
+type NetworksWithComponents = CryptoOrTokenCurrency &
+  Network & { balanceData?: BalanceUI; count?: number };
+
+const sortNetworks = (
+  result: NetworksWithComponents[],
+  leftElement?: NetworkLeftElementKind,
+  rightElement?: NetworkRightElementKind,
+) => {
+  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));
+  }
+};
+
 export const createNetworkConfigurationHook =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
   ({ networksConfig, accounts$ }: CreateNetworkConfigurationHookProps) => {
@@ -60,44 +83,34 @@ export const createNetworkConfigurationHook =
     const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
     const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const hooks = [rightHook, leftHook].filter(Boolean) as NetworkHook[];
+    const hooks = [rightHook, leftHook].filter((hook): hook is NetworkHook => Boolean(hook));
 
     return (
-      assets: CryptoOrTokenCurrency[],
       networks: CryptoOrTokenCurrency[],
-    ): Array<CryptoOrTokenCurrency & Network> => {
-      const composedHook = composeHooks<
-        CryptoOrTokenCurrency,
-        Network & { balanceData?: BalanceUI; count?: number }
-      >(
-        ...hooks.map(
-          hook => () =>
-            hook({
-              assets,
-              accounts$,
-              networks,
-            }),
-        ),
+    ): Array<CryptoOrTokenCurrency & Network & { balanceData?: BalanceUI; count?: number }> => {
+      const hookResults = hooks.map(hook =>
+        hook({
+          accounts$,
+          networks,
+        }),
       );
 
-      const result = composedHook(assets);
+      const networksWithComponents = networks.map((network, index) => {
+        const asset = network.type === "TokenCurrency" ? network.parentCurrency : network;
+
+        const merged: NetworksWithComponents = { ...asset };
+
+        for (const hookResult of hookResults) {
+          if (hookResult[index]) {
+            Object.assign(merged, hookResult[index]);
+          }
+        }
 
-      if (
-        leftElement === "numberOfAccounts" ||
-        leftElement === "numberOfAccountsAndApy" ||
-        leftElement === undefined // default
-      ) {
-        result.sort((a, b) => (b?.count || 0) - (a?.count || 0));
-      }
+        return merged;
+      });
 
-      if (
-        rightElement === "balance" ||
-        rightElement === undefined // default
-      ) {
-        result.sort((a, b) => compareByBalanceThenFiat(a?.balanceData, b?.balanceData));
-      }
+      sortNetworks(networksWithComponents, leftElement, rightElement);
 
-      return result;
+      return networksWithComponents;
     };
   };

package/src/modularDrawer/types/detailedAccount.ts

@@ -0,0 +1,49 @@
+import { Unit } from "@ledgerhq/types-cryptoassets";
+import { AccountLike } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+
+/**
+ * Base raw detailed account with unformatted values for UI formatting
+ * This is the shared interface that both mobile and desktop can extend
+ */
+export interface BaseRawDetailedAccount {
+  id: string;
+  name: string;
+  ticker: string;
+  balance: BigNumber;
+  balanceUnit: Unit;
+  fiatValue: number;
+  address: string;
+  cryptoId: string;
+  parentId?: string;
+}
+
+/**
+ * Extended detailed account that includes the original account references
+ * Used by mobile implementation that needs access to the full account objects
+ */
+export interface ExtendedRawDetailedAccount extends BaseRawDetailedAccount {
+  account: AccountLike;
+  parentAccount?: AccountLike;
+  protocol?: string;
+}
+
+/**
+ * Configuration for formatting detailed accounts
+ */
+export interface DetailedAccountFormatConfig {
+  discreet?: boolean;
+  locale?: string;
+  showCode?: boolean;
+}
+
+/**
+ * Parameters for creating detailed accounts
+ */
+export interface CreateDetailedAccountsParams {
+  asset: any; // CryptoOrTokenCurrency - avoiding import to keep this generic
+  accountTuples: any[]; // AccountTuple[] - avoiding import to keep this generic
+  accountNameMap: Record<string, string>;
+  isTokenCurrency: boolean;
+  formatConfig?: DetailedAccountFormatConfig;
+}

package/src/modularDrawer/types/index.ts

@@ -0,0 +1 @@
+export * from "./detailedAccount";

package/src/modularDrawer/utils/__tests__/sortAccountsByFiatValue.test.ts

@@ -0,0 +1,117 @@
+import { sortAccountsByFiatValue } from "../sortAccountsByFiatValue";
+import { BaseRawDetailedAccount } from "../../types/detailedAccount";
+import BigNumber from "bignumber.js";
+
+const mockBalanceUnit = { name: "Ethereum", code: "ETH", magnitude: 18 };
+
+const mockAccounts: BaseRawDetailedAccount[] = [
+  {
+    name: "Ethereum 1",
+    id: "js:2:ethereum:0xaDf49b9f133fb137e82b24F06D23E49c51f586C7:",
+    ticker: "ETH",
+    balance: new BigNumber("1.55699"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 4149.62,
+    address: "0xaDf...586C7",
+    cryptoId: "ethereum",
+  },
+  {
+    name: "Ethereum 2",
+    id: "js:2:ethereum:0xd4b6595ff5f3c21E0b00edB8947A31110a9c4B8f:",
+    ticker: "ETH",
+    balance: new BigNumber("0.178403"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 475.47,
+    address: "0xd4b...c4B8f",
+    cryptoId: "ethereum",
+  },
+  {
+    name: "Ethereum 3",
+    id: "js:2:ethereum:0x833eBB4bDa11da33a7F1C907C8171e5995Fe33c7:",
+    ticker: "ETH",
+    balance: new BigNumber("5.10589"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 13607.93,
+    address: "0x833...e33c7",
+    cryptoId: "ethereum",
+  },
+  {
+    name: "Ethereum 4",
+    id: "js:2:ethereum:0xDbD543b0e80e0E73FbD49FDEe902FC59652753B9:",
+    ticker: "ETH",
+    balance: new BigNumber("0.00148572"),
+    balanceUnit: mockBalanceUnit,
+    fiatValue: 3.96,
+    address: "0xDbD...753B9",
+    cryptoId: "ethereum",
+  },
+];
+
+const expectedSortedAccounts = [
+  mockAccounts[2], // 13607.93
+  mockAccounts[0], // 4149.62
+  mockAccounts[1], // 475.47
+  mockAccounts[3], // 3.96
+];
+
+describe("sortAccountsByFiatValue", () => {
+  it("should sort accounts by fiat value in descending order", () => {
+    const sortedAccounts = sortAccountsByFiatValue(mockAccounts);
+    expect(sortedAccounts).toEqual(expectedSortedAccounts);
+  });
+
+  it("should handle empty accounts array", () => {
+    const sortedAccounts = sortAccountsByFiatValue([]);
+    expect(sortedAccounts).toEqual([]);
+  });
+
+  it("should handle accounts with identical fiat values", () => {
+    const identicalAccounts = [
+      { ...mockAccounts[0], fiatValue: 1000 },
+      { ...mockAccounts[1], fiatValue: 1000 },
+    ];
+    const sortedAccounts = sortAccountsByFiatValue(identicalAccounts);
+    expect(sortedAccounts).toEqual(identicalAccounts);
+  });
+
+  it("should handle accounts with zero fiat value", () => {
+    const zeroBalanceAccounts = [
+      { ...mockAccounts[0], fiatValue: 0 },
+      { ...mockAccounts[1], fiatValue: 10000 },
+    ];
+    const sortedAccounts = sortAccountsByFiatValue(zeroBalanceAccounts);
+    expect(sortedAccounts).toEqual([zeroBalanceAccounts[1], zeroBalanceAccounts[0]]);
+  });
+
+  it("should handle accounts with undefined fiat value", () => {
+    const undefinedFiatAccounts = [
+      { ...mockAccounts[0], fiatValue: undefined as any },
+      { ...mockAccounts[1], fiatValue: 5000 },
+    ];
+    const sortedAccounts = sortAccountsByFiatValue(undefinedFiatAccounts);
+    expect(sortedAccounts).toEqual([undefinedFiatAccounts[1], undefinedFiatAccounts[0]]);
+  });
+
+  it("should not mutate the original array", () => {
+    const originalAccounts = [...mockAccounts];
+    const sortedAccounts = sortAccountsByFiatValue(mockAccounts);
+
+    expect(mockAccounts).toEqual(originalAccounts);
+    expect(sortedAccounts).not.toBe(mockAccounts);
+  });
+
+  it("should work with extended account types", () => {
+    interface ExtendedAccount extends BaseRawDetailedAccount {
+      customField: string;
+    }
+
+    const extendedAccounts: ExtendedAccount[] = [
+      { ...mockAccounts[0], customField: "test1" },
+      { ...mockAccounts[2], customField: "test2" },
+    ];
+
+    const sortedAccounts = sortAccountsByFiatValue(extendedAccounts);
+    expect(sortedAccounts[0].customField).toBe("test2"); // Higher fiat value
+    expect(sortedAccounts[1].customField).toBe("test1"); // Lower fiat value
+  });
+});

package/src/modularDrawer/utils/getBalanceAndFiatValueByAssets.ts

@@ -5,9 +5,9 @@ import { AccountLike } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
 
-interface ExtendedAssetType extends AssetType {
-  currency?: CryptoOrTokenCurrency;
-  balance?: BigNumber;
+export interface ExtendedAssetType extends AssetType {
+  currency: CryptoOrTokenCurrency;
+  balance: BigNumber;
   fiatValue?: number;
 }
 
@@ -30,6 +30,9 @@ export const getBalanceAndFiatValueByAssets = (
       id: asset.id,
       name: asset.name,
       ticker: asset.ticker,
+      currency: asset,
+      balance: new BigNumber(0),
+      fiatValue: 0,
     };
   });
 };

package/src/modularDrawer/utils/index.ts

@@ -1,5 +1,6 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
+export { sortAccountsByFiatValue } from "./sortAccountsByFiatValue";
 
 function isCorrespondingCurrency(
   elem: CryptoOrTokenCurrency,