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

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -1,20 +1,14 @@
 import { useMemo } from "react";
-import type { ReactNode } from "react";
-import type { CryptoOrTokenCurrency, Currency } from "@ledgerhq/types-cryptoassets";
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/formatCurrencyUnit";
+import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import BigNumber from "bignumber.js";
-import { counterValueFormatter } from "../utils/counterValueFormatter";
 import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { UseBalanceDeps } from "../utils/type";
-import { buildProviderCurrenciesMap } from "../utils/buildProviderCurrenciesMap";
-import { CurrenciesByProviderId } from "../../deposit/type";
+import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { calculateProviderTotals } from "../utils/calculateProviderTotal";
-import { getProviderCurrency } from "../utils/getProviderCurrency";
 import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
 
 export type AssetDeps = {
   useBalanceDeps: UseBalanceDeps;
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   assetsMap: Map<
     string,
     { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
@@ -26,120 +20,50 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
     providerCurrency: CryptoOrTokenCurrency,
     totalBalance: BigNumber,
     totalFiatValue: BigNumber,
-    counterValueCurrency: Currency,
-    locale: string,
-    discreet: boolean,
   ) => {
-    const unit = providerCurrency.units?.[0];
-    const balance = unit
-      ? formatCurrencyUnit(unit, totalBalance, { showCode: true, discreet })
-      : `${totalBalance.toFixed()} ${providerCurrency.ticker ?? providerCurrency.symbol}`;
-    const fiatValue = counterValueFormatter({
-      currency: counterValueCurrency.ticker,
-      value: totalFiatValue.toNumber(),
-      locale,
-      allowZeroValue: true,
-    });
-    return { balance, fiatValue };
+    return {
+      currency: providerCurrency,
+      balance: totalBalance,
+      fiatValue: totalFiatValue.toNumber(),
+    };
   };
 
-  return function useRightBalanceAsset(
-    assets: CryptoOrTokenCurrency[],
-    currenciesByProvider: CurrenciesByProviderId[],
-  ) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+  return function useRightBalanceAsset(assets: CryptoOrTokenCurrency[]) {
+    const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
     const grouped = useMemo(
-      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency, discreet),
-      [flattenedAccounts, state, counterValueCurrency, discreet],
-    );
-
-    const providerMap = useMemo(
-      () => buildProviderCurrenciesMap(currenciesByProvider),
-      [currenciesByProvider],
+      () => groupAccountsByAsset(flattenedAccounts, state, counterValueCurrency),
+      [flattenedAccounts, state, counterValueCurrency],
     );
 
     return useMemo(() => {
-      if (!providerMap) {
-        const balanceMap = new Map();
-
-        for (const [, { currencies, mainCurrency }] of assetsMap) {
-          const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
-
-          const { balance, fiatValue } = formatProviderResult(
-            mainCurrency,
-            totalBalance,
-            totalFiatValue,
-            counterValueCurrency,
-            locale,
-            discreet,
-          );
-
-          balanceMap.set(mainCurrency.id, {
-            balance: balance,
-            fiatValue: fiatValue,
-          });
-        }
+      const balanceMap = new Map();
 
-        const assetsWithBalanceData = assets.map(asset => {
-          const balanceData = balanceMap.get(asset.id) || {};
-          return {
-            asset,
-            balanceData,
-          };
-        });
-
-        assetsWithBalanceData.sort((a, b) =>
-          compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-        );
-
-        return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-          ...asset,
-          rightElement: balanceItem(balanceData),
-        }));
-      }
-
-      const assetsSet = new Set(assets.map(a => a.id));
-      const providerResultsMap = new Map<string, { balance?: string; fiatValue?: string }>();
-
-      for (const [, { currencies, mainCurrency }] of providerMap) {
-        if (!assetsSet.has(mainCurrency.id)) continue;
-        const providerCurrency = getProviderCurrency(mainCurrency, currencies);
-        if (!providerCurrency) continue;
-
-        const { totalBalance, totalFiatValue, hasAccounts } = calculateProviderTotals(
+      for (const [, { currencies, mainCurrency }] of assetsMap) {
+        const { totalBalance, totalFiatValue, referenceCurrency } = calculateProviderTotals(
           currencies,
           grouped,
         );
-        if (!hasAccounts) continue;
 
-        const { balance, fiatValue } = formatProviderResult(
-          providerCurrency,
-          totalBalance,
-          totalFiatValue,
-          counterValueCurrency,
-          locale,
-          discreet,
-        );
-        providerResultsMap.set(mainCurrency.id, { balance, fiatValue });
+        // Use referenceCurrency from actual accounts if available, fallback to mainCurrency
+        const currencyToUse = referenceCurrency || mainCurrency;
+        const balanceData = formatProviderResult(currencyToUse, totalBalance, totalFiatValue);
+
+        balanceMap.set(mainCurrency.id, balanceData);
       }
 
       const assetsWithBalanceData = assets.map(asset => {
-        const balanceData = providerResultsMap.get(asset.id) || {};
+        const balanceData = balanceMap.get(asset.id) || {};
         return {
-          asset,
+          ...asset,
           balanceData,
+          rightElement: balanceItem(balanceData),
         };
       });
 
-      assetsWithBalanceData.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
+      return assetsWithBalanceData.sort((a, b) =>
+        compareByBalanceThenFiat(a.balanceData, b.balanceData),
       );
-
-      return assetsWithBalanceData.map(({ asset, balanceData }) => ({
-        ...asset,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [providerMap, assets, grouped, counterValueCurrency, locale, discreet]);
+    }, [assets, grouped]);
   };
 }

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,118 +1,37 @@
-import { useMemo, type ReactNode } from "react";
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { BalanceUI, UseBalanceDeps } from "../utils/type";
-import { CurrenciesByProviderId } from "../../deposit/type";
+import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 
 export type NetworkDeps = {
-  balanceItem: (asset: { fiatValue?: string; balance?: string }) => ReactNode;
+  balanceItem: CreateBalanceItem;
   useBalanceDeps: UseBalanceDeps;
 };
 
 type Params = {
-  assets: CryptoOrTokenCurrency[];
   networks: CryptoOrTokenCurrency[];
-  selectedAssetId: string;
-  currenciesByProvider: CurrenciesByProviderId[];
 };
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({
-    assets: networks,
-    selectedAssetId,
-    currenciesByProvider,
-    networks: actualNetworks,
-  }: Params) {
-    const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
+  return function useRightBalanceNetwork({ networks }: Params) {
+    const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
-    return useMemo(() => {
-      if (currenciesByProvider && currenciesByProvider.length > 0) {
-        const providerOfSelectedAsset = currenciesByProvider.find(provider =>
-          provider.currenciesByNetwork.some(currency => currency.id === selectedAssetId),
-        );
-
-        if (providerOfSelectedAsset) {
-          const pairs = networks.map(network => ({
-            network,
-            asset: providerOfSelectedAsset.currenciesByNetwork.find(currency =>
-              currency.type === "TokenCurrency"
-                ? currency.parentCurrency.id === network.id
-                : currency.id === network.id,
-            ),
-          }));
-
-          const validAssets = pairs.filter(p => p.asset).map(p => p.asset!);
-
-          const allBalanceData =
-            validAssets.length > 0
-              ? getBalanceAndFiatValueByAssets(
-                  flattenedAccounts,
-                  validAssets,
-                  state,
-                  counterValueCurrency,
-                  discreet,
-                  locale,
-                )
-              : [];
-
-          const balanceMap = new Map(allBalanceData.map(b => [b.id, b]));
-
-          const networkWithBalanceData = pairs.map(({ network, asset }) => {
-            const balanceData: BalanceUI = asset ? balanceMap.get(asset.id) || {} : {};
-            return {
-              network,
-              balanceData,
-            };
-          });
-
-          networkWithBalanceData.sort((a, b) =>
-            compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-          );
-
-          return networkWithBalanceData.map(({ network, balanceData }) => ({
-            ...network,
-            rightElement: balanceItem(balanceData),
-          }));
-        }
-      }
-
-      const networkBalanceData = getBalanceAndFiatValueByAssets(
-        flattenedAccounts,
-        actualNetworks,
-        state,
-        counterValueCurrency,
-        discreet,
-        locale,
-      );
-
-      const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
-
-      const networksWithBalance = actualNetworks.map(network => {
-        const balanceData = balanceMap.get(network.id) || {};
-        return {
-          network,
-          balanceData,
-        };
-      });
-
-      networksWithBalance.sort((a, b) =>
-        compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
-      );
-
-      return networksWithBalance.map(({ network, balanceData }) => ({
-        ...network,
-        rightElement: balanceItem(balanceData),
-      }));
-    }, [
-      networks,
-      selectedAssetId,
-      currenciesByProvider,
+    const networkBalanceData = getBalanceAndFiatValueByAssets(
       flattenedAccounts,
+      networks,
       state,
       counterValueCurrency,
-      discreet,
-      locale,
-    ]);
+    );
+
+    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;
+      return {
+        ...details,
+        rightElement: balanceItem(balanceData),
+        balanceData: balanceData,
+      };
+    });
   };
 }

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -1,6 +1,5 @@
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { AssetType, CreateAssetConfigurationHook, AssetConfigurationDeps } from "../utils/type";
-import { CurrenciesByProviderId } from "../../deposit/type";
 import { composeHooks } from "../../utils/composeHooks";
 import { useLeftApyModule } from "../hooks/modules/useLeftApyModule";
 import { createUseRightBalanceAsset } from "../hooks/useRightBalanceAsset";
