@ledgerhq/live-common 34.50.0-nightly.6 → 34.51.0-nightly.0

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

@@ -0,0 +1,228 @@
+import { groupAccountsByAsset } from "../groupAccountsByAsset";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+import BigNumber from "bignumber.js";
+import type { Account, TokenAccount } from "@ledgerhq/types-live";
+import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+
+// Mock calculate function
+jest.mock("@ledgerhq/live-countervalues/logic", () => ({
+  calculate: jest.fn((state, { value }) => {
+    // Mock: return the balance directly as fiat value for simple testing
+    return value;
+  }),
+}));
+
+describe("groupAccountsByAsset", () => {
+  const mockCurrency = createFixtureCryptoCurrency("bitcoin");
+  const mockEthCurrency = createFixtureCryptoCurrency("ethereum");
+
+  const mockCounterValuesState = {} as CounterValuesState;
+  const mockTargetCurrency = createFixtureCryptoCurrency("usd");
+
+  const mockUSDCToken = {
+    type: "TokenCurrency" as const,
+    id: "ethereum/erc20/usdc",
+    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    parentCurrency: mockEthCurrency,
+    tokenType: "erc20" as const,
+    name: "USD Coin",
+    ticker: "USDC",
+    units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
+  };
+
+  const mockBTCAccount: Account = {
+    type: "Account",
+    id: "btc-account-1",
+    seedIdentifier: "seed-id",
+    derivationMode: "",
+    currency: mockCurrency,
+    balance: new BigNumber(100000000), // 1 BTC
+    spendableBalance: new BigNumber(100000000),
+    blockHeight: 0,
+    operations: [],
+    operationsCount: 0,
+    pendingOperations: [],
+    index: 0,
+    freshAddress: "btc-address",
+    freshAddressPath: "44'/0'/0'/0/0",
+    used: true,
+    swapHistory: [],
+    nfts: [],
+    lastSyncDate: new Date(),
+    creationDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: { balances: [], latestDate: null },
+      DAY: { balances: [], latestDate: null },
+      WEEK: { balances: [], latestDate: null },
+    },
+  };
+
+  const mockUSDCAccount: TokenAccount = {
+    type: "TokenAccount",
+    id: "usdc-account-1",
+    token: mockUSDCToken,
+    parentId: "eth-account-1",
+    balance: new BigNumber(1000000), // 1 USDC
+    spendableBalance: new BigNumber(1000000),
+    operations: [],
+    operationsCount: 0,
+    pendingOperations: [],
+    swapHistory: [],
+    creationDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: { balances: [], latestDate: null },
+      DAY: { balances: [], latestDate: null },
+      WEEK: { balances: [], latestDate: null },
+    },
+  };
+
+  it("should group accounts by asset ID and aggregate balances", () => {
+    const accounts = [mockBTCAccount, mockUSDCAccount];
+    const result = groupAccountsByAsset(accounts, mockCounterValuesState, mockTargetCurrency);
+
+    expect(result).toEqual({
+      [mockCurrency.id]: {
+        totalBalance: new BigNumber(100000000), // 1 BTC in satoshis
+        totalFiatValue: new BigNumber(100000000), // Mock returns balance as fiat value
+        accounts: [mockBTCAccount],
+        referenceCurrency: mockCurrency,
+      },
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC in micro-USDC
+        totalFiatValue: new BigNumber(1000000), // Mock returns balance as fiat value
+        accounts: [mockUSDCAccount],
+        referenceCurrency: mockUSDCToken,
+      },
+    });
+  });
+
+  it("should aggregate multiple accounts with the same asset", () => {
+    const secondBTCAccount: Account = {
+      ...mockBTCAccount,
+      id: "btc-account-2",
+      balance: new BigNumber(50000000), // 0.5 BTC
+    };
+
+    const accounts = [mockBTCAccount, secondBTCAccount];
+    const result = groupAccountsByAsset(accounts, mockCounterValuesState, mockTargetCurrency);
+
+    expect(result[mockCurrency.id]).toEqual({
+      totalBalance: new BigNumber(150000000), // 1.5 BTC total
+      totalFiatValue: new BigNumber(150000000), // Mock returns balance as fiat value
+      accounts: [mockBTCAccount, secondBTCAccount],
+      referenceCurrency: mockCurrency,
+    });
+  });
+
+  it("should handle empty accounts array", () => {
+    const result = groupAccountsByAsset([], mockCounterValuesState, mockTargetCurrency);
+    expect(result).toEqual({});
+  });
+
+  it("should handle accounts with zero balance", () => {
+    const zeroBalanceAccount: Account = {
+      ...mockBTCAccount,
+      balance: new BigNumber(0),
+    };
+
+    const accounts = [zeroBalanceAccount];
+    const result = groupAccountsByAsset(accounts, mockCounterValuesState, mockTargetCurrency);
+
+    expect(result[mockCurrency.id]).toEqual({
+      totalBalance: new BigNumber(0),
+      totalFiatValue: new BigNumber(0), // Mock returns balance (0) as fiat value
+      accounts: [zeroBalanceAccount],
+      referenceCurrency: mockCurrency,
+    });
+  });
+
+  it("should set referenceCurrency to the first currency encountered for each asset group", () => {
+    const accounts = [mockBTCAccount, mockUSDCAccount];
+    const result = groupAccountsByAsset(accounts, mockCounterValuesState, mockTargetCurrency);
+
+    expect(result[mockCurrency.id].referenceCurrency).toEqual(mockCurrency);
+    expect(result[mockUSDCToken.id].referenceCurrency).toEqual(mockUSDCToken);
+  });
+
+  it("should normalize balances when tokens have different magnitudes", () => {
+    // Create BSC USDC with different magnitude (18 decimals instead of 6)
+    const mockBscUSDCToken = {
+      ...mockUSDCToken,
+      id: "bsc/bep20/usdc",
+      name: "USD Coin (BSC)",
+      ticker: "USDC",
+      units: [{ name: "USD Coin", code: "USDC", magnitude: 18 }], // 18 decimals
+    };
+
+    const mockEthUSDCAccount: TokenAccount = {
+      ...mockUSDCAccount,
+      id: "eth-usdc-account",
+      token: mockUSDCToken, // 6 decimals
+      balance: new BigNumber(1000000), // 1 USDC with 6 decimals
+    };
+
+    const mockBscUSDCAccount: TokenAccount = {
+      ...mockUSDCAccount,
+      id: "bsc-usdc-account",
+      token: mockBscUSDCToken, // 18 decimals
+      balance: new BigNumber("1000000000000000000"), // 1 USDC with 18 decimals
+    };
+
+    // Both should be grouped under the same token ID for this test
+    // First account (ETH USDC) becomes reference currency with 6 decimals
+    const accounts = [mockEthUSDCAccount, mockBscUSDCAccount];
+    const result = groupAccountsByAsset(accounts, mockCounterValuesState, mockTargetCurrency);
+
+    const ethGroup = result[mockUSDCToken.id];
+    expect(ethGroup.referenceCurrency).toEqual(mockUSDCToken); // First currency is reference
+    expect(ethGroup.accounts).toHaveLength(1);
+    expect(ethGroup.totalBalance).toEqual(new BigNumber(1000000)); // 1 USDC normalized to 6 decimals
+
+    const bscGroup = result[mockBscUSDCToken.id];
+    expect(bscGroup.referenceCurrency).toEqual(mockBscUSDCToken);
+    expect(bscGroup.accounts).toHaveLength(1);
+    expect(bscGroup.totalBalance).toEqual(new BigNumber("1000000000000000000")); // 1 USDC with 18 decimals
+  });
+
+  it("should normalize balances correctly when adding accounts with different magnitudes to same asset group", () => {
+    // Create two USDC tokens with same ID but different magnitudes
+    const ethUSDCToken = {
+      ...mockUSDCToken,
+      units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }], // 6 decimals
+    };
+
+    const bscUSDCToken = {
+      ...mockUSDCToken,
+      units: [{ name: "USD Coin", code: "USDC", magnitude: 18 }], // 18 decimals
+    };
+
+    const ethAccount: TokenAccount = {
+      ...mockUSDCAccount,
+      id: "eth-usdc",
+      token: ethUSDCToken,
+      balance: new BigNumber(1000000), // 1 USDC with 6 decimals
+    };
+
+    const bscAccount: TokenAccount = {
+      ...mockUSDCAccount,
+      id: "bsc-usdc",
+      token: bscUSDCToken,
+      balance: new BigNumber("1000000000000000000"), // 1 USDC with 18 decimals
+    };
+
+    // Process ETH account first to make it the reference currency
+    const accounts = [ethAccount, bscAccount];
+    const result = groupAccountsByAsset(accounts, mockCounterValuesState, mockTargetCurrency);
+
+    const group = result[mockUSDCToken.id];
+    expect(group.referenceCurrency).toEqual(ethUSDCToken); // First currency is reference (6 decimals)
+    expect(group.accounts).toHaveLength(2);
+
+    // BSC balance should be normalized from 18 decimals to 6 decimals
+    // 1000000000000000000 (18 decimals) -> 1000000 (6 decimals)
+    // magnitudeDiff = 6 - 18 = -12
+    // normalized = 1000000000000000000 * 10^(-12) = 1000000
+    const expectedTotal = new BigNumber(1000000).plus(new BigNumber(1000000)); // 2 USDC total
+    expect(group.totalBalance).toEqual(expectedTotal);
+  });
+});

