@ledgerhq/live-common 34.53.0-nightly.20251120023735 → 34.53.0

package/src/deposit/type.ts

@@ -17,9 +17,30 @@ export type MappedAsset = {
   ledgerCurrency?: CryptoOrTokenCurrency;
 };
 
+export type GroupedCurrency = {
+  providerId: string;
+  currenciesByNetwork: MappedAsset[];
+};
+
+export type CurrenciesByProviderId = {
+  currenciesByNetwork: CryptoOrTokenCurrency[];
+  providerId: string;
+  metaCurrencyId?: string;
+};
+
+export type GroupedCurrencies = {
+  currenciesByProvider: CurrenciesByProviderId[];
+  sortedCryptoCurrencies: CryptoOrTokenCurrency[];
+};
+
 export enum LoadingStatus {
   Idle = "idle",
   Pending = "pending",
   Success = "success",
   Error = "error",
 }
+
+export type LoadingBasedGroupedCurrencies = {
+  result: GroupedCurrencies;
+  loadingStatus: LoadingStatus;
+};

package/src/deposit/useGroupedCurrenciesByProvider.hook.ts

@@ -0,0 +1,46 @@
+import { GroupedCurrencies, LoadingBasedGroupedCurrencies, LoadingStatus } from "./type";
+import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { useEffect, useMemo, useState } from "react";
+import { isCurrencySupported, listSupportedCurrencies, listTokens } from "../currencies";
+import { loadCurrenciesByProvider } from "./helper";
+import { useAcceptedCurrency } from "../modularDrawer/hooks/useAcceptedCurrency";
+
+// FIXME(LIVE-10505): bad performane & shared utility to move to coin-framework
+const listSupportedTokens = () => listTokens().filter(t => isCurrencySupported(t.parentCurrency));
+
+const initialResult: GroupedCurrencies = {
+  sortedCryptoCurrencies: [],
+  currenciesByProvider: [],
+};
+
+export const useGroupedCurrenciesByProvider = (
+  withLoading?: boolean,
+): GroupedCurrencies | LoadingBasedGroupedCurrencies => {
+  const [result, setResult] = useState(initialResult);
+  const isAcceptedCurrency = useAcceptedCurrency();
+
+  const [loadingStatus, setLoadingStatus] = useState<LoadingStatus>(LoadingStatus.Idle);
+  const coinsAndTokensSupported = useMemo(
+    () =>
+      (listSupportedCurrencies() as CryptoOrTokenCurrency[])
+        .concat(listSupportedTokens())
+        .filter(isAcceptedCurrency),
+    [isAcceptedCurrency],
+  );
+
+  // Get mapped assets filtered by supported & sorted currencies, grouped by provider id
+  useEffect(() => {
+    if (withLoading) {
+      setLoadingStatus(LoadingStatus.Idle);
+      loadCurrenciesByProvider(coinsAndTokensSupported)
+        .then(data => {
+          setResult(data);
+          setLoadingStatus(LoadingStatus.Success);
+        })
+        .catch(() => setLoadingStatus(LoadingStatus.Error));
+    } else {
+      loadCurrenciesByProvider(coinsAndTokensSupported).then(setResult);
+    }
+  }, [coinsAndTokensSupported, withLoading]);
+  return withLoading ? { result, loadingStatus } : result;
+};

package/src/deviceSDK/hooks/useBatteryStatuses.test.ts

@@ -6,9 +6,7 @@ import { useBatteryStatuses } from "./useBatteryStatuses";
 
 describe("useBatteryStatuses", () => {
   it("should return an initial cancelRequest method that is callable", async () => {
-    const { result } = renderHook(() =>
-      useBatteryStatuses({ deviceName: null, statuses: [], enabled: true }),
-    );
+    const { result } = renderHook(() => useBatteryStatuses({ deviceName: null, statuses: [] }));
     expect(() => result.current.cancelRequest()).not.toThrow();
   });
 });

package/src/deviceSDK/hooks/useBatteryStatuses.ts

