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

package/src/e2e/families/aptos.ts

@@ -2,24 +2,36 @@ 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 async function sendAptos(tx: Transaction) {
-  await getSendEvents(tx);
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+export const sendAptos = withDeviceController(
+  ({ getButtonsController }) =>
+    async (tx: Transaction) => {
+      const buttons = getButtonsController();
 
-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();
-}
+      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();
+    },
+);

package/src/e2e/families/bitcoin.ts

@@ -2,49 +2,63 @@ 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 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);
+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);
       } else {
-        await waitFor(DeviceLabels.TRANSACTION_SIGNED);
+        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}`);
       }
-    }
-  } catch (e) {
-    invariant(false, `Error while sending BTC transaction: ${e}`);
-  }
-}
+    },
+);

package/src/e2e/families/cardano.ts

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

package/src/e2e/families/celo.ts

@@ -2,18 +2,24 @@ 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 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();
-  }
-}
+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();
+      }
+    },
+);

package/src/e2e/families/cosmos.ts

@@ -2,32 +2,44 @@ import expect from "expect";
 import { Delegate } from "../models/Delegate";
 import { Transaction } from "../models/Transaction";
 import { containsSubstringInEvent, getDelegateEvents, getSendEvents } from "../speculos";
-import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { isTouchDevice } from "../speculosAppVersion";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export async function delegateCosmos(delegatingAccount: Delegate) {
-  const events = await getDelegateEvents(delegatingAccount);
-  const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
-  expect(isAmountCorrect).toBeTruthy();
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+export const delegateCosmos = withDeviceController(
+  ({ getButtonsController }) =>
+    async (delegatingAccount: Delegate) => {
+      const buttons = getButtonsController();
 
-export async function sendCosmos(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();
+      const events = await getDelegateEvents(delegatingAccount);
+      const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
+      expect(isAmountCorrect).toBeTruthy();
 
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+      if (isTouchDevice()) {
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+      }
+    },
+);
+
+export const sendCosmos = 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();
+      }
+    },
+);

package/src/e2e/families/evm.ts

@@ -1,17 +1,17 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
 import { containsSubstringInEvent, pressUntilTextFound } from "../speculos";
-import { getSpeculosModel } from "../speculosAppVersion";
-import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
+import { getSpeculosModel, isTouchDevice } from "../speculosAppVersion";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 import { DeviceModelId } from "@ledgerhq/types-devices";
-import { isTouchDevice } from "../speculosAppVersion";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
 
 function validateTransactionData(tx: Transaction, events: string[]) {
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
+
   if (tx.accountToCredit.ensName && process.env.SPECULOS_DEVICE !== Device.LNS.name) {
     const isENSNameCorrect = containsSubstringInEvent(tx.accountToCredit.ensName, events);
     expect(isENSNameCorrect).toBeTruthy();
@@ -27,20 +27,31 @@ async function sendEvmTouchDevices(tx: Transaction) {
   await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
 }
 
-async function sendEvmButtonDevice(tx: Transaction) {
-  const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
-  validateTransactionData(tx, events);
-  await pressBoth();
-}
+export const sendEvmButtonDevice = withDeviceController(
+  ({ getButtonsController }) =>
+    async (tx: Transaction) => {
+      const buttons = getButtonsController();
 
-async function sendEvmNanoS(tx: Transaction) {
-  const events = await pressUntilTextFound(DeviceLabels.ACCEPT);
-  validateTransactionData(tx, events);
-  await pressBoth();
-}
+      const events = await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION);
+      validateTransactionData(tx, events);
+      await buttons.both();
+    },
+);
+
+export const sendEvmNanoS = withDeviceController(
+  ({ getButtonsController }) =>
+    async (tx: Transaction) => {
+      const buttons = getButtonsController();
+
+      const events = await pressUntilTextFound(DeviceLabels.ACCEPT);
+      validateTransactionData(tx, events);
+      await buttons.both();
+    },
+);
 
 export async function sendEVM(tx: Transaction) {
   const speculosModel = getSpeculosModel();
+
   if (isTouchDevice()) {
     return sendEvmTouchDevices(tx);
   }

package/src/e2e/families/hedera.ts

@@ -1,8 +1,10 @@
-import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { pressUntilTextFound } from "../speculos";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
+
+export const sendHedera = withDeviceController(({ getButtonsController }) => async () => {
+  const buttons = getButtonsController();
 
-export async function sendHedera() {
   await pressUntilTextFound(DeviceLabels.APPROVE);
-  await pressBoth();
-}
+  await buttons.both();
+});

package/src/e2e/families/kaspa.ts

@@ -1,25 +1,37 @@
 import expect from "expect";
 import { waitFor, containsSubstringInEvent, pressUntilTextFound, 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 { Transaction } from "../models/Transaction";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export async function sendKaspa(tx: Transaction) {
-  await getSendEvents(tx);
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+export const sendKaspa = withDeviceController(
+  ({ getButtonsController }) =>
+    async (tx: Transaction) => {
+      const buttons = getButtonsController();
 
-export async function delegateKaspa(delegatingAccount: Delegate) {
-  await waitFor(DeviceLabels.REVIEW_OPERATION);
-  const events = await pressUntilTextFound(DeviceLabels.APPROVE);
-  const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
-  expect(isAmountCorrect).toBeTruthy();
-  await pressBoth();
-}
+      await getSendEvents(tx);
+
+      if (isTouchDevice()) {
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+      }
+    },
+);
+
+export const delegateKaspa = 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();
+    },
+);

package/src/e2e/families/multiversX.ts

@@ -1,16 +1,22 @@
 import { getDelegateEvents, pressUntilTextFound } from "../speculos";
 import { Delegate } from "../models/Delegate";
-import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { isTouchDevice } from "../speculosAppVersion";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export async function delegateMultiversX(delegatingAccount: Delegate) {
-  await getDelegateEvents(delegatingAccount);
-  if (isTouchDevice()) {
-    await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+export const delegateMultiversX = withDeviceController(
+  ({ getButtonsController }) =>
+    async (delegatingAccount: Delegate) => {
+      const buttons = getButtonsController();
+
+      await getDelegateEvents(delegatingAccount);
+
+      if (isTouchDevice()) {
+        await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+      }
+    },
+);

package/src/e2e/families/near.ts

@@ -7,23 +7,29 @@ import {
   pressUntilTextFound,
 } from "../speculos";
 import { isTouchDevice } from "../speculosAppVersion";
-import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { longPressAndRelease, pressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export async function delegateNear(delegatingAccount: Delegate) {
-  const events = await getDelegateEvents(delegatingAccount);
-  const isProviderCorrect = containsSubstringInEvent(delegatingAccount.provider, events);
-  expect(isProviderCorrect).toBeTruthy();
-  if (isTouchDevice()) {
-    await pressAndRelease(DeviceLabels.CONFIRM_HEADER);
-    await waitFor(DeviceLabels.VIEW_ACTION);
-    await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-    await waitFor(DeviceLabels.VIEW_ACTION);
-    await pressUntilTextFound(DeviceLabels.SIGN);
-    await pressBoth();
-  }
-}
+export const delegateNear = withDeviceController(
+  ({ getButtonsController }) =>
+    async (delegatingAccount: Delegate) => {
+      const buttons = getButtonsController();
+
+      const events = await getDelegateEvents(delegatingAccount);
+      const isProviderCorrect = containsSubstringInEvent(delegatingAccount.provider, events);
+      expect(isProviderCorrect).toBeTruthy();
+
+      if (isTouchDevice()) {
+        await pressAndRelease(DeviceLabels.CONFIRM_HEADER);
+        await waitFor(DeviceLabels.VIEW_ACTION);
+        await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+        await waitFor(DeviceLabels.VIEW_ACTION);
+        await pressUntilTextFound(DeviceLabels.SIGN);
+        await buttons.both();
+      }
+    },
+);

package/src/e2e/families/osmosis.ts

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