package/src/modularDrawer/utils/calculateProviderTotal.ts

@@ -9,15 +9,26 @@ export const calculateProviderTotals = (
   let totalBalance = new BigNumber(0);
   let totalFiatValue = new BigNumber(0);
   let hasAccounts = false;
+  let referenceCurrency: CryptoOrTokenCurrency | null = null;
 
   for (const currency of currencies) {
     const assetGroup = groupedAccountsByAsset[currency.id];
     if (assetGroup?.accounts.length > 0) {
-      totalBalance = totalBalance.plus(assetGroup.totalBalance);
+      const refCurrency = referenceCurrency ?? assetGroup.referenceCurrency;
+      const magnitudeDiff =
+        refCurrency.units[0].magnitude - assetGroup.referenceCurrency.units[0].magnitude;
+      const normalizedBalance = assetGroup.totalBalance.shiftedBy(magnitudeDiff);
+
+      totalBalance = totalBalance.plus(normalizedBalance);
       totalFiatValue = totalFiatValue.plus(assetGroup.totalFiatValue);
       hasAccounts = true;
+
+      // Use the referenceCurrency from the first asset group with accounts
+      if (!referenceCurrency) {
+        referenceCurrency = assetGroup.referenceCurrency;
+      }
     }
   }
 
-  return { totalBalance, totalFiatValue, hasAccounts };
+  return { totalBalance, totalFiatValue, hasAccounts, referenceCurrency };
 };

