@ledgerhq/live-common 34.51.0-nightly.2 → 34.51.0-nightly.3

package/src/modularDrawer/hooks/__tests__/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/index.ts

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

package/src/modularDrawer/hooks/useDetailedAccountsCore.ts

@@ -0,0 +1,146 @@
+import { useCallback } from "react";
+import { AccountLike } from "@ledgerhq/types-live";
+import { Currency } from "@ledgerhq/types-cryptoassets";
+import { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+import { calculate } from "@ledgerhq/live-countervalues/logic";
+import { getTagDerivationMode } from "@ledgerhq/coin-framework/derivation";
+import {
+  BaseRawDetailedAccount,
+  ExtendedRawDetailedAccount,
+  CreateDetailedAccountsParams,
+} from "../types/detailedAccount";
+import { sortAccountsByFiatValue } from "../utils/sortAccountsByFiatValue";
+
+/**
+ * Core hook for creating detailed accounts with shared logic
+ * This contains the business logic that can be reused across platforms
+ */
+export function useDetailedAccountsCore(
+  counterValuesState: CounterValuesState,
+  counterValueCurrency: Currency,
+) {
+  /**
+   * Calculate fiat value for an account using counter values
+   */
+  const calculateFiatValue = useCallback(
+    (account: AccountLike): number => {
+      const currency = account.type === "Account" ? account.currency : account.token;
+      const fiatValue = calculate(counterValuesState, {
+        from: currency,
+        to: counterValueCurrency,
+        value: account.balance.toNumber(),
+      });
+      return fiatValue || 0;
+    },
+    [counterValuesState, counterValueCurrency],
+  );
+
+  /**
+   * Create base detailed accounts from account tuples
+   * This is the core transformation logic shared between platforms
+   */
+  const createBaseDetailedAccounts = useCallback(
+    (params: CreateDetailedAccountsParams): BaseRawDetailedAccount[] => {
+      const { accountTuples, accountNameMap, isTokenCurrency } = params;
+
+      const baseAccounts = accountTuples.map(tuple => {
+        const { account, subAccount } = tuple;
+        const address = account.freshAddress;
+
+        if (isTokenCurrency && subAccount) {
+          const parentAccountName = accountNameMap[account.id];
+          const details = subAccount.token;
+
+          return {
+            id: subAccount.id,
+            name: parentAccountName ?? details.name,
+            ticker: details.ticker,
+            balance: subAccount.balance,
+            balanceUnit: subAccount.token.units[0],
+            fiatValue: calculateFiatValue(subAccount),
+            address,
+            cryptoId: details.id,
+            parentId: details.parentCurrency.id,
+          };
+        } else {
+          const accountName = accountNameMap[account.id];
+          const details = account.currency;
+
+          return {
+            id: account.id,
+            name: accountName ?? details.name,
+            ticker: details.ticker,
+            balance: account.balance,
+            balanceUnit: account.currency.units[0],
+            fiatValue: calculateFiatValue(account),
+            address,
+            cryptoId: details.id,
+          };
+        }
+      });
+
+      return sortAccountsByFiatValue(baseAccounts);
+    },
+    [calculateFiatValue],
+  );
+
+  /**
+   * Create extended detailed accounts that include account references
+   * Used by mobile implementation that needs access to the full account objects
+   */
+  const createExtendedDetailedAccounts = useCallback(
+    (params: CreateDetailedAccountsParams): ExtendedRawDetailedAccount[] => {
+      const { accountTuples, accountNameMap, isTokenCurrency } = params;
+
+      const extendedAccounts = accountTuples.map(tuple => {
+        const { account, subAccount } = tuple;
+        const protocol = getTagDerivationMode(account.currency, account.derivationMode) ?? "";
+        const address = account.freshAddress;
+
+        if (isTokenCurrency && subAccount) {
+          const parentAccountName = accountNameMap[account.id];
+          const details = subAccount.token;
+
+          return {
+            id: subAccount.id,
+            name: parentAccountName ?? details.name,
+            ticker: details.ticker,
+            balance: subAccount.balance,
+            balanceUnit: subAccount.token.units[0],
+            fiatValue: calculateFiatValue(subAccount),
+            address,
+            cryptoId: details.id,
+            parentId: details.parentCurrency.id,
+            account: subAccount,
+            parentAccount: account,
+          };
+        } else {
+          const accountName = accountNameMap[account.id];
+          const details = account.currency;
+
+          return {
+            id: account.id,
+            name: accountName ?? details.name,
+            ticker: details.ticker,
+            balance: account.balance,
+            balanceUnit: account.currency.units[0],
+            fiatValue: calculateFiatValue(account),
+            address,
+            cryptoId: details.id,
+            account,
+            protocol,
+          };
+        }
+      });
+
+      return sortAccountsByFiatValue(extendedAccounts);
+    },
+    [calculateFiatValue],
+  );
+
+  return {
+    calculateFiatValue,
+    createBaseDetailedAccounts,
+    createExtendedDetailedAccounts,
+  };
+}

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -53,7 +53,11 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
       }
 
       const assetsWithBalanceData = assets.map(asset => {
-        const balanceData = balanceMap.get(asset.id) || {};
+        const balanceData = balanceMap.get(asset.id) || {
+          currency: asset,
+          balance: new BigNumber(0),
+          fiatValue: 0,
+        };
         return {
           ...asset,
           balanceData,

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,6 +1,7 @@
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
+import BigNumber from "bignumber.js";
 
 export type NetworkDeps = {
   balanceItem: CreateBalanceItem;
@@ -25,12 +26,17 @@ export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: Ne
     const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
 
     return networks.map(network => {
-      const balanceData = balanceMap.get(network.id) || {};
-      const details = network.type === "TokenCurrency" ? network.parentCurrency : network;
+      const currency = network.type === "TokenCurrency" ? network.parentCurrency : network;
+      const balanceData = balanceMap.get(network.id) || {
+        currency,
+        balance: new BigNumber(0),
+        fiatValue: 0,
+      };
+
       return {
-        ...details,
+        ...currency,
         rightElement: balanceItem(balanceData),
-        balanceData: balanceData,
+        balanceData,
       };
     });
   };

package/src/modularDrawer/index.ts

@@ -0,0 +1,3 @@
+export * from "./hooks";
+export * from "./types";
+export * from "./utils";