@ledgerhq/live-common 34.51.0-nightly.9 → 34.52.0-nightly.0

package/src/e2e/deviceInteraction/TouchDeviceSimulator.ts

@@ -0,0 +1,52 @@
+import { retryAxiosRequest, getSpeculosAddress, getDeviceLabelCoordinates } from "../speculos";
+import axios from "axios";
+import { getEnv } from "@ledgerhq/live-env";
+
+function getSpeculosInfo(): {
+  speculosApiPort: number;
+  speculosAddress: string;
+} {
+  const speculosApiPort = getEnv("SPECULOS_API_PORT");
+  const speculosAddress = getSpeculosAddress();
+  return { speculosApiPort, speculosAddress };
+}
+export async function pressAndRelease(deviceLabel: string, x?: number, y?: number) {
+  const { speculosApiPort, speculosAddress } = getSpeculosInfo();
+  const { x: coordX, y: coordY } = await getDeviceLabelCoordinates(deviceLabel, speculosApiPort);
+  x = x === undefined ? coordX : x;
+  y = y === undefined ? coordY : y;
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/finger`, {
+      action: "press-and-release",
+      x: x,
+      y: y,
+    }),
+  );
+}
+
+export async function longPressAndRelease(deviceLabel: string, delay: number) {
+  const { speculosApiPort, speculosAddress } = getSpeculosInfo();
+  const deviceLabelCoordinates = await getDeviceLabelCoordinates(deviceLabel, speculosApiPort);
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/finger`, {
+      action: "press-and-release",
+      x: deviceLabelCoordinates.x,
+      y: deviceLabelCoordinates.y,
+      delay: delay,
+    }),
+  );
+}
+
+export async function swipeRight() {
+  const { speculosApiPort, speculosAddress } = getSpeculosInfo();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/finger`, {
+      action: "press-and-release",
+      x: 100,
+      y: 100,
+      x2: 50,
+      y2: 100,
+      delay: 0.5,
+    }),
+  );
+}

package/src/e2e/enum/Account.ts

@@ -1,6 +1,5 @@
 import { Currency } from "./Currency";
 import { TokenType } from "./TokenType";
-import { Nft } from "./Nft";
 
 export class Account {
   constructor(
@@ -11,7 +10,6 @@ export class Account {
     public readonly tokenType?: TokenType,
     public readonly ensName?: string,
     public readonly derivationMode?: string,
-    public readonly nft?: Nft[],
     public readonly parentAccount?: Account,
   ) {}
 
@@ -246,7 +244,6 @@ export class Account {
     undefined,
     undefined,
     undefined,
-    [Nft.ANTITUS, Nft.PODIUM, Nft.NY_LA_MUSE],
   );
   // don't use this account as a recipient, it's balance
   // should stay close to null to allow for error message testing
@@ -361,7 +358,6 @@ export class Account {
     undefined,
     undefined,
     undefined,
-    [Nft.ANIME_SHIPS_494, Nft.BISHOP_OF_STORMS, Nft.COMMON_TOWER_MAP],
   );
   static readonly POL_2 = new Account(
     Currency.POL,
@@ -552,19 +548,8 @@ export class TokenAccount extends Account {
     parentAccount: Account,
     ensName?: string,
     derivationMode?: string,
-    nft?: Nft[],
   ) {
-    super(
-      currency,
-      accountName,
-      address,
-      index,
-      tokenType,
-      ensName,
-      derivationMode,
-      nft,
-      parentAccount,
-    );
+    super(currency, accountName, address, index, tokenType, ensName, derivationMode, parentAccount);
   }
 
   static readonly ETH_LIDO = new TokenAccount(

package/src/e2e/enum/Device.ts

@@ -7,4 +7,5 @@ export class Device {
   static readonly LNS = new Device("nanoS", 823132164);
   static readonly LNX = new Device("nanoX", 855638020);
   static readonly LNSP = new Device("nanoSP", 856686596);
+  static readonly STAX = new Device("stax", 857735172);
 }

package/src/e2e/enum/DeviceLabels.ts

@@ -12,6 +12,8 @@ export enum DeviceLabels {
   CONFIRM = "Confirm",
   CONNECT = "Connect",
   CONNECT_TO = "Connect to",
+  CONNECT_WITH = "Connect with",
+  CONNECT_WITH_LEDGER_SYNC = "Connect with Ledger Sync",
   CONTINUE = "Continue",
   CONTINUE_TO_ACTION = "Continue to actions",
   CONTRACT_DATA = "Contract data",
@@ -35,20 +37,22 @@ export enum DeviceLabels {
   REMOVE = "Remove",
   REMOVE_FROM_LEDGER_SYNC = "Remove from",
   REVIEW_OPERATION = "Review",
+  REMOVE_PHONE_OR_COMPUTER = "Remove phone or computer",
   REVIEW_TRANSACTION = "Review transaction",
   SEND = "Send",
   SEND_TO_ADDRESS = "Send to address",
   SEND_TO_ADDRESS_2 = "Send to address (2/2)",
   SETTINGS = "Settings",
+  SETTINGS_TOGGLE_1 = "Settings toggle 1",
   SIGN = "Sign",
   SIGN_TRANSACTION = "Sign transaction",
   STAKE_KEY = "Stake key",
   TO = "To",
   TRANSACTION_FEE = "Transaction fee",
   TRANSACTION_SIGNED = "Transaction Signed",
+  TRANSACTION_TYPE = "Transaction Type",
   TRANSFER = "Transfer",
   TURN_ON_SYNC = "Turn on sync",
-  TURN_ON_SYNC2 = "Turn On sync",
   TYPE_DELEGATE = "Type Delegate",
   VALUE = "Value",
   VERIFY_ADDRESS = "Verify address",
@@ -58,4 +62,8 @@ export enum DeviceLabels {
   VERIFY_SOLANA_ADDRESS = "Verify Solana address",
   VIEW_ACTION = "View action",
   VIEW_HEADER = "View Header",
+  HOLD_TO_SIGN = "Hold to sign",
+  CONFIRM_HEADER = "Confirm header",
+  CONFIRM_CHANGE = "Confirm change",
+  TAP_TO_CONTINUE = "Tap to continue",
 }

package/src/e2e/families/algorand.ts

@@ -1,14 +1,20 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
-import { pressBoth, pressUntilTextFound, containsSubstringInEvent } from "../speculos";
+import { containsSubstringInEvent, getSendEvents } from "../speculos";
+import { isTouchDevice } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
+import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
 
 export async function sendAlgorand(tx: Transaction) {
-  const events = await pressUntilTextFound(DeviceLabels.CAPS_APPROVE);
+  const events = await getSendEvents(tx);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
   const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
   expect(isAddressCorrect).toBeTruthy();
-
-  await pressBoth();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }

package/src/e2e/families/aptos.ts

@@ -1,11 +1,19 @@
 import expect from "expect";
-import { pressBoth, pressUntilTextFound, waitFor, containsSubstringInEvent } from "../speculos";
+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";
 
-export async function sendAptos() {
-  await pressUntilTextFound(DeviceLabels.APPROVE);
-  await pressBoth();
+export async function sendAptos(tx: Transaction) {
+  await getSendEvents(tx);
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }
 
 export async function delegateAptos(delegatingAccount: Delegate) {

package/src/e2e/families/bitcoin.ts

@@ -1,41 +1,48 @@
 import expect from "expect";
 import { Transaction } from "../models/Transaction";
-import { pressBoth, pressUntilTextFound, waitFor, containsSubstringInEvent } from "../speculos";
-import { getSpeculosModel } from "../speculosAppVersion";
+import { waitFor, containsSubstringInEvent, pressUntilTextFound, getSendEvents } from "../speculos";
+import { getSpeculosModel, isTouchDevice } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
-import { Device } from "../enum/Device";
 import invariant from "invariant";
+import { DeviceModelId } from "@ledgerhq/types-devices";
+import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
 
 export async function sendBTCBasedCoin(tx: Transaction) {
-  const events = await pressUntilTextFound(DeviceLabels.ACCEPT);
+  const events = await getSendEvents(tx);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
   const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
   expect(isAddressCorrect).toBeTruthy();
-  await pressBoth();
-  await waitFor(DeviceLabels.CONFIRM);
-  await pressUntilTextFound(DeviceLabels.ACCEPT);
-  await pressBoth();
+  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 =
-      speculosDevice === Device.LNS.name
-        ? await pressUntilTextFound(DeviceLabels.CONTINUE)
-        : await pressUntilTextFound(DeviceLabels.SIGN_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();
-    await pressBoth();
-    if (speculosDevice === Device.LNS.name) {
-      await pressUntilTextFound(DeviceLabels.SIGN);
-      await pressBoth();
-      await waitFor(DeviceLabels.BITCOIN_IS_READY);
+    if (speculosDevice === DeviceModelId.stax) {
+      await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
     } else {
-      await waitFor(DeviceLabels.TRANSACTION_SIGNED);
+      await pressBoth();
+      if (speculosDevice === DeviceModelId.nanoS) {
+        await pressUntilTextFound(DeviceLabels.SIGN);
+        await pressBoth();
+        await waitFor(DeviceLabels.BITCOIN_IS_READY);
+      } else {
+        await waitFor(DeviceLabels.TRANSACTION_SIGNED);
+      }
     }
   } catch (e) {
     invariant(false, `Error while sending BTC transaction: ${e}`);

package/src/e2e/families/cardano.ts

@@ -1,81 +1,168 @@
 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 {
-  pressBoth,
-  pressUntilTextFound,
-  containsSubstringInEvent,
-  waitFor,
-  pressRightButton,
-} from "../speculos";
+  pressAndRelease,
+  longPressAndRelease,
+  swipeRight,
+} from "../deviceInteraction/TouchDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
-import { Device } from "../enum/Device";
+import { DeviceModelId } from "@ledgerhq/types-devices";
 
-export async function sendCardano(tx: Transaction) {
-  const isNanoS = process.env.SPECULOS_DEVICE === Device.LNS.name;
+type ActionType = "both" | "right" | "tap" | "swipe" | "confirm" | "hold";
+
+function validateTransactionData(tx: Transaction, events: string[]) {
+  const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
+  expect(isAddressCorrect).toBeTruthy();
+  const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
+  expect(isAmountCorrect).toBeTruthy();
+}
+
+async function sendCardanoStax(tx: Transaction) {
+  await waitFor(DeviceLabels.REVIEW_TRANSACTION);
+  const events = await pressUntilTextFound(DeviceLabels.TO);
+  validateTransactionData(tx, events);
+  await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
+  await waitFor(DeviceLabels.FEES);
+  await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
+  await waitFor(DeviceLabels.SIGN_TRANSACTION);
+  await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+}
+
+async function sendCardanoNanoS(_tx: Transaction) {
   await waitFor(DeviceLabels.NEW_ORDINARY);
-  await (isNanoS ? pressRightButton() : pressBoth());
-  if (isNanoS) {
-    await waitFor(DeviceLabels.SEND_TO_ADDRESS);
-    await pressBoth();
-  } else {
-    await pressUntilTextFound(DeviceLabels.SEND_TO_ADDRESS_2);
-    await pressBoth();
-  }
+  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();
+}
+
+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);
-  if (!isNanoS) {
-    const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
-    expect(isAmountCorrect).toBeTruthy();
-  }
+  validateTransactionData(tx, events);
   await pressBoth();
   await waitFor(DeviceLabels.TRANSACTION_FEE);
   await pressBoth();
   await waitFor(DeviceLabels.CONFIRM);
-  if (isNanoS) {
-    await pressRightButton();
-  } else {
-    await pressBoth();
-    const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
-    expect(isAddressCorrect).toBeTruthy();
+  await pressBoth();
+}
+
+export async function sendCardano(tx: Transaction) {
+  const speculosModel = getSpeculosModel();
+  if (speculosModel === DeviceModelId.stax) {
+    return sendCardanoStax(tx);
   }
+  if (speculosModel === DeviceModelId.nanoS) {
+    return sendCardanoNanoS(tx);
+  }
+  return sendCardanoButtonDevice(tx);
 }
 
-export async function delegateCardano() {
-  const commonSteps = [
-    [DeviceLabels.NEW_ORDINARY, "both"],
+const DELEGATE_STEPS_CONFIG = {
+  [DeviceModelId.stax]: [
+    [DeviceLabels.REVIEW_TRANSACTION, "swipe"],
+    [DeviceLabels.TAP_TO_CONTINUE, "tap"],
+    [DeviceLabels.REGISTER, "swipe"],
+    [DeviceLabels.TAP_TO_CONTINUE, "tap"],
+    [DeviceLabels.CONFIRM, "confirm"],
+    [DeviceLabels.DELEGATE_STAKE, "swipe"],
+    [DeviceLabels.TAP_TO_CONTINUE, "tap"],
+    [DeviceLabels.CONFIRM, "confirm"],
+    [DeviceLabels.HOLD_TO_SIGN, "hold"],
+  ] as const,
+  [DeviceModelId.nanoS]: [
+    [DeviceLabels.NEW_ORDINARY, "right"],
     [DeviceLabels.TRANSACTION_FEE, "both"],
     [DeviceLabels.REGISTER, "both"],
     [DeviceLabels.STAKE_KEY, "both"],
     [DeviceLabels.DEPOSIT, "both"],
-    [DeviceLabels.CONFIRM, "both"],
+    [DeviceLabels.CONFIRM, "right"],
     [DeviceLabels.DELEGATE_STAKE, "both"],
     [DeviceLabels.STAKE_KEY, "both"],
-    [DeviceLabels.CONFIRM, "both"],
-    [DeviceLabels.CONFIRM, "both"],
-  ] as const;
-
-  const LNSSpecificSteps = [
-    [DeviceLabels.NEW_ORDINARY, "right"],
+    [DeviceLabels.CONFIRM, "right"],
+    [DeviceLabels.CONFIRM, "right"],
+  ] as const,
+  default: [
+    [DeviceLabels.NEW_ORDINARY, "both"],
     [DeviceLabels.TRANSACTION_FEE, "both"],
     [DeviceLabels.REGISTER, "both"],
     [DeviceLabels.STAKE_KEY, "both"],
     [DeviceLabels.DEPOSIT, "both"],
-    [DeviceLabels.CONFIRM, "right"],
+    [DeviceLabels.CONFIRM, "both"],
     [DeviceLabels.DELEGATE_STAKE, "both"],
     [DeviceLabels.STAKE_KEY, "both"],
-    [DeviceLabels.CONFIRM, "right"],
-    [DeviceLabels.CONFIRM, "right"],
-  ] as const;
-
-  const steps = process.env.SPECULOS_DEVICE === Device.LNS.name ? LNSSpecificSteps : commonSteps;
+    [DeviceLabels.CONFIRM, "both"],
+    [DeviceLabels.CONFIRM, "both"],
+  ] as const,
+};
 
-  for (const [label, action] of steps) {
-    try {
-      await waitFor(label);
-      action === "both" ? await pressBoth() : await pressRightButton();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`Error while waiting for "${label}":`, message);
+async function delegateStaxAction(label: DeviceLabels) {
+  const CONFIRM_BUTTON_COORDS = { x: 139, y: 532 };
+  await waitFor(label);
+  switch (label) {
+    case DeviceLabels.TAP_TO_CONTINUE:
+      await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
+      break;
+    case DeviceLabels.CONFIRM:
+      await pressAndRelease(DeviceLabels.CONFIRM, CONFIRM_BUTTON_COORDS.x, CONFIRM_BUTTON_COORDS.y);
+      break;
+    case DeviceLabels.HOLD_TO_SIGN:
+      await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
       break;
+    default:
+      await swipeRight();
+      break;
+  }
+}
+
+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,
+  speculosModel: DeviceModelId,
+) {
+  try {
+    if (speculosModel === DeviceModelId.stax) {
+      await delegateStaxAction(label);
+    } else {
+      await delegateNanoAction(label, action);
     }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error while waiting for "${label}":`, message);