@@ -13,7 +13,6 @@ export type UseBatteryStatusesArgs = {
   deviceId?: string;
   deviceName: string | null;
   statuses: BatteryStatusTypes[];
-  enabled: boolean;
 };
 
 /**
@@ -32,7 +31,6 @@ export const useBatteryStatuses = ({
   deviceId,
   deviceName,
   statuses,
-  enabled,
 }: UseBatteryStatusesArgs): {
   batteryStatusesState: GetBatteryStatusesActionState;
   requestCompleted: boolean;
@@ -54,7 +52,6 @@ export const useBatteryStatuses = ({
   const lowBatteryPercentage = useEnv("LOW_BATTERY_PERCENTAGE");
 
   useEffect(() => {
-    if (!enabled) return;
     if (nonce > 0 && deviceId) {
       const sub = getBatteryStatusesAction({
         deviceId,
@@ -93,7 +90,7 @@ export const useBatteryStatuses = ({
         sub.unsubscribe();
       };
     }
-  }, [deviceId, deviceName, lowBatteryPercentage, statuses, nonce, enabled]);
+  }, [deviceId, deviceName, lowBatteryPercentage, statuses, nonce]);
 
   const triggerRequest = useCallback(() => {
     setRequestCompleted(false);

package/src/deviceSDK/tasks/core.test.ts

@@ -1,11 +1,9 @@
 import { of, throwError } from "rxjs";
 import { retryOnErrorsCommandWrapper, sharedLogicTaskWrapper } from "./core";
 import { DisconnectedDevice, LockedDeviceError } from "@ledgerhq/errors";
-import { DeviceBusyError } from "@ledgerhq/device-management-kit";
 import { concatMap } from "rxjs/operators";
 import { TransportRef } from "../transports/core";
 import { aTransportRefBuilder } from "../mocks/aTransportRef";
-import { isDmkError } from "./core";
 
 // Needs to mock the timer from rxjs used in the retry mechanism
 jest.mock("rxjs", () => {
@@ -332,22 +330,4 @@ describe("retryOnErrorsCommandWrapper", () => {
       });
     });
   });
-
-  describe("isDmkError (deviceSDK/tasks/core)", () => {
-    it("returns true for a DMK error instance", () => {
-      expect(isDmkError(new DeviceBusyError())).toBe(true);
-    });
-
-    it("returns false for a regular Error instance", () => {
-      expect(isDmkError(new Error("error"))).toBe(false);
-    });
-
-    it("returns false for a string error (e.g. 'Invalid extension provided')", () => {
-      expect(isDmkError("Invalid extension provided")).toBe(false);
-    });
-
-    it("returns false for undefined", () => {
-      expect(isDmkError(undefined)).toBe(false);
-    });
-  });
 });

package/src/deviceSDK/tasks/core.ts

@@ -79,8 +79,7 @@ type ErrorClass = CustomErrorClassType | TransportStatusErrorClassType;
 // To be able to retry a command, the command needs to take an object containing a transport as its argument
 type CommandTransportArgs = { transport: Transport };
 
-export const isDmkError = (error: unknown): error is DmkError =>
-  !!error && typeof error === "object" && error !== null && "_tag" in error;
+export const isDmkError = (error: any): error is DmkError => error && "_tag" in error;
 
 /**
  * Calls a command and retries it on given errors. The transport is refreshed before each retry.

package/src/deviceSDK/tasks/getDeviceInfo.ts

@@ -11,7 +11,6 @@ import { map, switchMap } from "rxjs/operators";
 import { SharedTaskEvent, retryOnErrorsCommandWrapper, sharedLogicTaskWrapper } from "./core";
 import { quitApp } from "../commands/quitApp";
 import { withTransport } from "../transports/core";
-import { SendApduEmptyResponseError } from "@ledgerhq/device-management-kit";
 
 const ManagerAllowedFlag = 0x08;
 const PinValidatedFlag = 0x80;
@@ -47,7 +46,6 @@ export function internalGetDeviceInfoTask({
             return retryOnErrorsCommandWrapper({
               command: getVersion,
               allowedErrors: [{ maxRetries: 3, errorClass: DisconnectedDevice }],
-              allowedDmkErrors: [new SendApduEmptyResponseError()],
             })(transportRef, {});
           }),
           map(value => {

package/src/deviceSDK/tasks/getLatestFirmware.ts

@@ -2,11 +2,11 @@ import type { DeviceId, DeviceInfo, FirmwareUpdateContext } from "@ledgerhq/type
 
 import { quitApp } from "../commands/quitApp";
 
+import { withDevice } from "../../hw/deviceAccess";
 import { from, Observable, of } from "rxjs";
 import { switchMap, catchError } from "rxjs/operators";
 import { SharedTaskEvent, sharedLogicTaskWrapper } from "./core";
 import { getLatestFirmwareForDeviceUseCase } from "../../device/use-cases/getLatestFirmwareForDeviceUseCase";
-import { withTransport } from "../transports/core";
 
 export type GetLatestFirmwareTaskArgs = {
   deviceId: DeviceId;
@@ -32,11 +32,11 @@ function internalGetLatestFirmwareTask({
   deviceInfo,
 }: GetLatestFirmwareTaskArgs): Observable<GetLatestFirmwareTaskEvent> {
   return new Observable(subscriber => {
-    return withTransport(
+    return withDevice(
       deviceId,
       deviceName ? { matchDeviceByName: deviceName } : undefined,
-    )(({ transportRef }) =>
-      quitApp(transportRef.current).pipe(
+    )(transport =>
+      quitApp(transport).pipe(
         switchMap(() => {
           return from(getLatestFirmwareForDeviceUseCase(deviceInfo));
         }),

package/src/deviceSDK/tasks/updateFirmware.ts

@@ -36,7 +36,6 @@ import { parseDeviceInfo } from "./getDeviceInfo";
 import {
   DeviceDisconnectedBeforeSendingApdu,
   DeviceDisconnectedWhileSendingError,
-  SendApduEmptyResponseError,
 } from "@ledgerhq/device-management-kit";
 
 export type UpdateFirmwareTaskArgs = {
@@ -80,7 +79,6 @@ const waitForGetVersion = retryOnErrorsCommandWrapper({
   allowedDmkErrors: [
     new DeviceDisconnectedWhileSendingError(),
     new DeviceDisconnectedBeforeSendingApdu(),
-    new SendApduEmptyResponseError(),
   ],
 });
 

package/src/e2e/deviceInteraction/ButtonDeviceSimulator.ts

@@ -0,0 +1,23 @@
+import { getEnv } from "@ledgerhq/live-env";
+import { getSpeculosAddress, retryAxiosRequest } from "../speculos";
+import axios from "axios";
+
+export async function pressBoth() {
+  const speculosApiPort = getEnv("SPECULOS_API_PORT");
+  const speculosAddress = getSpeculosAddress();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
+      action: "press-and-release",
+    }),
+  );
+}
+
+export async function pressRightButton(): Promise<void> {
+  const speculosApiPort = getEnv("SPECULOS_API_PORT");
+  const speculosAddress = getSpeculosAddress();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
+      action: "press-and-release",
+    }),
+  );
+}

package/src/e2e/enum/Account.ts

@@ -108,6 +108,12 @@ export class Account {
     "0xa1baa625c5E6A9304cB7AcD86d2fee6B710eC3eB",
     1,
   );
+  static readonly BSC_SHIBA = new Account(
+    Currency.BSC_SHIBA,
+    "BNB Chain 1",
+    "0x4BE2E2B8872AA298D6d123b9211B53E41f611566",
+    0,
+  );
 
   static readonly BTC_LEGACY_1 = new Account(
     Currency.BTC,

package/src/e2e/enum/Currency.ts

@@ -72,7 +72,7 @@ export class Currency {
   );
   static readonly SOL = new Currency("Solana", "SOL", "solana", AppInfos.SOLANA, [Network.SOLANA]);
 
-  static readonly DOT = new Currency("Polkadot", "DOT", "assethub_polkadot", AppInfos.POLKADOT, [
+  static readonly DOT = new Currency("Polkadot", "DOT", "polkadot", AppInfos.POLKADOT, [
     Network.POLKADOT,
   ]);
   static readonly TRX = new Currency("Tron", "TRX", "tron", AppInfos.TRON, [Network.TRON]);
@@ -156,6 +156,10 @@ export class Currency {
     AppInfos.BNB_CHAIN,
     [Network.BNB_CHAIN, Network.POLYGON],
   );
+  static readonly BSC_SHIBA = new Currency("Shiba Inu", "SHIB", "bsc", AppInfos.BNB_CHAIN, [
+    Network.BNB_CHAIN,
+    Network.ETHEREUM,
+  ]);
   static readonly POL_DAI = new Currency(
     "(PoS) Dai Stablecoin",
     "DAI",
@@ -200,7 +204,7 @@ export class Currency {
   static readonly SUI = new Currency("Sui", "SUI", "sui", AppInfos.SUI, [Network.SUI]);
 
   static readonly SUI_USDC = new Currency(
-    "USD Coin",
+    "USDC",
     "USDC",
     "sui/coin/usdc_0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::usdc",
     AppInfos.SUI,

package/src/e2e/families/algorand.ts

@@ -2,26 +2,19 @@ import expect from "expect";
 import { Transaction } from "../models/Transaction";
 import { containsSubstringInEvent, getSendEvents } from "../speculos";
 import { isTouchDevice } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
-import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export const sendAlgorand = withDeviceController(
-  ({ getButtonsController }) =>
-    async (tx: Transaction) => {
-      const buttons = getButtonsController();
-
-      const events = await getSendEvents(tx);
-      const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
-      expect(isAmountCorrect).toBeTruthy();
-
-      const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
-      expect(isAddressCorrect).toBeTruthy();
-
-      if (isTouchDevice()) {
-        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-      } else {
-        await buttons.both();
-      }
-    },
-);
+export async function sendAlgorand(tx: Transaction) {
+  const events = await getSendEvents(tx);
+  const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
+  expect(isAmountCorrect).toBeTruthy();
+  const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
+  expect(isAddressCorrect).toBeTruthy();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
+}

package/src/e2e/families/aptos.ts

@@ -2,36 +2,24 @@ import expect from "expect";
 import { Transaction } from "../models/Transaction";
 import { waitFor, pressUntilTextFound, containsSubstringInEvent, getSendEvents } from "../speculos";
 import { isTouchDevice } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Delegate } from "../models/Delegate";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
-import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export const sendAptos = withDeviceController(
-  ({ getButtonsController }) =>
-    async (tx: Transaction) => {
-      const buttons = getButtonsController();
+export async function sendAptos(tx: Transaction) {
+  await getSendEvents(tx);
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
+}
 
-      await getSendEvents(tx);
-
-      if (isTouchDevice()) {
-        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-      } else {
-        await buttons.both();
-      }
-    },
-);
-
-export const delegateAptos = withDeviceController(
-  ({ getButtonsController }) =>
-    async (delegatingAccount: Delegate) => {
-      const buttons = getButtonsController();
-
-      await waitFor(DeviceLabels.REVIEW_OPERATION);
-      const events = await pressUntilTextFound(DeviceLabels.APPROVE);
-      const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
-      expect(isAmountCorrect).toBeTruthy();
-
-      await buttons.both();
-    },
-);
+export async function delegateAptos(delegatingAccount: Delegate) {
+  await waitFor(DeviceLabels.REVIEW_OPERATION);
+  const events = await pressUntilTextFound(DeviceLabels.APPROVE);
+  const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
+  expect(isAmountCorrect).toBeTruthy();
+  await pressBoth();
+}

package/src/e2e/families/bitcoin.ts

@@ -2,63 +2,49 @@ import expect from "expect";
 import { Transaction } from "../models/Transaction";
 import { waitFor, containsSubstringInEvent, pressUntilTextFound, getSendEvents } from "../speculos";
 import { getSpeculosModel, isTouchDevice } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import invariant from "invariant";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
-import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export const sendBTCBasedCoin = withDeviceController(
-  ({ getButtonsController }) =>
-    async (tx: Transaction) => {
-      const buttons = getButtonsController();
-
-      const events = await getSendEvents(tx);
-      const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
-      expect(isAmountCorrect).toBeTruthy();
-
-      const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
-      expect(isAddressCorrect).toBeTruthy();
-
-      if (isTouchDevice()) {
-        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+export async function sendBTCBasedCoin(tx: Transaction) {
+  const events = await getSendEvents(tx);
+  const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
+  expect(isAmountCorrect).toBeTruthy();
+  const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
+  expect(isAddressCorrect).toBeTruthy();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+    await waitFor(DeviceLabels.CONFIRM);
+    await pressUntilTextFound(DeviceLabels.ACCEPT);
+    await pressBoth();
+  }
+}
+
+export async function sendBTC(tx: Transaction) {
+  const speculosDevice = getSpeculosModel();
+  try {
+    const events = await getSendEvents(tx);
+    const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
+    expect(isAmountCorrect).toBeTruthy();
+    const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
+    expect(isAddressCorrect).toBeTruthy();
+    if (isTouchDevice()) {
+      await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+    } else {
+      await pressBoth();
+      if (speculosDevice === DeviceModelId.nanoS) {
+        await pressUntilTextFound(DeviceLabels.SIGN);
+        await pressBoth();
+        await waitFor(DeviceLabels.BITCOIN_IS_READY);
       } else {
-        await buttons.both();
-        await waitFor(DeviceLabels.CONFIRM);
-        await pressUntilTextFound(DeviceLabels.ACCEPT);
-        await buttons.both();
-      }
-    },
-);
-
-export const sendBTC = withDeviceController(
-  ({ getButtonsController }) =>
-    async (tx: Transaction) => {
-      const buttons = getButtonsController();
-      const speculosDevice = getSpeculosModel();
-
-      try {
-        const events = await getSendEvents(tx);
-        const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
-        expect(isAmountCorrect).toBeTruthy();
-
-        const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
-        expect(isAddressCorrect).toBeTruthy();
-
-        if (isTouchDevice()) {
-          await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-        } else {
-          await buttons.both();
-          if (speculosDevice === DeviceModelId.nanoS) {
-            await pressUntilTextFound(DeviceLabels.SIGN);
-            await buttons.both();
-            await waitFor(DeviceLabels.BITCOIN_IS_READY);
-          } else {
-            await waitFor(DeviceLabels.TRANSACTION_SIGNED);
-          }
-        }
-      } catch (e) {
-        invariant(false, `Error while sending BTC transaction: ${e}`);
+        await waitFor(DeviceLabels.TRANSACTION_SIGNED);
       }
-    },
-);
+    }
+  } catch (e) {
+    invariant(false, `Error while sending BTC transaction: ${e}`);
+  }
+}

package/src/e2e/families/cardano.ts

@@ -1,7 +1,8 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
 import { pressUntilTextFound, containsSubstringInEvent, waitFor } from "../speculos";
-import { getSpeculosModel, isTouchDevice } from "../speculosAppVersion";
+import { getSpeculosModel } from "../speculosAppVersion";
+import { pressBoth, pressRightButton } from "../deviceInteraction/ButtonDeviceSimulator";
 import {
   pressAndRelease,
   longPressAndRelease,
@@ -9,7 +10,7 @@ import {
 } from "../deviceInteraction/TouchDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { DeviceModelId } from "@ledgerhq/types-devices";
-import { withDeviceController } from "../deviceInteraction/DeviceController";
+import { isTouchDevice } from "../speculosAppVersion";
 
 type ActionType = "both" | "right" | "tap" | "swipe" | "confirm" | "hold";
 
@@ -31,40 +32,32 @@ async function sendCardanoTouchDevices(tx: Transaction) {
   await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
 }
 
-export const sendCardanoNanoS = withDeviceController(
-  ({ getButtonsController }) =>
-    async (_tx: Transaction) => {
-      const buttons = getButtonsController();
-      await waitFor(DeviceLabels.NEW_ORDINARY);
-      await buttons.right();
-      await waitFor(DeviceLabels.SEND_TO_ADDRESS);
-      await buttons.both();
-      await pressUntilTextFound(DeviceLabels.SEND);
-      await buttons.both();
-      await waitFor(DeviceLabels.TRANSACTION_FEE);
-      await buttons.both();
-      await waitFor(DeviceLabels.CONFIRM);
-      await buttons.right();
-    },
-);
+async function sendCardanoNanoS(_tx: Transaction) {
+  await waitFor(DeviceLabels.NEW_ORDINARY);
+  await pressRightButton();
+  await waitFor(DeviceLabels.SEND_TO_ADDRESS);
+  await pressBoth();
+  await pressUntilTextFound(DeviceLabels.SEND);
+  await pressBoth();
+  await waitFor(DeviceLabels.TRANSACTION_FEE);
+  await pressBoth();
+  await waitFor(DeviceLabels.CONFIRM);
+  await pressRightButton();
+}
 
-export const sendCardanoButtonDevice = withDeviceController(
-  ({ getButtonsController }) =>
-    async (tx: Transaction) => {
-      const buttons = getButtonsController();
-      await waitFor(DeviceLabels.NEW_ORDINARY);
-      await buttons.both();
-      await pressUntilTextFound(DeviceLabels.SEND_TO_ADDRESS_2);
-      await buttons.both();
-      const events = await pressUntilTextFound(DeviceLabels.SEND);
-      validateTransactionData(tx, events);
-      await buttons.both();
-      await waitFor(DeviceLabels.TRANSACTION_FEE);
-      await buttons.both();
-      await waitFor(DeviceLabels.CONFIRM);
-      await buttons.both();
-    },
-);
+async function sendCardanoButtonDevice(tx: Transaction) {
+  await waitFor(DeviceLabels.NEW_ORDINARY);
+  await pressBoth();
+  await pressUntilTextFound(DeviceLabels.SEND_TO_ADDRESS_2);
+  await pressBoth();
+  const events = await pressUntilTextFound(DeviceLabels.SEND);
+  validateTransactionData(tx, events);
+  await pressBoth();
+  await waitFor(DeviceLabels.TRANSACTION_FEE);
+  await pressBoth();
+  await waitFor(DeviceLabels.CONFIRM);
+  await pressBoth();
+}
 
 export async function sendCardano(tx: Transaction) {
   const speculosModel = getSpeculosModel();
@@ -134,18 +127,14 @@ async function delegateTouchDevicesAction(label: DeviceLabels) {
   }
 }
 
-export const delegateNanoAction = withDeviceController(
-  ({ getButtonsController }) =>
-    async (label: DeviceLabels, action: ActionType) => {
-      const buttons = getButtonsController();
-      await waitFor(label);
-      if (action === "both") {
-        await buttons.both();
-      } else {
-        await buttons.right();
-      }
-    },
-);
+async function delegateNanoAction(label: DeviceLabels, action: ActionType) {
+  await waitFor(label);
+  if (action === "both") {
+    await pressBoth();
+  } else {
+    await pressRightButton();
+  }
+}
 
 async function executeDelegateStep(label: DeviceLabels, action: ActionType) {
   try {

package/src/e2e/families/celo.ts

@@ -2,24 +2,18 @@ import { containsSubstringInEvent, getDelegateEvents, pressUntilTextFound } from
 import { isTouchDevice } from "../speculosAppVersion";
 import { Delegate } from "../models/Delegate";
 import expect from "expect";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
-import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export const delegateCelo = withDeviceController(
-  ({ getButtonsController }) =>
-    async (delegatingAccount: Delegate) => {
-      const buttons = getButtonsController();
-
-      const events = await getDelegateEvents(delegatingAccount);
-      const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
-      expect(isAmountCorrect).toBeTruthy();
-
-      if (isTouchDevice()) {
-        await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
-        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-      } else {
-        await buttons.both();
-      }
-    },
-);
+export async function delegateCelo(delegatingAccount: Delegate) {
+  const events = await getDelegateEvents(delegatingAccount);
+  const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
+  expect(isAmountCorrect).toBeTruthy();
+  if (isTouchDevice()) {
+    await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
+}