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

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

@@ -0,0 +1,237 @@
+import { calculateProviderTotals } from "../calculateProviderTotal";
+import { createFixtureCryptoCurrency } from "../../../mock/fixtures/cryptoCurrencies";
+import { genAccount } from "../../../mock/account";
+import BigNumber from "bignumber.js";
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+describe("calculateProviderTotals", () => {
+  const mockBTCCurrency = createFixtureCryptoCurrency("bitcoin");
+  const mockETHCurrency = createFixtureCryptoCurrency("ethereum");
+
+  const mockBTCAccount = genAccount("btc-account", { currency: mockBTCCurrency });
+  const mockUSDCAccount = genAccount("usdc-account", { currency: mockETHCurrency });
+  const mockBscUSDCAccount = genAccount("bsc-usdc-account", { currency: mockETHCurrency });
+
+  const mockUSDCToken: CryptoOrTokenCurrency = {
+    type: "TokenCurrency",
+    id: "ethereum/erc20/usdc",
+    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    parentCurrency: mockETHCurrency,
+    tokenType: "erc20",
+    name: "USD Coin",
+    ticker: "USDC",
+    units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
+  };
+
+  const mockBscUSDCToken: CryptoOrTokenCurrency = {
+    type: "TokenCurrency",
+    id: "bsc/bep20/usdc",
+    contractAddress: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+    parentCurrency: mockETHCurrency, // Using ETH as parent for simplicity
+    tokenType: "bep20",
+    name: "USD Coin (BSC)",
+    ticker: "USDC",
+    units: [{ name: "USD Coin", code: "USDC", magnitude: 18 }],
+  };
+
+  it("should return totals with hasAccounts false when no accounts exist", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {};
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result).toEqual({
+      totalBalance: new BigNumber(0),
+      totalFiatValue: new BigNumber(0),
+      hasAccounts: false,
+      referenceCurrency: null,
+    });
+  });
+
+  it("should sum totals across multiple currencies", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {
+      [mockBTCCurrency.id]: {
+        totalBalance: new BigNumber(100000000), // 1 BTC
+        totalFiatValue: new BigNumber(50000), // $50,000
+        accounts: [mockBTCAccount], // Non-empty accounts array
+        referenceCurrency: mockBTCCurrency,
+      },
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC
+        totalFiatValue: new BigNumber(1), // $1
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken,
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    // BTC (magnitude 8) sets reference, USDC (magnitude 6) gets normalized
+    // USDC: 1000000 * 10^(8-6) = 1000000 * 100 = 100000000
+    // Total: 100000000 (BTC) + 100000000 (normalized USDC) = 200000000
+    expect(result).toEqual({
+      totalBalance: new BigNumber(200000000), // Combined balance after magnitude normalization
+      totalFiatValue: new BigNumber(50001), // Combined fiat value
+      hasAccounts: true,
+      referenceCurrency: mockBTCCurrency, // First currency with accounts
+    });
+  });
+
+  it("should return referenceCurrency from first asset group with accounts", () => {
+    const currencies = [mockUSDCToken, mockBscUSDCToken];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken, // ETH USDC with 6 decimals
+      },
+      [mockBscUSDCToken.id]: {
+        totalBalance: new BigNumber("1000000000000000000"),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockBscUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockBscUSDCToken, // BSC USDC with 18 decimals
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result.referenceCurrency).toEqual(mockUSDCToken); // First currency
+    expect(result.hasAccounts).toBe(true);
+  });
+
+  it("should skip currencies with no accounts", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken,
+      },
+      // BTC has no entry in groupedAccounts
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result).toEqual({
+      totalBalance: new BigNumber(1000000), // Only USDC balance
+      totalFiatValue: new BigNumber(1), // Only USDC fiat value
+      hasAccounts: true,
+      referenceCurrency: mockUSDCToken,
+    });
+  });
+
+  it("should skip currencies with empty accounts array", () => {
+    const currencies = [mockBTCCurrency, mockUSDCToken];
+    const groupedAccounts = {
+      [mockBTCCurrency.id]: {
+        totalBalance: new BigNumber(100000000),
+        totalFiatValue: new BigNumber(50000),
+        accounts: [], // Empty accounts array should be skipped
+        referenceCurrency: mockBTCCurrency,
+      },
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000),
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount], // Non-empty accounts array
+        referenceCurrency: mockUSDCToken,
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result).toEqual({
+      totalBalance: new BigNumber(1000000), // Only USDC (non-empty accounts)
+      totalFiatValue: new BigNumber(1),
+      hasAccounts: true,
+      referenceCurrency: mockUSDCToken,
+    });
+  });
+
+  it("should normalize balances based on magnitude differences", () => {
+    // Test the specific code: magnitude normalization between currencies
+    const currencies = [mockUSDCToken, mockBscUSDCToken];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC with 6 decimals
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount],
+        referenceCurrency: mockUSDCToken, // 6 decimals
+      },
+      [mockBscUSDCToken.id]: {
+        totalBalance: new BigNumber("1000000000000000000"), // 1 USDC with 18 decimals
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockBscUSDCAccount],
+        referenceCurrency: mockBscUSDCToken, // 18 decimals
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    // First currency (USDC) sets reference magnitude of 6
+    // Second currency (BSC USDC) has magnitude 18, so diff = 6 - 18 = -12
+    // BSC balance of 1000000000000000000 shifted by -12 = 1000000
+    // Total should be 1000000 + 1000000 = 2000000
+    expect(result.totalBalance).toEqual(new BigNumber(2000000));
+    expect(result.totalFiatValue).toEqual(new BigNumber(2));
+    expect(result.hasAccounts).toBe(true);
+    expect(result.referenceCurrency).toEqual(mockUSDCToken);
+  });
+
+  it("should handle magnitude normalization when referenceCurrency is set", () => {
+    const currencies = [mockBscUSDCToken];
+    const groupedAccounts = {
+      [mockBscUSDCToken.id]: {
+        totalBalance: new BigNumber("2000000000000000000"),
+        totalFiatValue: new BigNumber(2),
+        accounts: [mockBscUSDCAccount],
+        referenceCurrency: mockBscUSDCToken,
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    expect(result.totalBalance).toEqual(new BigNumber("2000000000000000000"));
+    expect(result.referenceCurrency).toEqual(mockBscUSDCToken);
+  });
+
+  it("should handle zero magnitude difference correctly", () => {
+    const sameMagnitudeCurrency: CryptoOrTokenCurrency = {
+      type: "TokenCurrency",
+      id: "ethereum/erc20/usdc2",
+      contractAddress: "0x1234567890123456789012345678901234567890",
+      parentCurrency: mockETHCurrency,
+      tokenType: "erc20",
+      name: "USD Coin 2",
+      ticker: "USDC2",
+      units: [{ name: "USD Coin 2", code: "USDC2", magnitude: 6 }],
+    };
+
+    const mockSameMagnitudeAccount = genAccount("usdc2-account", { currency: mockETHCurrency });
+
+    const currencies = [mockUSDCToken, sameMagnitudeCurrency];
+    const groupedAccounts = {
+      [mockUSDCToken.id]: {
+        totalBalance: new BigNumber(1000000), // 1 USDC
+        totalFiatValue: new BigNumber(1),
+        accounts: [mockUSDCAccount],
+        referenceCurrency: mockUSDCToken, // 6 decimals
+      },
+      [sameMagnitudeCurrency.id]: {
+        totalBalance: new BigNumber(2000000), // 2 USDC2
+        totalFiatValue: new BigNumber(2),
+        accounts: [mockSameMagnitudeAccount],
+        referenceCurrency: sameMagnitudeCurrency, // 6 decimals
+      },
+    };
+
+    const result = calculateProviderTotals(currencies, groupedAccounts);
+
+    // Both have magnitude 6, so diff = 6 - 6 = 0
+    // No shifting needed, simple addition: 1000000 + 2000000 = 3000000
+    expect(result.totalBalance).toEqual(new BigNumber(3000000));
+    expect(result.totalFiatValue).toEqual(new BigNumber(3));
+  });
+});

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