+    throw error;
+  }
+}
+
+export async function delegateCardano() {
+  const speculosModel = getSpeculosModel();
+  const steps =
+    speculosModel === DeviceModelId.stax
+      ? DELEGATE_STEPS_CONFIG[DeviceModelId.stax]
+      : speculosModel === DeviceModelId.nanoS
+        ? DELEGATE_STEPS_CONFIG[DeviceModelId.nanoS]
+        : DELEGATE_STEPS_CONFIG.default;
+
+  for (const [label, action] of steps) {
+    await executeDelegateStep(label, action, speculosModel);
   }
 }

package/src/e2e/families/celo.ts

@@ -1,10 +1,19 @@
-import { pressBoth, containsSubstringInEvent, getDelegateEvents } from "../speculos";
+import { containsSubstringInEvent, getDelegateEvents, pressUntilTextFound } from "../speculos";
+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";
 
 export async function delegateCelo(delegatingAccount: Delegate) {
   const events = await getDelegateEvents(delegatingAccount);
   const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
   expect(isAmountCorrect).toBeTruthy();
-  await pressBoth();
+  if (isTouchDevice()) {
+    await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }

package/src/e2e/families/cosmos.ts

@@ -1,27 +1,33 @@
 import expect from "expect";
 import { Delegate } from "../models/Delegate";
 import { Transaction } from "../models/Transaction";
-import {
-  pressBoth,
-  pressUntilTextFound,
-  containsSubstringInEvent,
-  getDelegateEvents,
-} from "../speculos";
+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";
 
 export async function delegateCosmos(delegatingAccount: Delegate) {
   const events = await getDelegateEvents(delegatingAccount);
   const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
   expect(isAmountCorrect).toBeTruthy();
-  await pressBoth();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }
 
 export async function sendCosmos(tx: Transaction) {
-  const events = await pressUntilTextFound(DeviceLabels.CAPS_APPROVE);
+  const events = await getSendEvents(tx);
   const isAmountCorrect = containsSubstringInEvent(tx.amount, events);
   expect(isAmountCorrect).toBeTruthy();
   const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
   expect(isAddressCorrect).toBeTruthy();
 
-  await pressBoth();
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }

package/src/e2e/families/evm.ts

@@ -1,16 +1,14 @@
 import expect from "expect";
-import { NFTTransaction, Transaction } from "../models/Transaction";
-import { pressBoth, pressUntilTextFound, containsSubstringInEvent, waitFor } from "../speculos";
+import { Transaction } from "../models/Transaction";
+import { containsSubstringInEvent, pressUntilTextFound } from "../speculos";
 import { getSpeculosModel } from "../speculosAppVersion";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
+import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Device } from "../enum/Device";
 import { DeviceModelId } from "@ledgerhq/types-devices";
 
