@ledgerhq/live-common 34.53.0 → 34.54.0-nightly.20251126160702

package/src/e2e/speculos.ts

@@ -48,7 +48,7 @@ import {
   longPressAndRelease,
   swipeRight,
 } from "./deviceInteraction/TouchDeviceSimulator";
-import { pressBoth, pressRightButton } from "./deviceInteraction/ButtonDeviceSimulator";
+import { withDeviceController } from "./deviceInteraction/DeviceController";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -555,32 +555,35 @@ export async function fetchAllEvents(speculosApiPort: number): Promise<string[]>
   return response.data.events.map(event => event.text);
 }
 
-export async function pressUntilTextFound(
-  targetText: string,
-  strictMatch: boolean = false,
-): Promise<string[]> {
-  const maxAttempts = 18;
-  const speculosApiPort = getEnv("SPECULOS_API_PORT");
-
-  for (let attempts = 0; attempts < maxAttempts; attempts++) {
-    const texts = await fetchCurrentScreenTexts(speculosApiPort);
-    if (
-      strictMatch ? texts === targetText : texts.toLowerCase().includes(targetText.toLowerCase())
-    ) {
-      return await fetchAllEvents(speculosApiPort);
-    }
-    if (isTouchDevice()) {
-      await swipeRight();
-    } else {
-      await pressRightButton();
-    }
-    await waitForTimeOut(200);
-  }
+export const pressUntilTextFound = withDeviceController(
+  ({ getButtonsController }) =>
+    async (targetText: string, strictMatch: boolean = false): Promise<string[]> => {
+      const maxAttempts = 18;
+      const speculosApiPort = getEnv("SPECULOS_API_PORT");
+      const buttons = getButtonsController();
+
+      for (let attempts = 0; attempts < maxAttempts; attempts++) {
+        const texts = await fetchCurrentScreenTexts(speculosApiPort);
+        if (
+          strictMatch
+            ? texts === targetText
+            : texts.toLowerCase().includes(targetText.toLowerCase())
+        ) {
+          return await fetchAllEvents(speculosApiPort);
+        }
+        if (isTouchDevice()) {
+          await swipeRight();
+        } else {
+          await buttons.right();
+        }
+        await waitForTimeOut(200);
+      }
 
-  throw new Error(
-    `ElementNotFoundException: Element with text "${targetText}" not found on speculos screen`,
-  );
-}
+      throw new Error(
+        `ElementNotFoundException: Element with text "${targetText}" not found on speculos screen`,
+      );
+    },
+);
 
 export function containsSubstringInEvent(targetString: string, events: string[]): boolean {
   const concatenatedEvents = events.join("");
@@ -615,38 +618,45 @@ export async function waitForTimeOut(ms: number) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
-export async function removeMemberLedgerSync() {
-  await waitFor(DeviceLabels.CONNECT_WITH);
-  if (isTouchDevice()) {
-    await pressAndRelease(DeviceLabels.CONNECT);
-    await waitFor(DeviceLabels.REMOVE_FROM_LEDGER_SYNC);
-    await pressAndRelease(DeviceLabels.REMOVE);
-    await waitFor(DeviceLabels.CONFIRM_CHANGE);
-    await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
-    await waitFor(DeviceLabels.TURN_ON_SYNC);
-    await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
-    await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
-    await pressAndRelease(DeviceLabels.TURN_ON_SYNC);
-  } else {
-    await pressUntilTextFound(DeviceLabels.CONNECT_WITH_LEDGER_SYNC, true);
-    await pressBoth();
-    await waitFor(DeviceLabels.REMOVE_PHONE_OR_COMPUTER);
-    await pressUntilTextFound(DeviceLabels.REMOVE_PHONE_OR_COMPUTER, true);
-    await pressBoth();
-    await waitFor(DeviceLabels.TURN_ON_SYNC);
-    await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
-    await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
-    await pressBoth();
-  }
-}
+export const removeMemberLedgerSync = withDeviceController(
+  ({ getButtonsController }) =>
+    async () => {
+      const buttons = getButtonsController();
+      await waitFor(DeviceLabels.CONNECT_WITH);
+
+      if (isTouchDevice()) {
+        await pressAndRelease(DeviceLabels.CONNECT);
+        await waitFor(DeviceLabels.REMOVE_FROM_LEDGER_SYNC);
+        await pressAndRelease(DeviceLabels.REMOVE);
+        await waitFor(DeviceLabels.CONFIRM_CHANGE);
+        await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
+        await waitFor(DeviceLabels.TURN_ON_SYNC);
+        await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
+        await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
+        await pressAndRelease(DeviceLabels.TURN_ON_SYNC);
+      } else {
+        await pressUntilTextFound(DeviceLabels.CONNECT_WITH_LEDGER_SYNC, true);
+        await buttons.both();
+        await waitFor(DeviceLabels.REMOVE_PHONE_OR_COMPUTER);
+        await pressUntilTextFound(DeviceLabels.REMOVE_PHONE_OR_COMPUTER, true);
+        await buttons.both();
+        await waitFor(DeviceLabels.TURN_ON_SYNC);
+        await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
+        await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
+        await buttons.both();
+      }
+    },
+);
 
-export async function activateLedgerSync() {
+export const activateLedgerSync = withDeviceController(({ getButtonsController }) => async () => {
+  const buttons = getButtonsController();
   await waitFor(DeviceLabels.CONNECT_WITH);
+
   if (isTouchDevice()) {
     await pressAndRelease(DeviceLabels.CONNECT_WITH_LEDGER_SYNC);
   } else {
     await pressUntilTextFound(DeviceLabels.CONNECT_WITH_LEDGER_SYNC, true);
-    await pressBoth();
+    await buttons.both();
   }
   await waitFor(DeviceLabels.TURN_ON_SYNC);
   if (isTouchDevice()) {
@@ -654,11 +664,13 @@ export async function activateLedgerSync() {
   } else {
     await pressUntilTextFound(DeviceLabels.LEDGER_LIVE_WILL_BE);
     await pressUntilTextFound(DeviceLabels.TURN_ON_SYNC);
-    await pressBoth();
+    await buttons.both();
   }
-}
+});
+
+export const activateExpertMode = withDeviceController(({ getButtonsController }) => async () => {
+  const buttons = getButtonsController();
 
-export async function activateExpertMode() {
   if (isTouchDevice()) {
     await goToSettings();
     const SettingsToggle1Coordinates = { x: 344, y: 136 };
@@ -669,18 +681,22 @@ export async function activateExpertMode() {
     );
   } else {
     await pressUntilTextFound(DeviceLabels.EXPERT_MODE);
-    await pressBoth();
+    await buttons.both();
   }
-}
+});
+
+export const activateContractData = withDeviceController(({ getButtonsController }) => async () => {
+  const buttons = getButtonsController();
 
-export async function activateContractData() {
   await pressUntilTextFound(DeviceLabels.SETTINGS);
-  await pressBoth();
+  await buttons.both();
   await waitFor(DeviceLabels.CONTRACT_DATA);
-  await pressBoth();
-}
+  await buttons.both();
+});
+
+export const goToSettings = withDeviceController(({ getButtonsController }) => async () => {
+  const buttons = getButtonsController();
 
-export async function goToSettings() {
   if (isTouchDevice()) {
     const SettingsCogwheelCoordinates = { x: 400, y: 75 };
     await pressAndRelease(
@@ -690,13 +706,14 @@ export async function goToSettings() {
     );
   } else {
     await pressUntilTextFound(DeviceLabels.SETTINGS);
-    await pressBoth();
+    await buttons.both();
   }
-}
+});
 
-export async function providePublicKey() {
-  await pressRightButton();
-}
+export const providePublicKey = withDeviceController(({ getButtonsController }) => async () => {
+  const buttons = getButtonsController();
+  await buttons.right();
+});
 
 type DeviceLabelsReturn = {
   delegateConfirmLabel: string;
@@ -737,28 +754,31 @@ export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
   };
 }
 
-export async function expectValidAddressDevice(account: Account, addressDisplayed: string) {
-  if (account.currency === Currency.SUI_USDC) {
-    providePublicKey();
-  }
-  const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(account.currency.speculosApp);
-  await waitFor(receiveVerifyLabel);
-  if (isTouchDevice()) {
-    const events = await pressUntilTextFound(receiveConfirmLabel);
-    const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
-    expect(isAddressCorrect).toBeTruthy();
-    await pressAndRelease(DeviceLabels.CONFIRM);
-  } else {
-    const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(
-      account.currency.speculosApp,
-    );
-    await waitFor(receiveVerifyLabel);
-    const events = await pressUntilTextFound(receiveConfirmLabel);
-    const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
-    expect(isAddressCorrect).toBeTruthy();
-    await pressBoth();
-  }
-}
+export const expectValidAddressDevice = withDeviceController(
+  ({ getButtonsController }) =>
+    async (account: Account, addressDisplayed: string) => {
+      const buttons = getButtonsController();
+      if (account.currency === Currency.SUI_USDC) {
+        await providePublicKey();
+      }
+      const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(
+        account.currency.speculosApp,
+      );
+      await waitFor(receiveVerifyLabel);
+
+      if (isTouchDevice()) {
+        const events = await pressUntilTextFound(receiveConfirmLabel);
+        const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
+        expect(isAddressCorrect).toBeTruthy();
+        await pressAndRelease(DeviceLabels.CONFIRM);
+      } else {
+        const events = await pressUntilTextFound(receiveConfirmLabel);
+        const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
+        expect(isAddressCorrect).toBeTruthy();
+        await buttons.both();
+      }
+    },
+);
 
 export async function signSendTransaction(tx: Transaction) {
   const currencyName = tx.accountToDebit.currency;
@@ -873,58 +893,73 @@ export async function getDelegateEvents(delegatingAccount: Delegate): Promise<st
   return await pressUntilTextFound(delegateConfirmLabel);
 }
 
-export async function verifyAmountsAndAcceptSwap(swap: Swap, amount: string) {
-  await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  const events =
-    getSpeculosModel() === DeviceModelId.nanoS
-      ? await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND)
-      : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
-  verifySwapData(swap, events, amount);
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
-
-export async function verifyAmountsAndAcceptSwapForDifferentSeed(
-  swap: Swap,
-  amount: string,
-  errorMessage: string | null,
-) {
-  if (errorMessage === null && isTouchDevice()) {
-    await waitFor(DeviceLabels.RECEIVE_ADDRESS_DOES_NOT_BELONG);
-    await pressAndRelease(DeviceLabels.CONTINUE_ANYWAY);
-  } else {
-    await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  }
-  const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
-  verifySwapData(swap, events, amount);
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+export const verifyAmountsAndAcceptSwap = withDeviceController(
+  ({ getButtonsController }) =>
+    async (swap: Swap, amount: string) => {
+      const buttons = getButtonsController();
+      await waitFor(DeviceLabels.REVIEW_TRANSACTION);
+      const events =
+        getSpeculosModel() === DeviceModelId.nanoS
+          ? await pressUntilTextFound(DeviceLabels.ACCEPT_AND_SEND)
+          : await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+      verifySwapData(swap, events, amount);
+      if (isTouchDevice()) {
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+      }
+    },
+);
+
+export const verifyAmountsAndAcceptSwapForDifferentSeed = withDeviceController(
+  ({ getButtonsController }) =>
+    async (swap: Swap, amount: string, errorMessage: string | null) => {
+      const buttons = getButtonsController();
+      if (errorMessage === null) {
+        if (isTouchDevice()) {
+          await waitFor(DeviceLabels.RECEIVE_ADDRESS_DOES_NOT_BELONG);
+          await pressAndRelease(DeviceLabels.CONTINUE_ANYWAY);
+        } else {
+          await waitFor(DeviceLabels.REVIEW_TRANSACTION);
+          await pressUntilTextFound(DeviceLabels.RECEIVE_ADDRESS_DOES_NOT_BELONG);
+          await buttons.both();
+        }
+      } else {
+        await waitFor(DeviceLabels.REVIEW_TRANSACTION);
+      }
 
-export async function verifyAmountsAndRejectSwap(swap: Swap, amount: string) {
-  await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  let events: string[] = [];
-  if (isTouchDevice()) {
-    events = await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
-  } else {
-    events = await pressUntilTextFound(DeviceLabels.REJECT);
-  }
+      const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+      verifySwapData(swap, events, amount);
+      if (isTouchDevice()) {
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+      }
+    },
+);
+
+export const verifyAmountsAndRejectSwap = withDeviceController(
+  ({ getButtonsController }) =>
+    async (swap: Swap, amount: string) => {
+      const buttons = getButtonsController();
+      await waitFor(DeviceLabels.REVIEW_TRANSACTION);
+      let events: string[] = [];
+      if (isTouchDevice()) {
+        events = await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
+      } else {
+        events = await pressUntilTextFound(DeviceLabels.REJECT);
+      }
 
-  verifySwapData(swap, events, amount);
-  if (isTouchDevice()) {
-    await pressAndRelease(DeviceLabels.REJECT);
-    await waitFor(DeviceLabels.YES_REJECT);
-    await pressAndRelease(DeviceLabels.YES_REJECT);
-  } else {
-    await pressBoth();
-  }
-}
+      verifySwapData(swap, events, amount);
+      if (isTouchDevice()) {
+        await pressAndRelease(DeviceLabels.REJECT);
+        await waitFor(DeviceLabels.YES_REJECT);
+        await pressAndRelease(DeviceLabels.YES_REJECT);
+      } else {
+        await buttons.both();
+      }
+    },
+);
 
 function verifySwapData(swap: Swap, events: string[], amount: string) {
   const swapPair = `swap ${swap.getAccountToDebit.currency.ticker} to ${swap.getAccountToCredit.currency.ticker}`;

package/src/exchange/providers/swap.ts

@@ -328,3 +328,7 @@ export const getAvailableProviders = async (): Promise<string[]> => {
   }
   return Object.keys(await fetchAndMergeProviderData({ ledgerSignatureEnv, partnerSignatureEnv }));
 };
+
+export const getDefaultSwapProviderKeys = (): string[] => {
+  return Object.keys(DEFAULT_SWAP_PROVIDERS);
+};

package/src/exchange/swap/getCompleteSwapHistory.ts

@@ -1,4 +1,4 @@
-import { getCryptoAssetsStore } from "../../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { AccountLike, SwapOperation } from "@ledgerhq/types-live";
 import { accountWithMandatoryTokens, getAccountCurrency } from "../../account";
 import type { MappedSwapOperation, SwapHistorySection } from "./types";

package/src/exchange/swap/hooks/useSelectableCurrencies.test.ts

@@ -5,6 +5,10 @@ import { renderHook, waitFor } from "@testing-library/react";
 
 import { useSelectableCurrencies } from "./useSelectableCurrencies";
 import { getCryptoCurrencyById } from "../../../currencies";
+import { setupMockCryptoAssetsStore } from "../../../test-helpers/cryptoAssetsStore";
+
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
 
 describe("useSelectableCurrencies", () => {
   test("returns an empty array when empty list are passed", async () => {

package/src/exchange/swap/hooks/useSelectableCurrencies.ts

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { getCryptoAssetsStore } from "../../../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 export const useSelectableCurrencies = ({

package/src/exchange/swap/hooks/v5/useFetchCurrencyAll.ts

@@ -6,7 +6,7 @@ import { useFilteredProviders } from "./useFilteredProviders";
 
 export function useFetchCurrencyAll() {
   const fetchAdditionalCoins = useFeature("fetchAdditionalCoins");
-  const { providers, loading, error } = useFilteredProviders();
+  const { providers, error } = useFilteredProviders();
 
   const { data, ...rest } = useAPI({
     queryFn: fetchCurrencyAll,
@@ -14,9 +14,8 @@ export function useFetchCurrencyAll() {
       additionalCoinsFlag: fetchAdditionalCoins?.enabled,
       providers,
     },
-    // assume the all currency list for the given props won't change during a users session.
     staleTimeout: FETCH_CURRENCIES_TIMEOUT_MS,
-    enabled: !loading && !error,
+    enabled: !error && providers.length > 0,
   });
   return {
     ...rest,

package/src/exchange/swap/hooks/v5/useFilteredProviders.ts

@@ -1,27 +1,52 @@
 import { getEnv } from "@ledgerhq/live-env";
-import { useCallback, useEffect, useState } from "react";
-import { fetchAndMergeProviderData } from "../../../providers/swap";
+import { useCallback, useEffect, useState, useMemo } from "react";
+import { fetchAndMergeProviderData, getDefaultSwapProviderKeys } from "../../../providers/swap";
 import { useFeature } from "../../../../featureFlags";
 
+const filterProvidersByFeatureFlags = (
+  providers: string[],
+  ptxSwapMoonpayProviderFlag?: { enabled?: boolean },
+  ptxSwapExodusProviderFlag?: { enabled?: boolean },
+): string[] => {
+  let filtered = providers;
+  if (!ptxSwapMoonpayProviderFlag?.enabled) {
+    filtered = filtered.filter(provider => provider !== "moonpay");
+  }
+  if (!ptxSwapExodusProviderFlag?.enabled) {
+    filtered = filtered.filter(provider => provider !== "exodus");
+  }
+  return filtered;
+};
+
 export const useFilteredProviders = () => {
-  const [providers, setProviders] = useState<string[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<unknown>(null);
   const ptxSwapMoonpayProviderFlag = useFeature("ptxSwapMoonpayProvider");
   const ptxSwapExodusProviderFlag = useFeature("ptxSwapExodusProvider");
+
+  const defaultProviders = useMemo(
+    () =>
+      filterProvidersByFeatureFlags(
+        getDefaultSwapProviderKeys(),
+        ptxSwapMoonpayProviderFlag ?? undefined,
+        ptxSwapExodusProviderFlag ?? undefined,
+      ),
+    [ptxSwapMoonpayProviderFlag, ptxSwapExodusProviderFlag],
+  );
+
+  const [providers, setProviders] = useState<string[]>(defaultProviders);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<unknown>(null);
+
   const fetchProviders = useCallback(async () => {
     try {
       const ledgerSignatureEnv = getEnv("MOCK_EXCHANGE_TEST_CONFIG") ? "test" : "prod";
       const partnerSignatureEnv = getEnv("MOCK_EXCHANGE_TEST_PARTNER") ? "test" : "prod";
 
       const data = await fetchAndMergeProviderData({ ledgerSignatureEnv, partnerSignatureEnv });
-      let filteredProviders = Object.keys(data);
-      if (!ptxSwapMoonpayProviderFlag?.enabled) {
-        filteredProviders = filteredProviders.filter(provider => provider !== "moonpay");
-      }
-      if (!ptxSwapExodusProviderFlag?.enabled) {
-        filteredProviders = filteredProviders.filter(provider => provider !== "exodus");
-      }
+      const filteredProviders = filterProvidersByFeatureFlags(
+        Object.keys(data),
+        ptxSwapMoonpayProviderFlag ?? undefined,
+        ptxSwapExodusProviderFlag ?? undefined,
+      );
 
       setProviders(filteredProviders);
     } catch (error) {

package/src/families/algorand/bridge.integration.test.ts

@@ -1,4 +1,4 @@
-import "../../__tests__/test-helpers/setup";
+import "../../__tests__/test-helpers/setup.integration";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import { dataset } from "@ledgerhq/coin-algorand/test/bridge.dataset";