@@ -46,7 +45,7 @@ const getLeftElement =
 
 const createAssetConfigurationHook: CreateAssetConfigurationHook =
   deps =>
-  ({ assetsConfiguration, currenciesByProvider }) => {
+  ({ assetsConfiguration }) => {
     const { rightElement, leftElement } = assetsConfiguration ?? {};
 
     const rightHook = getRightElement(deps)(rightElement);
@@ -54,18 +53,11 @@ const createAssetConfigurationHook: CreateAssetConfigurationHook =
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const hooks = [rightHook, leftHook].filter(Boolean) as Array<
-      (
-        assets: CryptoOrTokenCurrency[],
-        currenciesByProvider?: CurrenciesByProviderId[],
-      ) => AssetType[]
+      (assets: CryptoOrTokenCurrency[]) => AssetType[]
     >;
 
     return (assets: CryptoOrTokenCurrency[]) => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(
-        ...hooks.map(
-          hook => (assets: CryptoOrTokenCurrency[]) => hook(assets, currenciesByProvider),
-        ),
-      );
+      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(...hooks);
       return composedHook(assets);
     };
   };

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -10,8 +10,10 @@ import {
   NetworkHook,
   RightElementKind,
   AccountModuleParams,
+  BalanceUI,
 } from "../utils/type";
 import { composeHooks } from "../../utils/composeHooks";