package/src/modularDrawer/utils/getBalanceAndFiatValueByAssets.ts

@@ -1,14 +1,14 @@
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/lib-es/currencies/formatCurrencyUnit";
-import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
 import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
 import { groupAccountsByAsset, type GroupedAccount } from "./groupAccountsByAsset";
 import { AssetType } from "./type";
 import { AccountLike } from "@ledgerhq/types-live";
-import { counterValueFormatter } from "./counterValueFormatter";
+import BigNumber from "bignumber.js";
+import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
 
 interface ExtendedAssetType extends AssetType {
-  balance?: string;
-  fiatValue?: string;
+  currency?: CryptoOrTokenCurrency;
+  balance?: BigNumber;
+  fiatValue?: number;
 }
 
 export const getBalanceAndFiatValueByAssets = (
@@ -16,21 +16,14 @@ export const getBalanceAndFiatValueByAssets = (
   assets: CryptoOrTokenCurrency[],
   counterValuesState: CounterValuesState,
   targetCurrency: Currency,
-  isDiscreetMode: boolean = false,
-  userLocale: string,
 ): ExtendedAssetType[] => {
-  const groupedAccountsByAsset = groupAccountsByAsset(
-    accounts,
-    counterValuesState,
-    targetCurrency,
-    isDiscreetMode,
-  );
+  const groupedAccountsByAsset = groupAccountsByAsset(accounts, counterValuesState, targetCurrency);
 
   return assets.map(asset => {
     const assetGroup = groupedAccountsByAsset[asset.id];
 
     if (assetGroup) {
-      return formatAssetDetails(assetGroup, asset, targetCurrency, isDiscreetMode, userLocale);
+      return yieldAssetDetails(assetGroup, asset);
     }
 
     return {
@@ -41,36 +34,19 @@ export const getBalanceAndFiatValueByAssets = (
   });
 };
 
-const formatAssetDetails = (
+const yieldAssetDetails = (
   assetGroup: GroupedAccount,
   asset: CryptoOrTokenCurrency,
-  targetCurrency: Currency,
-  isDiscreetMode: boolean,
-  userLocale: string,
 ): ExtendedAssetType => {
-  const assetDetails =
-    assetGroup.accounts[0].type === "Account"
-      ? assetGroup.accounts[0].currency
-      : assetGroup.accounts[0].token;
-
-  const formattedBalance = formatCurrencyUnit(assetDetails.units[0], assetGroup.totalBalance, {
-    showCode: true,
-    discreet: isDiscreetMode,
-  });
-
-  const formattedFiatValue = counterValueFormatter({
-    currency: targetCurrency.ticker,
-    value: assetGroup.totalFiatValue.toNumber(),
-    locale: userLocale,
-    allowZeroValue: true,
-    discreetMode: isDiscreetMode,
-  });
+  // Use the reference currency for consistent magnitude
+  const assetDetails = assetGroup.referenceCurrency;
 
   return {
     id: asset.id,
     name: asset.name,
     ticker: asset.ticker,
-    balance: formattedBalance,
-    fiatValue: formattedFiatValue,
+    currency: assetDetails,
+    balance: assetGroup.totalBalance,
+    fiatValue: assetGroup.totalFiatValue.toNumber(),
   };
 };

package/src/modularDrawer/utils/groupAccountsByAsset.ts

@@ -1,51 +1,70 @@
-import { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
-import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
-import { Currency } from "@ledgerhq/types-cryptoassets";
 import { AccountLike } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
-import { parseToBigNumber } from "./parseToBigNumber";
+import type { CounterValuesState } from "@ledgerhq/live-countervalues/types";
+import { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
+import { calculate } from "@ledgerhq/live-countervalues/logic";
 
 export type GroupedAccount = {
   totalBalance: BigNumber;
   totalFiatValue: BigNumber;
   accounts: AccountLike[];
+  referenceCurrency: CryptoOrTokenCurrency; // Reference currency for magnitude normalization
 };
 
 export const groupAccountsByAsset = (
   accounts: AccountLike[],
   counterValuesState: CounterValuesState,
   targetCurrency: Currency,
-  isDiscreetMode: boolean,
 ): Record<string, GroupedAccount> => {
   const initialGroupedAccounts: Record<string, GroupedAccount> = {};
 
   return accounts.reduce((groupedAccounts, account) => {
     const assetId = account.type === "Account" ? account.currency.id : account.token.id;
 
-    if (!groupedAccounts[assetId]) {
-      groupedAccounts[assetId] = {
+    let assetGroup = groupedAccounts[assetId];
+    if (!assetGroup) {
+      const currency = account.type === "Account" ? account.currency : account.token;
+      assetGroup = groupedAccounts[assetId] = {
         totalBalance: new BigNumber(0),
         totalFiatValue: new BigNumber(0),
         accounts: [],
+        referenceCurrency: currency, // First currency becomes the reference
       };
     }
 
-    const { fiatValue } = getBalanceAndFiatValue(
-      account,
-      counterValuesState,
-      targetCurrency,
-      isDiscreetMode,
-      false,
-    );
+    const currency = account.type === "Account" ? account.currency : account.token;
     const balance = account.balance;
 
-    const parsedFiatValue = parseToBigNumber(fiatValue ?? "0");
+    // Convert balance to reference currency magnitude before summing
+    const referenceMagnitude = assetGroup.referenceCurrency.units[0].magnitude || 0;
+    const currentMagnitude = currency.units[0].magnitude || 0;
+    const magnitudeDiff = referenceMagnitude - currentMagnitude;
+    const normalizedBalance = balance.shiftedBy(magnitudeDiff);
 
-    groupedAccounts[assetId].totalBalance = groupedAccounts[assetId].totalBalance.plus(balance);
-    groupedAccounts[assetId].totalFiatValue =
-      groupedAccounts[assetId].totalFiatValue.plus(parsedFiatValue);
-    groupedAccounts[assetId].accounts.push(account);
+    const fiatValue = calculateFiatValue(account, counterValuesState, targetCurrency);
+
+    assetGroup.totalBalance = assetGroup.totalBalance.plus(normalizedBalance);
+    assetGroup.totalFiatValue = assetGroup.totalFiatValue.plus(fiatValue || 0);
+    assetGroup.accounts.push(account);
 
     return groupedAccounts;
   }, initialGroupedAccounts);
 };
+
+function calculateFiatValue(
+  account: AccountLike,
+  state: CounterValuesState,
+  toCurrency: Currency,
+): number {
+  const currency = account.type === "Account" ? account.currency : account.token;
+
+  const balanceNumber = account.balance.toNumber();
+
+  const fiatValue = calculate(state, {
+    from: currency,
+    to: toCurrency,
+    value: balanceNumber,
+  });
+
+  return fiatValue || 0;
+}

package/src/modularDrawer/utils/index.ts

@@ -1,6 +1,4 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-export { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
 export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
 
 function isCorrespondingCurrency(

package/src/modularDrawer/utils/sortByBalance.tsx

@@ -1,32 +1,19 @@
 import { BalanceUI } from "./type";
 
-export const parseFiatValue = (value?: string, discreet?: boolean) => {
-  if (!value || discreet) return -1;
-  return parseFloat(value.replace(/[^0-9.-]+/g, "")) || -1;
-};
-
-export function toFiatString(x?: BalanceUI): string | undefined {
-  return x && "fiatValue" in x ? String(x.fiatValue) : undefined;
-}
-
 export function hasBalance(balanceData?: BalanceUI): boolean {
-  return (
-    !!balanceData &&
-    (("fiatValue" in balanceData && !!balanceData.fiatValue) ||
-      ("balance" in balanceData && !!balanceData.balance))
-  );
+  return !!balanceData && balanceData.balance !== undefined && balanceData.balance.gt(0);
 }
 
 export function compareByBalanceThenFiat(
   a: BalanceUI | undefined,
   b: BalanceUI | undefined,
-  discreet: boolean,
 ): number {
   const ah = hasBalance(a);
   const bh = hasBalance(b);
   if (ah && !bh) return -1;
   if (!ah && bh) return 1;
-  const af = parseFiatValue(toFiatString(a), discreet);
-  const bf = parseFiatValue(toFiatString(b), discreet);
-  return bf - af;
+
+  const aFiat = a?.fiatValue ?? 0;
+  const bFiat = b?.fiatValue ?? 0;
+  return bFiat - aFiat;
 }

package/src/modularDrawer/utils/type.ts

@@ -1,5 +1,5 @@
 import { CounterValuesState } from "@ledgerhq/live-countervalues/lib/types";
-import { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
+import { CryptoOrTokenCurrency, Currency, Unit } from "@ledgerhq/types-cryptoassets";
 import { AccountLike } from "@ledgerhq/types-live";
 import { ReactNode } from "react";
 import { Observable } from "rxjs";
@@ -7,6 +7,7 @@ import { WalletAPIAccount } from "../../wallet-api/types";
 import { EnhancedModularDrawerConfiguration } from "../../wallet-api/ModularDrawer/types";
 import { InterestRate } from "../../dada-client/entities";
 import { MarketItemResponse } from "../../market/utils/types";
+import BigNumber from "bignumber.js";
 import { ApyType } from "../../dada-client/types/trend";
 
 export type AssetType = {
@@ -34,13 +35,21 @@ export type AssetWithBalance = AssetType & {
 
 export type UseBalanceDeps = () => {
   flattenedAccounts: AccountLike[];
-  discreet: boolean;
   state: CounterValuesState;
   counterValueCurrency: Currency;
   locale: string;
 };
 
-export type BalanceUI = { balance?: string; fiatValue?: string };
+export type BalanceUI = {
+  // Raw values
+  balance?: BigNumber;
+  fiatValue?: number;
+  fiatUnit?: Unit;
+  currency?: CryptoOrTokenCurrency;
+  // Formatting parameters
+  locale?: string;
+  discreet?: boolean;
+};
 export type CreateBalanceItem = (x: BalanceUI) => React.ReactNode;
 
 export type CreateAccountsCountAndApy = (args: {
@@ -111,7 +120,7 @@ export type AssetConfigurationDeps = {
   MarketPercentIndicator: (args: { percent: number }) => ReactNode;
   MarketPriceIndicator: (args: { price: string; percent: number }) => ReactNode;
   useBalanceDeps: UseBalanceDeps;
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   assetsMap: Map<
     string,
     { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }

package/src/wallet-api/Exchange/server.ts

@@ -567,9 +567,9 @@ export const handlers = ({
               targetCurrencyId: toCurrency?.id,
               hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
               swapAppVersion,
-              fromAccountId: fromAccount.id,
-              toAccountId: toAccount?.id,
-              amount: amountExpectedTo.toString(),
+              fromAccountAddress,
+              toAccountAddress,
+              fromAmount,
             });
 
             resolve({ operationHash, swapId });
@@ -586,11 +586,11 @@ export const handlers = ({
               hardwareWalletType: deviceInfo?.modelId as DeviceModelId,
               swapType: quoteId ? "fixed" : "float",
               swapAppVersion,
-              fromAccountId: fromAccount.id,
-              toAccountId: toAccount?.id,
+              fromAccountAddress,
+              toAccountAddress,
               refundAddress,
               payoutAddress,
-              amount: amountExpectedTo.toString(),
+              fromAmount,
               seedIdFrom: mainFromAccount.seedIdentifier,
               seedIdTo: toParentAccount?.seedIdentifier || (toAccount as Account)?.seedIdentifier,
             });

package/lib/modularDrawer/utils/__tests__/counterValueFormatter.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=counterValueFormatter.test.d.ts.map

package/lib/modularDrawer/utils/__tests__/counterValueFormatter.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"counterValueFormatter.test.d.ts","sourceRoot":"","sources":["../../../../src/modularDrawer/utils/__tests__/counterValueFormatter.test.ts"],"names":[],"mappings":""}