@ledgerhq/live-common 34.50.0-nightly.5 → 34.50.0

package/src/generated/bridge/js.ts

@@ -17,6 +17,7 @@ import { bridge as near } from "../../families/near/setup";
 import { bridge as polkadot } from "../../families/polkadot/setup";
 import { bridge as solana } from "../../families/solana/setup";
 import { bridge as stacks } from "../../families/stacks/setup";
+import { bridge as tezos } from "../../families/tezos/setup";
 import { bridge as ton } from "../../families/ton/setup";
 import { bridge as tron } from "../../families/tron/setup";
 import { bridge as vechain } from "../../families/vechain/setup";
@@ -43,6 +44,7 @@ export default {
   polkadot,
   solana,
   stacks,
+  tezos,
   ton,
   tron,
   vechain,

package/src/hw/actions/completeExchange.ts

@@ -3,7 +3,6 @@ import { scan, tap } from "rxjs/operators";
 import { useEffect, useState } from "react";
 import type { Action, Device } from "./types";
 import type { AppState } from "./app";
-import type { DeviceModelId } from "@ledgerhq/devices";
 import { log } from "@ledgerhq/logs";
 import { Exchange } from "../../exchange/types";
 import { Transaction } from "../../generated/types";
@@ -19,7 +18,6 @@ type State = {
 
 type CompleteExchangeState = AppState & State;
 type CompleteExchangeRequest = {
-  deviceModelId?: DeviceModelId;
   deviceId?: string;
   provider: string;
   transaction: Transaction;
@@ -132,7 +130,6 @@ export const createAction = (
         }),
         completeExchangeExec({
           deviceId: reduxDeviceFrozen?.deviceId,
-          deviceModelId: reduxDeviceFrozen?.modelId,
           provider,
           transaction,
           binaryPayload,

package/src/hw/signMessage/index.ts

@@ -13,7 +13,6 @@ import type { ConnectAppEvent, Input as ConnectAppInput } from "../connectApp";
 import { withDevice } from "../deviceAccess";
 import type { SignMessage, Result } from "./types";
 import { messageSigner as ACREMessageSigner } from "../../families/bitcoin/ACRESetup";
-import { decodeAccountId } from "../../account";
 
 export const prepareMessageToSign = (account: Account, message: string): AnyMessage => {
   const utf8Message = Buffer.from(message, "hex").toString();
@@ -92,15 +91,6 @@ export const signMessageExec = ({ request, deviceId }: Input): Observable<Result
     throw new Error("account is required");
   }
 
-  const { type } = decodeAccountId(request.account.id);
-  if (type === "mock") {
-    return from(
-      Promise.resolve({
-        signature: "mockedSignature",
-      }),
-    );
-  }
-
   const result: Observable<Result> = withDevice(deviceId)(transport =>
     from(signMessage(transport, request.account!, request.message)),
   );

package/src/modularDrawer/hooks/useRightBalanceAsset.tsx

@@ -1,11 +1,15 @@
-import { useMemo, type ReactNode } from "react";
+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 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 { calculateProviderTotals } from "../utils/calculateProviderTotal";
+import { getProviderCurrency } from "../utils/getProviderCurrency";
 import { groupAccountsByAsset } from "../utils/groupAccountsByAsset";
 
 export type AssetDeps = {
@@ -39,7 +43,10 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
     return { balance, fiatValue };
   };
 
-  return function useRightBalanceAsset(assets: CryptoOrTokenCurrency[]) {
+  return function useRightBalanceAsset(
+    assets: CryptoOrTokenCurrency[],
+    currenciesByProvider: CurrenciesByProviderId[],
+  ) {
     const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
 
     const grouped = useMemo(
@@ -47,39 +54,92 @@ export function createUseRightBalanceAsset({ useBalanceDeps, balanceItem, assets
       [flattenedAccounts, state, counterValueCurrency, discreet],
     );
 
+    const providerMap = useMemo(
+      () => buildProviderCurrenciesMap(currenciesByProvider),
+      [currenciesByProvider],
+    );
+
     return useMemo(() => {
-      const balanceMap = new Map();
+      if (!providerMap) {
+        const balanceMap = new Map();
+
+        for (const [, { currencies, mainCurrency }] of assetsMap) {
+          const { totalBalance, totalFiatValue } = calculateProviderTotals(currencies, grouped);
 
-      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 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(
+          currencies,
+          grouped,
+        );
+        if (!hasAccounts) continue;
 
         const { balance, fiatValue } = formatProviderResult(
-          mainCurrency,
+          providerCurrency,
           totalBalance,
           totalFiatValue,
           counterValueCurrency,
           locale,
           discreet,
         );
-
-        balanceMap.set(mainCurrency.id, {
-          balance: balance,
-          fiatValue: fiatValue,
-        });
+        providerResultsMap.set(mainCurrency.id, { balance, fiatValue });
       }
 
       const assetsWithBalanceData = assets.map(asset => {
-        const balanceData = balanceMap.get(asset.id) || {};
+        const balanceData = providerResultsMap.get(asset.id) || {};
         return {
-          ...asset,
+          asset,
           balanceData,
-          rightElement: balanceItem(balanceData),
         };
       });
 
-      return assetsWithBalanceData.sort((a, b) =>
+      assetsWithBalanceData.sort((a, b) =>
         compareByBalanceThenFiat(a.balanceData, b.balanceData, discreet),
       );
-    }, [assets, grouped, counterValueCurrency, locale, discreet]);
+
+      return assetsWithBalanceData.map(({ asset, balanceData }) => ({
+        ...asset,
+        rightElement: balanceItem(balanceData),
+      }));
+    }, [providerMap, assets, grouped, counterValueCurrency, locale, discreet]);
   };
 }

package/src/modularDrawer/hooks/useRightBalanceNetwork.tsx

@@ -1,7 +1,8 @@
-import { type ReactNode } from "react";
+import { useMemo, type ReactNode } from "react";
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 import { compareByBalanceThenFiat } from "../utils/sortByBalance";
-import { UseBalanceDeps } from "../utils/type";
+import { BalanceUI, UseBalanceDeps } from "../utils/type";
+import { CurrenciesByProviderId } from "../../deposit/type";
 import { getBalanceAndFiatValueByAssets } from "../utils/getBalanceAndFiatValueByAssets";
 
 export type NetworkDeps = {
@@ -10,39 +11,108 @@ export type NetworkDeps = {
 };
 
 type Params = {
+  assets: CryptoOrTokenCurrency[];
   networks: CryptoOrTokenCurrency[];
+  selectedAssetId: string;
+  currenciesByProvider: CurrenciesByProviderId[];
 };
 
 export function createUseRightBalanceNetwork({ useBalanceDeps, balanceItem }: NetworkDeps) {
-  return function useRightBalanceNetwork({ networks }: Params) {
+  return function useRightBalanceNetwork({
+    assets: networks,
+    selectedAssetId,
+    currenciesByProvider,
+    networks: actualNetworks,
+  }: Params) {
     const { flattenedAccounts, discreet, state, counterValueCurrency, locale } = useBalanceDeps();
 
-    const networkBalanceData = getBalanceAndFiatValueByAssets(
-      flattenedAccounts,
+    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,
+      flattenedAccounts,
       state,
       counterValueCurrency,
       discreet,
       locale,
-    );
-
-    const balanceMap = new Map(networkBalanceData.map(b => [b.id, b]));
-
-    const networksWithBalance = networks.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),
-    }));
+    ]);
   };
 }

package/src/modularDrawer/modules/createAssetConfiguration.ts

@@ -1,5 +1,6 @@
 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";
@@ -45,7 +46,7 @@ const getLeftElement =
 
 const createAssetConfigurationHook: CreateAssetConfigurationHook =
   deps =>
-  ({ assetsConfiguration }) => {
+  ({ assetsConfiguration, currenciesByProvider }) => {
     const { rightElement, leftElement } = assetsConfiguration ?? {};
 
     const rightHook = getRightElement(deps)(rightElement);
@@ -53,11 +54,18 @@ const createAssetConfigurationHook: CreateAssetConfigurationHook =
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const hooks = [rightHook, leftHook].filter(Boolean) as Array<
-      (assets: CryptoOrTokenCurrency[]) => AssetType[]
+      (
+        assets: CryptoOrTokenCurrency[],
+        currenciesByProvider?: CurrenciesByProviderId[],
+      ) => AssetType[]
     >;
 
     return (assets: CryptoOrTokenCurrency[]) => {
-      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(...hooks);
+      const composedHook = composeHooks<CryptoOrTokenCurrency, AssetType>(
+        ...hooks.map(
+          hook => (assets: CryptoOrTokenCurrency[]) => hook(assets, currenciesByProvider),
+        ),
+      );
       return composedHook(assets);
     };
   };

package/src/modularDrawer/modules/createNetworkConfiguration.ts

@@ -53,7 +53,12 @@ export const getRightElement =
 
 export const createNetworkConfigurationHook =
   (NetworkConfigurationDeps: NetworkConfigurationDeps) =>
-  ({ networksConfig, accounts$ }: CreateNetworkConfigurationHookProps) => {
+  ({
+    networksConfig,
+    selectedAssetId,
+    currenciesByProvider,
+    accounts$,
+  }: CreateNetworkConfigurationHookProps) => {
     const { leftElement, rightElement } = networksConfig ?? {};
     const leftHook = getLeftElement(NetworkConfigurationDeps)(leftElement);
     const rightHook = getRightElement(NetworkConfigurationDeps)(rightElement);
@@ -70,6 +75,8 @@ export const createNetworkConfigurationHook =
           hook => () =>
             hook({
               assets,
+              selectedAssetId,
+              currenciesByProvider: currenciesByProvider || [],
               accounts$,
               networks,
             }),

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__/haveOneCommonProvider.test.ts

@@ -0,0 +1,34 @@
+import { haveOneCommonProvider } from "../haveOneCommonProvider";
+import { useGroupedCurrenciesByProvider } from "../../__mocks__/useGroupedCurrenciesByProvider.mock";
+import { LoadingBasedGroupedCurrencies } from "../../../deposit/type";
+
+jest.mock("../../../deposit/useGroupedCurrenciesByProvider.hook", () => ({
+  useGroupedCurrenciesByProvider: () => useGroupedCurrenciesByProvider(),
+}));
+
+describe("haveOneCommonProvider", () => {
+  it("should return false for an empty array", () => {
+    expect(haveOneCommonProvider([], [])).toBe(false);
+  });
+
+  it("should return true for a single currency with one provider", () => {
+    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
+    const { currenciesByProvider } = result;
+
+    expect(haveOneCommonProvider(["bitcoin"], currenciesByProvider)).toBe(true);
+  });
+
+  it("should return false for multiple currencies with different providers", () => {
+    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
+    const { currenciesByProvider } = result;
+
+    expect(haveOneCommonProvider(["bitcoin", "ethereum"], currenciesByProvider)).toBe(false);
+  });
+
+  it("should return true for multiple currencies with the same provider", () => {
+    const { result } = useGroupedCurrenciesByProvider(true) as LoadingBasedGroupedCurrencies;
+    const { currenciesByProvider } = result;
+
+    expect(haveOneCommonProvider(["ethereum", "arbitrum"], currenciesByProvider)).toBe(true);
+  });
+});

package/src/modularDrawer/utils/buildProviderCurrenciesMap.tsx

@@ -0,0 +1,25 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+export const buildProviderCurrenciesMap = (
+  currenciesByProvider?: Array<{
+    providerId: string;
+    currenciesByNetwork?: CryptoOrTokenCurrency[];
+  }>,
+) => {
+  if (!currenciesByProvider?.length) return null;
+
+  const map = new Map<
+    string,
+    { mainCurrency: CryptoOrTokenCurrency; currencies: CryptoOrTokenCurrency[] }
+  >();
+
+  currenciesByProvider.forEach(({ providerId, currenciesByNetwork = [] }) => {
+    if (currenciesByNetwork.length > 0) {
+      const mainCurrency =
+        currenciesByNetwork.find(c => c.id === providerId) ?? currenciesByNetwork[0];
+      map.set(providerId, { mainCurrency, currencies: currenciesByNetwork });
+    }
+  });
+
+  return map;
+};

package/src/modularDrawer/utils/currencyUtils.ts

@@ -4,6 +4,7 @@ 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/getProviderCurrency.ts

@@ -0,0 +1,13 @@
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { getTokenOrCryptoCurrencyById } from "../../deposit/helper";
+
+export const getProviderCurrency = (
+  mainCurrency: CryptoOrTokenCurrency,
+  currencies: CryptoOrTokenCurrency[],
+) => {
+  try {
+    return getTokenOrCryptoCurrencyById(mainCurrency.id);
+  } catch {
+    return getTokenOrCryptoCurrencyById(currencies[0].id);
+  }
+};

package/src/modularDrawer/utils/haveOneCommonProvider.ts

@@ -0,0 +1,31 @@
+import { CurrenciesByProviderId } from "../../deposit/type";
+
+/**
+ * This function checks if all currencies in the provided array
+ * it stopped at the first currency that does not match to prevent unnecessary iterations.
+ *
+ * @param currenciesIdsArray array of currency IDs to check
+ * @param currenciesByProvider array of currencies grouped by provider
+ * @returns boolean indicating whether all currencies in the array have one common provider
+ */
+export const haveOneCommonProvider = (
+  currenciesIdsArray: string[],
+  currenciesByProvider: CurrenciesByProviderId[],
+): boolean => {
+  if (currenciesIdsArray.length === 0) return false;
+
+  const providerIds = new Set<string>();
+
+  for (const currencyId of currenciesIdsArray) {
+    for (const provider of currenciesByProvider) {
+      if (provider.currenciesByNetwork.some(currency => currency.id === currencyId)) {
+        providerIds.add(provider.providerId);
+        if (providerIds.size > 1) {
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+};

package/src/modularDrawer/utils/index.test.ts

@@ -1,8 +1,9 @@
-import { isCorrespondingCurrency } from "./index";
+import { isCorrespondingCurrency, getEffectiveCurrency } from "./index";
 
 import { createFixtureCryptoCurrency } from "../../mock/fixtures/cryptoCurrencies";
 import { cryptocurrenciesById } from "@ledgerhq/cryptoassets";
 import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { CurrenciesByProviderId } from "../../deposit/type";
 
 describe("isCorrespondingCurrency", () => {
   const evmCurrency = createFixtureCryptoCurrency("evm");
@@ -41,3 +42,33 @@ describe("isCorrespondingCurrency", () => {
     expect(isCorrespondingCurrency(bitcoinCurrency, evmCurrency)).toBe(false);
   });
 });
+
+describe("getEffectiveCurrency", () => {
+  const parent = createFixtureCryptoCurrency("evm");
+  const token: CryptoOrTokenCurrency = {
+    type: "TokenCurrency",
+    id: "ethereum/erc20/usdc",
+    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    parentCurrency: parent,
+    tokenType: "erc20",
+    name: "USD Coin",
+    ticker: "USDC",
+    units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
+  };
+  const provider: CurrenciesByProviderId = {
+    providerId: "provider1",
+    currenciesByNetwork: [parent, token],
+  };
+
+  it("returns currency if id is in currencyIds", () => {
+    expect(getEffectiveCurrency(token, provider, [token.id])).toBe(token);
+  });
+
+  it("returns first matching currency from provider if id not in currencyIds", () => {
+    expect(getEffectiveCurrency(token, provider, [parent.id])).toBe(parent);
+  });
+
+  it("returns currency if no match in provider", () => {
+    expect(getEffectiveCurrency(token, provider, ["notfound"])).toBe(token);
+  });
+});

package/src/modularDrawer/utils/index.ts

@@ -1,7 +1,8 @@
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-export { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
-export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
+import { CurrenciesByProviderId } from "../../deposit/type";
+import { haveOneCommonProvider } from "./haveOneCommonProvider";
+import { getBalanceAndFiatValue } from "./getBalanceAndFiatValue";
+import { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
 
 function isCorrespondingCurrency(
   elem: CryptoOrTokenCurrency,
@@ -16,4 +17,22 @@ function isCorrespondingCurrency(
   return false;
 }
 
-export { isCorrespondingCurrency };
+const getEffectiveCurrency = (
+  currency: CryptoOrTokenCurrency,
+  provider: CurrenciesByProviderId,
+  currencyIds: string[],
+) => {
+  const isCurrencyFiltered = currencyIds.includes(currency.id);
+
+  if (isCurrencyFiltered) return currency;
+
+  return provider.currenciesByNetwork.find(elem => currencyIds.includes(elem.id)) ?? currency;
+};
+
+export {
+  isCorrespondingCurrency,
+  getEffectiveCurrency,
+  haveOneCommonProvider,
+  getBalanceAndFiatValue,
+  groupCurrenciesByProvider,
+};

package/src/modularDrawer/utils/type.ts

@@ -4,6 +4,7 @@ import { AccountLike } from "@ledgerhq/types-live";
 import { ReactNode } from "react";
 import { Observable } from "rxjs";
 import { WalletAPIAccount } from "../../wallet-api/types";
+import { CurrenciesByProviderId } from "../../deposit/type";
 import { EnhancedModularDrawerConfiguration } from "../../wallet-api/ModularDrawer/types";
 import { InterestRate } from "../data/entities";
 import { MarketItemResponse } from "../../market/utils/types";
@@ -73,6 +74,8 @@ export type UseAccountData = (params: AccountModuleParams) => AccountDataItem[];
 export type NetworkHookParams = {
   assets: CryptoOrTokenCurrency[];
   networks: CryptoOrTokenCurrency[];
+  selectedAssetId: string;
+  currenciesByProvider: CurrenciesByProviderId[];
   accounts$?: Observable<WalletAPIAccount[]>;
 };
 export type NetworkHook = (params: NetworkHookParams) => Array<CryptoOrTokenCurrency & Network>;
@@ -98,11 +101,14 @@ export type Network = {
 
 export type CreateNetworkConfigurationHookProps = {
   networksConfig: EnhancedModularDrawerConfiguration["networks"];
+  currenciesByProvider?: CurrenciesByProviderId[];
+  selectedAssetId: string;
   accounts$?: Observable<WalletAPIAccount[]>;
 };
 
 type Props = {
   assetsConfiguration: EnhancedModularDrawerConfiguration["assets"];
+  currenciesByProvider?: CurrenciesByProviderId[];
 };
 
 export type AssetConfigurationDeps = {

package/lib/e2e/families/hedera.d.ts

@@ -1,2 +0,0 @@
-export declare function sendHedera(): Promise<void>;
-//# sourceMappingURL=hedera.d.ts.map

package/lib/e2e/families/hedera.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hedera.d.ts","sourceRoot":"","sources":["../../../src/e2e/families/hedera.ts"],"names":[],"mappings":"AAGA,wBAAsB,UAAU,kBAG/B"}

package/lib/e2e/families/hedera.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendHedera = void 0;
-const speculos_1 = require("../speculos");
-const DeviceLabels_1 = require("../enum/DeviceLabels");
-async function sendHedera() {
-    await (0, speculos_1.pressUntilTextFound)(DeviceLabels_1.DeviceLabels.APPROVE);
-    await (0, speculos_1.pressBoth)();
-}
-exports.sendHedera = sendHedera;
-//# sourceMappingURL=hedera.js.map

package/lib/e2e/families/hedera.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hedera.js","sourceRoot":"","sources":["../../../src/e2e/families/hedera.ts"],"names":[],"mappings":";;;AAAA,0CAA6D;AAC7D,uDAAoD;AAE7C,KAAK,UAAU,UAAU;IAC9B,MAAM,IAAA,8BAAmB,EAAC,2BAAY,CAAC,OAAO,CAAC,CAAC;IAChD,MAAM,IAAA,oBAAS,GAAE,CAAC;AACpB,CAAC;AAHD,gCAGC"}