+import { compareByBalanceThenFiat } from "../utils/sortByBalance";
 
 export const getLeftElement =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
@@ -53,12 +55,7 @@ export const getRightElement =
 
 export const createNetworkConfigurationHook =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  ({
-    networksConfig,
-    selectedAssetId,
-    currenciesByProvider,
-    accounts$,
-  }: CreateNetworkConfigurationHookProps) => {
+  ({ networksConfig, accounts$ }: CreateNetworkConfigurationHookProps) => {
     const { leftElement, rightElement } = networksConfig ?? {};
     const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
     const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
@@ -70,18 +67,37 @@ export const createNetworkConfigurationHook =
       assets: CryptoOrTokenCurrency[],
       networks: CryptoOrTokenCurrency[],
     ): Array<CryptoOrTokenCurrency & Network> => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, Network>(
+      const composedHook = composeHooks<
+        CryptoOrTokenCurrency,
+        Network & { balanceData?: BalanceUI; count?: number }
+      >(
         ...hooks.map(
           hook => () =>
             hook({
               assets,
-              selectedAssetId,
-              currenciesByProvider: currenciesByProvider || [],
               accounts$,
               networks,
             }),
         ),
       );
-      return composedHook(assets);
+
+      const result = composedHook(assets);
+
+      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));
+      }
+
+      return result;
     };
   };

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];