@@ -10,10 +10,10 @@ import {
   safeCurrencyLookup,
 } from "../currencyUtils";
 import {
-  usdcToken,
   mockBaseCryptoCurrency,
   mockBtcCryptoCurrency,
   mockEthCryptoCurrency,
+  usdcToken,
 } from "../../__mocks__/currencies.mock";
 
 describe("safeCurrencyLookup", () => {

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

@@ -4,7 +4,7 @@ import {
   mockScrollCryptoCurrency,
   usdcToken,
 } from "../../__mocks__/currencies.mock";
-import { ApyType } from "../type";
+import { ApyType } from "../../../dada-client/types/trend";
 
 describe("getInterestRateForAsset", () => {
   const networks = [mockEthCryptoCurrency, usdcToken];

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/currencyUtils.ts

@@ -4,7 +4,6 @@ import { isTokenCurrency } from "../../currencies";
 import { CurrenciesByProviderId } from "../../deposit/type";
 
 export type ProviderCoverageMap = Map<string, Set<string>>;
-
 export const safeCurrencyLookup = (id: string): CryptoOrTokenCurrency | null => {
   try {
     return getTokenOrCryptoCurrencyById(id);

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/getInterestRateForAsset.ts

@@ -1,5 +1,5 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { ApyType } from "./type";
+import { ApyType } from "../../dada-client/types/trend";
 
 type InterestRate = { value: number; type: ApyType };
 type InterestRateResult = {