-export async function sendEVM(tx: Transaction) {
-  const events =
-    getSpeculosModel() !== DeviceModelId.nanoS
-      ? await pressUntilTextFound(DeviceLabels.SIGN_TRANSACTION)
-      : await pressUntilTextFound(DeviceLabels.ACCEPT);
+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) {
@@ -20,14 +18,33 @@ export async function sendEVM(tx: Transaction) {
     const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
     expect(isAddressCorrect).toBeTruthy();
   }
+}
 
+async function sendEvmStax(tx: Transaction) {
+  const events = await pressUntilTextFound(DeviceLabels.HOLD_TO_SIGN);
+  validateTransactionData(tx, events);
+  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 async function sendEvmNFT(tx: NFTTransaction) {
-  await waitFor(DeviceLabels.REVIEW_OPERATION);
+async function sendEvmNanoS(tx: Transaction) {
   const events = await pressUntilTextFound(DeviceLabels.ACCEPT);
-  const isAddressCorrect = containsSubstringInEvent(tx.accountToCredit.address, events);
-  expect(isAddressCorrect).toBeTruthy();
+  validateTransactionData(tx, events);
   await pressBoth();
 }
+
+export async function sendEVM(tx: Transaction) {
+  const speculosModel = getSpeculosModel();
+  if (speculosModel === DeviceModelId.stax) {
+    return sendEvmStax(tx);
+  }
+  if (speculosModel === DeviceModelId.nanoS) {
+    return sendEvmNanoS(tx);
+  }
+  return sendEvmButtonDevice(tx);
+}

package/src/e2e/families/hedera.ts

@@ -1,5 +1,6 @@
-import { pressBoth, pressUntilTextFound } from "../speculos";
+import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
+import { pressUntilTextFound } from "../speculos";
 
 export async function sendHedera() {
   await pressUntilTextFound(DeviceLabels.APPROVE);

package/src/e2e/families/kaspa.ts

@@ -1,11 +1,19 @@
 import expect from "expect";
-import { pressBoth, pressUntilTextFound, waitFor, containsSubstringInEvent } from "../speculos";
+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";
 
-export async function sendKaspa() {
-  await pressUntilTextFound(DeviceLabels.APPROVE);
-  await pressBoth();
+export async function sendKaspa(tx: Transaction) {
+  await getSendEvents(tx);
+  if (isTouchDevice()) {
+    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+  } else {
+    await pressBoth();
+  }
 }
 
 export async function delegateKaspa(delegatingAccount: Delegate) {