@ledgerhq/live-common 34.51.0-nightly.8 → 34.51.0-nightly.9

package/src/modularDrawer/hooks/__tests__/useAcceptedCurrency.test.ts

@@ -0,0 +1,176 @@
+/**
+ * @jest-environment jsdom
+ */
+import { renderHook } from "@testing-library/react";
+import { useAcceptedCurrency } from "../useAcceptedCurrency";
+import { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { useCurrenciesUnderFeatureFlag } from "../useCurrenciesUnderFeatureFlag";
+import { isCurrencySupported } from "@ledgerhq/coin-framework/currencies/support";
+
+// Mock dependencies
+jest.mock("../useCurrenciesUnderFeatureFlag");
+jest.mock("@ledgerhq/coin-framework/currencies/support");
+
+const mockUseCurrenciesUnderFeatureFlag = useCurrenciesUnderFeatureFlag as jest.MockedFunction<
+  typeof useCurrenciesUnderFeatureFlag
+>;
+const mockIsCurrencySupported = isCurrencySupported as jest.MockedFunction<
+  typeof isCurrencySupported
+>;
+
+describe("useAcceptedCurrency", () => {
+  const mockCryptoCurrency: CryptoCurrency = {
+    id: "bitcoin",
+    name: "Bitcoin",
+    ticker: "BTC",
+    type: "CryptoCurrency",
+  } as CryptoCurrency;
+
+  const mockDeactivatedCurrency: CryptoCurrency = {
+    id: "ethereum",
+    name: "Ethereum",
+    ticker: "ETH",
+    type: "CryptoCurrency",
+  } as CryptoCurrency;
+
+  const mockTokenCurrency: TokenCurrency = {
+    id: "usdc",
+    name: "USD Coin",
+    ticker: "USDC",
+    type: "TokenCurrency",
+    parentCurrency: mockCryptoCurrency,
+  } as TokenCurrency;
+
+  const mockTokenWithDeactivatedParent: TokenCurrency = {
+    id: "weth",
+    name: "Wrapped Ethereum",
+    ticker: "WETH",
+    type: "TokenCurrency",
+    parentCurrency: mockDeactivatedCurrency,
+  } as TokenCurrency;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return true for a supported and non-deactivated currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockCryptoCurrency);
+
+    expect(isAccepted).toBe(true);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should return false for a deactivated currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["ethereum"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockDeactivatedCurrency);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockDeactivatedCurrency);
+  });
+
+  it("should return false for an unsupported currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(false);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockCryptoCurrency);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should return true for a token with an accepted parent currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockTokenCurrency);
+
+    expect(isAccepted).toBe(true);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should return false for a token with a deactivated parent currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["ethereum"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockTokenWithDeactivatedParent);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockDeactivatedCurrency);
+  });
+
+  it("should return false for a token with an unsupported parent currency", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(false);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+    const isAccepted = result.current(mockTokenCurrency);
+
+    expect(isAccepted).toBe(false);
+    expect(mockIsCurrencySupported).toHaveBeenCalledWith(mockCryptoCurrency);
+  });
+
+  it("should update when deactivatedCurrencyIds changes", () => {
+    const { result, rerender } = renderHook(() => useAcceptedCurrency());
+
+    // First render - currency is accepted
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set<string>(),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+    rerender();
+    expect(result.current(mockCryptoCurrency)).toBe(true);
+
+    // Second render - currency is deactivated
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["bitcoin"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    rerender();
+    expect(result.current(mockCryptoCurrency)).toBe(false);
+  });
+
+  it("should handle multiple currencies in deactivated set", () => {
+    mockUseCurrenciesUnderFeatureFlag.mockReturnValue({
+      deactivatedCurrencyIds: new Set(["ethereum", "cardano", "polkadot"]),
+      featureFlaggedCurrencies: {},
+    } as any);
+    mockIsCurrencySupported.mockReturnValue(true);
+
+    const { result } = renderHook(() => useAcceptedCurrency());
+
+    // Bitcoin should be accepted (not in deactivated set)
+    expect(result.current(mockCryptoCurrency)).toBe(true);
+
+    // Ethereum should be rejected (in deactivated set)
+    expect(result.current(mockDeactivatedCurrency)).toBe(false);
+  });
+});

package/src/modularDrawer/hooks/index.ts

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

package/src/modularDrawer/hooks/useAcceptedCurrency.ts

@@ -0,0 +1,28 @@
+import { useCallback } from "react";
+import { CryptoCurrency, CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { isCurrencySupported } from "@ledgerhq/coin-framework/currencies/support";
+import { useCurrenciesUnderFeatureFlag } from "./useCurrenciesUnderFeatureFlag";
+
+/**
+ * Hook that returns a predicate function to check if a currency or token is accepted.
+ * A currency is accepted if:
+ * - It is supported by the platform (via isCurrencySupported)
+ * - It is not deactivated by a feature flag
+ *
+ * For tokens, the parent currency is checked instead.
+ */
+export function useAcceptedCurrency() {
+  const { deactivatedCurrencyIds } = useCurrenciesUnderFeatureFlag();
+
+  const isAcceptedCurrency = useCallback(
+    (currencyOrToken: CryptoOrTokenCurrency): boolean => {
+      const currency: CryptoCurrency =
+        currencyOrToken.type === "TokenCurrency" ? currencyOrToken.parentCurrency : currencyOrToken;
+
+      return isCurrencySupported(currency) && !deactivatedCurrencyIds.has(currency.id);
+    },
+    [deactivatedCurrencyIds],
+  );
+
+  return isAcceptedCurrency;
+}

package/src/modularDrawer/hooks/useLeftAccounts.tsx

@@ -1,6 +1,5 @@
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { ReactNode } from "react";
-import { AccountModuleParams, AccountDataItem } from "../utils/type";
+import { AccountModuleParams, AccountDataItem, NetworkWithCount } from "../utils/type";
 
 export const createUseLeftAccountsModule = ({
   useAccountData,
@@ -9,13 +8,10 @@ export const createUseLeftAccountsModule = ({
   useAccountData: (params: AccountModuleParams) => AccountDataItem[];
   accountsCount: (args: { label: string }) => ReactNode;
 }) => {
-  return function useLeftAccountsModule(
-    params: AccountModuleParams,
-  ): Array<CryptoOrTokenCurrency & { leftElement?: ReactNode; count: number }> {
+  return function useLeftAccountsModule(params: AccountModuleParams): Array<NetworkWithCount> {
     const accountData = useAccountData(params);
 
-    return accountData.map(({ asset, label, count }) => ({
-      ...asset,
+    return accountData.map(({ label, count }) => ({
       leftElement: count > 0 ? accountsCount({ label }) : undefined,
       count,
     }));

package/src/modularDrawer/hooks/useLeftAccountsApy.tsx

@@ -5,15 +5,14 @@ import {
   NetworkWithCount,
 } from "../utils/type";
 import { useInterestRatesByCurrencies } from "../../dada-client/hooks/useInterestRatesByCurrencies";
-import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { getInterestRateForAsset } from "../utils/getInterestRateForAsset";
 
 export function useLeftAccountsApyModule(
   params: AccountModuleParams,
   useAccountData: (params: AccountModuleParams) => AccountDataItem[],
   accountsCountAndApy: CreateAccountsCountAndApy,
-  networks: CryptoOrTokenCurrency[],
-): NetworkWithCount[] {
+): Array<NetworkWithCount> {
+  const { networks } = params;
   const accountData = useAccountData(params);
   const interestRates = useInterestRatesByCurrencies(networks);
 
@@ -27,12 +26,10 @@ export function useLeftAccountsApyModule(
 
     if ((!interestRate || interestRatePercentageRounded <= 0) && count <= 0) {
       return {
-        ...asset,
         count,
       };
     }
     return {
-      ...asset,
       leftElement: accountsCountAndApy({
         label: count > 0 ? label : undefined,
         value: interestRatePercentageRounded,

package/src/modularDrawer/hooks/{useAssetAccountCounts.tsx → useNetworkAccountCounts.tsx}

@@ -5,26 +5,27 @@ import type { Account } from "@ledgerhq/types-live";
 import { WalletAPIAccount } from "../../wallet-api/types";
 
 type AccountModuleParams = {
-  assets: CryptoOrTokenCurrency[];
+  networks: CryptoOrTokenCurrency[];
   nestedAccounts: Account[];
   accountIds: Map<string, boolean> | undefined;
   formatLabel: (count: number) => string;
   accounts$?: Observable<WalletAPIAccount[]>;
 };
 
-export type AssetCountItem = {
+export type NetworkCountItem = {
   asset: CryptoOrTokenCurrency;
   label: string;
   count: number;
 };
 
-export const useAssetAccountCounts = ({
-  assets,
+export const useNetworkAccountCounts = ({
+  networks,
   nestedAccounts,
   accountIds,
   formatLabel,
-}: AccountModuleParams): AssetCountItem[] =>
-  assets.map(asset => {
+}: AccountModuleParams): NetworkCountItem[] =>
+  networks.map(network => {
+    const asset = network.type === "TokenCurrency" ? network.parentCurrency : network;
     const { length } = getAccountTuplesForCurrency(asset, nestedAccounts, accountIds);
     return {
       asset,

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,5 +1,5 @@
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { UseBalanceDeps, CreateBalanceItem } from "../utils/type";
+import { UseBalanceDeps, CreateBalanceItem, BalanceUI } from "../utils/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 import BigNumber from "bignumber.js";
 
@@ -13,7 +13,10 @@ type Params = {
 };
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({ networks }: Params) {
+  return function useRightBalanceNetwork({ networks }: Params): Array<{
+    rightElement?: React.ReactNode;
+    balanceData?: BalanceUI;
+  }> {
     const { flattenedAccounts, state, counterValueCurrency } = useBalanceDeps();
 
     const networkBalanceData = getBalanceAndFiatValueByAssets(
@@ -34,7 +37,6 @@ export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: Ne
       };
 
       return {
-        ...currency,
         rightElement: balanceItem(balanceData),
         balanceData,
       };

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

@@ -170,7 +170,7 @@ describe("createNetworkConfiguration", () => {
   it("should call balanceItem with correct BalanceUI objects for each network", () => {
     const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
     const res = result.current({ networksConfig: { rightElement: "balance" } });
-    res([baseCurrency, bscCurrency], [baseUsdcToken, bscUsdcToken]);
+    res([baseUsdcToken, bscUsdcToken]);
 
     expect(balanceItem).toHaveBeenCalledTimes(2);
     expect(balanceItem).toHaveBeenNthCalledWith(
@@ -186,7 +186,7 @@ describe("createNetworkConfiguration", () => {
   it("account count", () => {
     const { result } = renderHook(() => createNetworkConfigurationHook(networkConfigurationDeps));
     const res = result.current({ networksConfig: { leftElement: "numberOfAccounts" } });
-    res([baseCurrency, bscCurrency], [baseUsdcToken, bscUsdcToken]);
+    res([baseUsdcToken, bscUsdcToken]);
 
     expect(accountsCount).toHaveBeenCalledTimes(4);
     expect(accountsCount).toHaveBeenNthCalledWith(1, { label: "3 account" });
@@ -198,10 +198,7 @@ describe("createNetworkConfiguration", () => {
       networksConfig: { rightElement: "balance" },
     });
 
-    const orderedResult = res(
-      [ethereumCurrency, polygonCurrency, bscCurrency],
-      [ethereumUsdcToken, polygonUsdcToken, bscUsdcToken],
-    );
+    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken, bscUsdcToken]);
 
     expect(orderedResult).toHaveLength(3);
 
@@ -217,10 +214,7 @@ describe("createNetworkConfiguration", () => {
       networksConfig: { leftElement: "numberOfAccounts" },
     });
 
-    const orderedResult = res(
-      [ethereumCurrency, polygonCurrency, bscCurrency],
-      [ethereumUsdcToken, polygonUsdcToken, bscUsdcToken],
-    );
+    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken, bscUsdcToken]);
 
     expect(orderedResult).toHaveLength(3);
 
@@ -263,10 +257,7 @@ describe("createNetworkConfiguration", () => {
       networksConfig: { leftElement: "numberOfAccounts", rightElement: "balance" },
     });
 
-    const orderedResult = res(
-      [ethereumCurrency, polygonCurrency],
-      [ethereumUsdcToken, polygonUsdcToken],
-    );
+    const orderedResult = res([ethereumUsdcToken, polygonUsdcToken]);
 
     expect(orderedResult).toHaveLength(2);
 
@@ -336,10 +327,12 @@ describe("createNetworkConfiguration", () => {
       networksConfig: { leftElement: "numberOfAccounts", rightElement: "balance" },
     });
 
-    const orderedResult = res(
-      [testEthereumCurrency, testPolygonCurrency, testAvalancheCurrency, testArbitrumCurrency],
-      [testEthereumUsdcToken, testPolygonUsdcToken, testAvalancheUsdcToken, testArbitrumUsdcToken],
-    );
+    const orderedResult = res([
+      testEthereumUsdcToken,
+      testPolygonUsdcToken,
+      testAvalancheUsdcToken,
+      testArbitrumUsdcToken,
+    ]);
 
     expect(orderedResult[0].id).toBe(testEthereumCurrency.id); // 1000 ETH balance, 3 accounts
     expect(orderedResult[1].id).toBe(testPolygonCurrency.id); // 500 MATIC balance, 1 account

package/src/modularDrawer/modules/createNetworkConfiguration.ts

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

package/src/modularDrawer/utils/type.ts

@@ -58,7 +58,7 @@ export type CreateAccountsCountAndApy = (args: {
   type?: ApyType;
 }) => ReactNode;
 
-export type NetworkWithCount = CryptoOrTokenCurrency & {
+export type NetworkWithCount = {
   leftElement?: ReactNode;
   count: number;
 };
@@ -70,7 +70,7 @@ export type AccountDataItem = {
 };
 
 export type AccountModuleParams = {
-  assets: CryptoOrTokenCurrency[];
+  networks: CryptoOrTokenCurrency[];
   accounts$?: Observable<WalletAPIAccount[]>;
 };
 
@@ -79,14 +79,16 @@ export type CreateAccountsCount = (args: { label: string }) => ReactNode;
 export type UseAccountData = (params: AccountModuleParams) => AccountDataItem[];
 
 export type NetworkHookParams = {
-  assets: CryptoOrTokenCurrency[];
   networks: CryptoOrTokenCurrency[];
   accounts$?: Observable<WalletAPIAccount[]>;
 };
-// Network hook type that returns currency properties spread at top level
-export type NetworkHook = (
-  params: NetworkHookParams,
-) => Array<CryptoOrTokenCurrency & Network & { balanceData?: BalanceUI; count?: number }>;
+// Network hook type that returns additional properties to be merged with currencies
+export type NetworkHook = (params: NetworkHookParams) => Array<{
+  balanceData?: BalanceUI;
+  count?: number;
+  leftElement?: React.ReactNode;
+  rightElement?: React.ReactNode;
+}>;
 
 export type NetworkConfigurationDeps = {
   useAccountData: UseAccountData;
@@ -96,8 +98,8 @@ export type NetworkConfigurationDeps = {
   balanceItem: CreateBalanceItem;
 };
 
-export type LeftElementKind = "numberOfAccounts" | "numberOfAccountsAndApy" | "undefined";
-export type RightElementKind = "balance" | "undefined";
+export type NetworkLeftElementKind = "numberOfAccounts" | "numberOfAccountsAndApy" | "undefined";
+export type NetworkRightElementKind = "balance" | "undefined";
 
 export type Network = {
   name: string;

package/lib/DataModel.test.d.ts

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

package/lib/DataModel.test.d.ts.map

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