@ledgerhq/live-common 34.54.0 → 34.55.0-nightly.20251210114107

package/src/bridge/generic-alpaca/utils.test.ts

@@ -166,10 +166,12 @@ describe("Alpaca utils", () => {
           },
           ...params,
         } as GenericTransaction,
+        3n,
       );
 
       expect(operation).toMatchObject({
         id: `parent-account-id--${expected.parentType}`,
+        transactionSequenceNumber: new BigNumber(3),
         type: expected.parentType,
         value: expected.parentValue,
         accountId: "parent-account-id",
@@ -194,10 +196,12 @@ describe("Alpaca utils", () => {
               subOperations: [
                 {
                   id: `sub-account-id--${expected.subType}`,
+                  transactionSequenceNumber: new BigNumber(3),
                   accountId: "sub-account-id",
                   type: expected.subType,
                   senders: ["account-address"],
                   recipients: ["recipient-address"],
+                  fee: new BigNumber(12),
                   value: new BigNumber(50),
                   blockHash: null,
                   blockHeight: null,

package/src/bridge/generic-alpaca/utils.ts

@@ -72,6 +72,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     parentRecipients?: string[];
     ledgerOpType?: string | undefined;
     memo?: string | undefined;
+    internal?: boolean;
   } = {};
 
   if (op.details?.ledgerOpType !== undefined) {
@@ -106,6 +107,11 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
   if (op.details?.memo) {
     extra.memo = op.details.memo as string;
   }
+
+  if (op.details?.internal === true) {
+    extra.internal = op.details?.internal;
+  }
+
   const bnFees = new BigNumber(op.tx.fees.toString());
   const hasFailed = op.tx.failed;
 
@@ -214,6 +220,7 @@ export function transactionToIntent(
       transaction.nonce !== null && transaction.nonce !== undefined
         ? BigInt(transaction.nonce.toString())
         : undefined,
+    sponsored: transaction.sponsored,
   };
   if (transaction.assetReference && transaction.assetOwner) {
     const { subAccountId } = transaction;
@@ -265,8 +272,11 @@ function toGenericTransactionRaw(transaction: GenericTransaction): GenericTransa
     family: transaction.family,
   };
 
-  if ("useAllAmount" in transaction) {
-    raw.useAllAmount = transaction.useAllAmount;
+  const booleanFieldsToPropagate = ["useAllAmount", "sponsored"] as const;
+  for (const field of booleanFieldsToPropagate) {
+    if (field in transaction) {
+      raw[field] = transaction[field];
+    }
   }
 
   const stringFieldsToPropagate = [
@@ -296,6 +306,7 @@ function toGenericTransactionRaw(transaction: GenericTransaction): GenericTransa
     "gasPrice",
     "maxFeePerGas",
     "maxPriorityFeePerGas",
+    "additionalFees",
   ] as const;
   for (const field of bigNumberFieldsToPropagate) {
     if (field in transaction) {
@@ -407,11 +418,12 @@ export const buildOptimisticOperation = (
         hash: "",
         type,
         value: transaction.useAllAmount ? tokenAccount.balance : transaction.amount,
-        fee: new BigNumber(0),
+        fee: new BigNumber(fees.toString()),
         blockHash: null,
         blockHeight: null,
         senders: [account.freshAddress],
         recipients: [transaction.recipient],
+        transactionSequenceNumber: new BigNumber(sequenceNumber?.toString() ?? 0),
         accountId: subAccountId,
         date: new Date(),
         transactionRaw: toGenericTransactionRaw({

package/src/bridge/impl.ts

@@ -23,6 +23,7 @@ import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/erro
 // Removed: stores are now managed globally by @ledgerhq/cryptoassets/cal-client/store
 
 const alpacaized = {
+  evm: true,
   xrp: true,
   stellar: true,
   tezos: true,
@@ -35,7 +36,13 @@ const currencyBridgeCache: Record<string, CurrencyBridge> = {};
 export const getCurrencyBridge = (currency: CryptoCurrency): CurrencyBridge => {
   if (getEnv("MOCK")) {
     const mockBridge = mockBridges[currency.family];
-    if (mockBridge) return mockBridge.currencyBridge;
+    // TODO Remove once we delete mock bridges tests
+    if (mockBridge) {
+      if (typeof mockBridge.loadCoinConfig === "function") {
+        mockBridge.loadCoinConfig();
+      }
+      return mockBridge.currencyBridge;
+    }
     throw new CurrencyNotSupported("no mock implementation available for currency " + currency.id, {
       currencyName: currency.id,
     });
@@ -85,13 +92,19 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
 
     if (type === "mock") {
       const mockBridge = mockBridges[family];
-      if (mockBridge) return wrapAccountBridge(mockBridge.accountBridge);
+      // TODO Remove once we delete mock bridges tests
+      if (mockBridge) {
+        if (typeof mockBridge.loadCoinConfig === "function") {
+          mockBridge.loadCoinConfig();
+        }
+        return wrapAccountBridge(mockBridge.accountBridge);
+      }
     }
   }
 
   if (alpacaized[family]) {
     if (!bridgeCache[family]) {
-      bridgeCache[family] = getAlpacaAccountBridge(family, "local");
+      bridgeCache[family] = wrapAccountBridge(getAlpacaAccountBridge(family, "local"));
     }
     return bridgeCache[family];
   }

package/src/bridge/react/BridgeSync.tsx

@@ -48,7 +48,7 @@ export const BridgeSync = ({
   prepareCurrency,
   hydrateCurrency,
   blacklistedTokenIds,
-}: Props): JSX.Element => {
+}: Props): React.JSX.Element => {
   useHydrate({
     accounts,
     hydrateCurrency,

package/src/currencies/helpers.test.ts

@@ -1,5 +1,5 @@
 import "../__tests__/test-helpers/setup";
-import { isCryptoCurrency } from "./helpers";
+import { isCryptoCurrency, getFamilyByCurrencyId } from "./helpers";
 import { listCryptoCurrencies } from ".";
 
 describe("Currencies helpers", () => {
@@ -10,4 +10,13 @@ describe("Currencies helpers", () => {
       expect(isCryptoCurrency(currency)).toBeTruthy();
     });
   });
+
+  test("getFamilyByCurrencyId returns correct family for a known currency id", () => {
+    expect(getFamilyByCurrencyId("bitcoin")).toBe("bitcoin");
+    expect(getFamilyByCurrencyId("ethereum")).toBe("evm");
+  });
+
+  test("getFamilyByCurrencyId returns undefined for an unknown currency id", () => {
+    expect(getFamilyByCurrencyId("unknown_currency_id")).toBeUndefined();
+  });
 });

package/src/currencies/helpers.ts

@@ -1,4 +1,5 @@
 import { Currency, CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { findCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 
 export function isCryptoCurrency(currency: Currency): currency is CryptoCurrency {
   return currency.type === "CryptoCurrency";
@@ -15,3 +16,8 @@ export function isUTXOCompliant(currencyFamily: string): boolean {
 export type CurrencyFilters = {
   currencies?: string[];
 };
+
+export function getFamilyByCurrencyId(currencyId: string): CryptoCurrency["family"] | undefined {
+  const currency = findCryptoCurrencyById(currencyId);
+  return currency?.family;
+}

package/src/deposit/api.ts

@@ -1,11 +1,11 @@
 import { getEnv } from "@ledgerhq/live-env";
-import network from "@ledgerhq/live-network/network";
+import network from "@ledgerhq/live-network";
 import { MappedAsset } from "./type";
 
 const ROOT_PATH = getEnv("MAPPING_SERVICE");
 
 export async function getMappedAssets(): Promise<MappedAsset[]> {
   const url = `${ROOT_PATH}/v1/coingecko/mapped-assets`;
-  const { data } = await network({ method: "GET", url });
+  const { data } = await network<MappedAsset[]>({ method: "GET", url });
   return data;
 }

package/src/domain/getTokensWithFunds.ts

@@ -1,11 +1,8 @@
 import { getParentAccount } from "@ledgerhq/coin-framework/account/helpers";
 import { Account } from "@ledgerhq/types-live";
 
-export const getTokensWithFunds = (accounts: Account[]): string[] => {
-  if (!accounts?.length) return [];
-
-  const tokensMap = new Map<string, { ticker: string; networkName: string }>();
-
+export const getTokensWithFundsMap = (accounts: Account[]) => {
+  const tokensMap = new Map<string, { ticker: string; networkName: string; id: string }>();
   for (const account of accounts) {
     const { balance, currency } = account || {};
     if (!balance?.gt(0) || !currency) continue;
@@ -18,6 +15,7 @@ export const getTokensWithFunds = (accounts: Account[]): string[] => {
     tokensMap.set(mainKey, {
       ticker: currency.ticker,
       networkName,
+      id: currency.id,
     });
 
     account.subAccounts?.forEach(subAccount => {
@@ -28,9 +26,24 @@ export const getTokensWithFunds = (accounts: Account[]): string[] => {
       tokensMap.set(subKey, {
         ticker: token.ticker,
         networkName,
+        id: token.id,
       });
     });
   }
+  return tokensMap;
+};
+/** Format defaults to "USDT on Ethereum". format: "currencyId" returns the id of each token, e.g. "ethereum/erc20/usde". */
+export const getTokensWithFunds = (
+  accounts: Account[],
+  customFormat: "currencyId" | "default" = "default",
+) => {
+  if (!accounts?.length) return [];
+
+  const tokensMap = getTokensWithFundsMap(accounts);
+
+  if (customFormat === "currencyId") {
+    return Array.from(tokensMap.values(), token => token.id);
+  }
 
   return Array.from(tokensMap.values(), ({ ticker, networkName }) => `${ticker} on ${networkName}`);
 };

package/src/domain/getTotalStakeableAssets.test.ts

@@ -0,0 +1,267 @@
+import { genAccount } from "@ledgerhq/coin-framework/lib/mocks/account";
+import { getCryptoCurrencyById } from "../currencies/index";
+import { Account } from "@ledgerhq/types-live";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import BigNumber from "bignumber.js";
+import { getTotalStakeableAssets } from "./getTotalStakeableAssets";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
+
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
+
+const ETH = getCryptoCurrencyById("ethereum");
+const BTC = getCryptoCurrencyById("bitcoin");
+
+// Create mock tokens for tests
+const ZRX_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/0x_project",
+  contractAddress: "0xE41d2489571d322189246DaFA5ebDe1F4699F498",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "0x Project",
+  ticker: "ZRX",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "ZRX", code: "ZRX", magnitude: 18 }],
+};
+
+const REP_TOKEN: TokenCurrency = {
+  type: "TokenCurrency",
+  id: "ethereum/erc20/augur",
+  contractAddress: "0x1985365e9f78359a9B6AD760e32412f4a445E862",
+  parentCurrency: ETH,
+  tokenType: "erc20",
+  name: "Augur",
+  ticker: "REP",
+  delisted: false,
+  disableCountervalue: false,
+  units: [{ name: "REP", code: "REP", magnitude: 18 }],
+};
+
+const mockedAccounts: Account[] = [
+  genAccount("mocked-account-1", {
+    currency: ETH,
+    tokensData: [ZRX_TOKEN, REP_TOKEN],
+  }),
+];
+
+describe("getTotalStakeableAssets", () => {
+  it("should return empty Set if no accounts", () => {
+    const result = getTotalStakeableAssets([], [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if accounts is null", () => {
+    const result = getTotalStakeableAssets(null, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if accounts is undefined", () => {
+    const result = getTotalStakeableAssets(undefined, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return empty Set if no staking currencies enabled", () => {
+    const result = getTotalStakeableAssets(mockedAccounts, [], []);
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should return Set with matching currency ID when staking currency is enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id]; // "ethereum"
+
+    expect(account.balance).toBeTruthy();
+    expect(account.balance instanceof BigNumber).toBe(true);
+    expect(account.balance.gt(0)).toBe(true);
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual({
+      ticker: ETH.ticker,
+      networkName: ETH.name,
+      id: ETH.id,
+    });
+  });
+
+  it("should return Set with matching token IDs when staking tokens are enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
+
+    expect(account.subAccounts).toBeDefined();
+    expect(account.subAccounts?.length).toBe(2);
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should return Set with both currency and token IDs when both are enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id, ZRX_TOKEN.id, REP_TOKEN.id];
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(3);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(3);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+        expect.objectContaining({ id: REP_TOKEN.id, ticker: REP_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should filter out currencies without funds", () => {
+    const account = mockedAccounts[0];
+    const accountWithZeroBalance = { ...account, balance: new BigNumber(0) };
+    const stakingCurrenciesEnabled = [ETH.id];
+
+    const result = getTotalStakeableAssets([accountWithZeroBalance], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+
+  it("should filter out tokens without funds", () => {
+    const account = mockedAccounts[0];
+    const [zrxAccount, repAccount] = account.subAccounts || [];
+    const emptyRepAccount = { ...repAccount, balance: new BigNumber(0) };
+    const accountWithEmptyToken = { ...account, subAccounts: [zrxAccount, emptyRepAccount] };
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id, REP_TOKEN.id];
+
+    const result = getTotalStakeableAssets([accountWithEmptyToken], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual(
+      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+    );
+  });
+
+  it("should include partner staking currencies enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id];
+    const partnerStakingCurrenciesEnabled = [ZRX_TOKEN.id];
+
+    const result = getTotalStakeableAssets(
+      [account],
+      stakingCurrenciesEnabled,
+      partnerStakingCurrenciesEnabled,
+    );
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+      ]),
+    );
+  });
+
+  it("should deduplicate IDs when same currency appears in both lists", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ETH.id];
+    const partnerStakingCurrenciesEnabled = [ETH.id]; // Same currency
+
+    const result = getTotalStakeableAssets(
+      [account],
+      stakingCurrenciesEnabled,
+      partnerStakingCurrenciesEnabled,
+    );
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual({
+      ticker: ETH.ticker,
+      networkName: ETH.name,
+      id: ETH.id,
+    });
+  });
+
+  it("should handle multiple accounts with different currencies", () => {
+    const ethAccount = mockedAccounts[0];
+    const btcAccount = genAccount("mocked-account-2", {
+      currency: BTC,
+    });
+    const accounts = [ethAccount, btcAccount];
+    const stakingCurrenciesEnabled = [ETH.id, BTC.id];
+
+    const result = getTotalStakeableAssets(accounts, stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(2);
+    expect(result.combinedIds.has(ETH.id)).toBe(true);
+    expect(result.combinedIds.has(BTC.id)).toBe(true);
+    expect(result.stakeableAssets.length).toBe(2);
+    expect(result.stakeableAssets).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: ETH.id, ticker: ETH.ticker }),
+        expect.objectContaining({ id: BTC.id, ticker: BTC.ticker }),
+      ]),
+    );
+  });
+
+  it("should only include IDs that match staking currencies enabled", () => {
+    const account = mockedAccounts[0];
+    const stakingCurrenciesEnabled = [ZRX_TOKEN.id]; // Only ZRX enabled, not ETH or REP
+
+    const result = getTotalStakeableAssets([account], stakingCurrenciesEnabled, []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(1);
+    expect(result.combinedIds.has(ZRX_TOKEN.id)).toBe(true);
+    expect(result.combinedIds.has(ETH.id)).toBe(false);
+    expect(result.combinedIds.has(REP_TOKEN.id)).toBe(false);
+    expect(result.stakeableAssets.length).toBe(1);
+    expect(result.stakeableAssets[0]).toEqual(
+      expect.objectContaining({ id: ZRX_TOKEN.id, ticker: ZRX_TOKEN.ticker }),
+    );
+  });
+
+  it("should handle empty arrays for staking currencies", () => {
+    const account = mockedAccounts[0];
+    const result = getTotalStakeableAssets([account], [], []);
+
+    expect(result.combinedIds).toBeInstanceOf(Set);
+    expect(result.combinedIds.size).toBe(0);
+    expect(result.stakeableAssets).toEqual([]);
+  });
+});

package/src/domain/getTotalStakeableAssets.ts

@@ -0,0 +1,47 @@
+import { getTokensWithFundsMap } from "./getTokensWithFunds";
+import { Account } from "@ledgerhq/types-live";
+
+export function getTotalStakeableAssets(
+  accounts: Account[] | null | undefined,
+  stakingCurrenciesEnabled: string[],
+  partnerStakingCurrenciesEnabled: string[],
+): {
+  combinedIds: Set<string>;
+  stakeableAssets: { ticker: string; networkName: string; id: string }[];
+} {
+  if (!accounts) return { combinedIds: new Set<string>(), stakeableAssets: [] };
+
+  const accountsWithFundsCurrencies = accounts
+    .filter(account => account?.balance.isGreaterThan(0))
+    .map(account => account?.currency);
+
+  const allStakingCurrenciesEnabled = new Set([
+    ...stakingCurrenciesEnabled,
+    ...partnerStakingCurrenciesEnabled,
+  ]);
+
+  const tokenWithFundsMap = getTokensWithFundsMap(accounts);
+  const filteredAccountCurrencyIds = [...accountsWithFundsCurrencies].filter(currency =>
+    allStakingCurrenciesEnabled.has(currency.id),
+  );
+  const filteredTokenWithFunds = [...tokenWithFundsMap.values()].filter(token =>
+    allStakingCurrenciesEnabled.has(token.id),
+  );
+
+  const combined = new Map<string, { ticker: string; networkName: string; id: string }>();
+  for (const currency of filteredAccountCurrencyIds) {
+    combined.set(currency.id, {
+      ticker: currency.ticker,
+      networkName: currency.name,
+      id: currency.id,
+    });
+  }
+  for (const token of filteredTokenWithFunds) {
+    combined.set(token.id, token);
+  }
+
+  return {
+    combinedIds: new Set(Array.from(combined.values(), details => details.id)),
+    stakeableAssets: Array.from(combined.values()),
+  };
+}

package/src/e2e/data/deviceLabelsData.ts

@@ -112,6 +112,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
   },
   [DeviceModelId.stax]: TOUCHSCREEN_DEVICE_CONFIG,
   [DeviceModelId.europa]: TOUCHSCREEN_DEVICE_CONFIG,
+  [DeviceModelId.apex]: TOUCHSCREEN_DEVICE_CONFIG,
   default: {
     receiveVerify: {
       [AppInfos.BNB_CHAIN.name]: DeviceLabels.VERIFY_BSC,

package/src/e2e/data/regexes.ts

@@ -0,0 +1 @@
+export const floatNumberRegex = /^\d+\.?\d+$/;

package/src/e2e/enum/Device.ts

@@ -9,4 +9,5 @@ export class Device {
   static readonly LNSP = new Device("nanoSP", 856686596);
   static readonly STAX = new Device("stax", 857735172);
   static readonly FLEX = new Device("flex", 858783748);
+  static readonly NANO_GEN_5 = new Device("nanoGen5", 859832324);
 }

package/src/e2e/families/cardano.ts

@@ -22,7 +22,7 @@ function validateTransactionData(tx: Transaction, events: string[]) {
 
 async function sendCardanoTouchDevices(tx: Transaction) {
   await waitFor(DeviceLabels.REVIEW_TRANSACTION);
-  const events = await pressUntilTextFound(DeviceLabels.TO);
+  const events = await pressUntilTextFound(DeviceLabels.AMOUNT);
   validateTransactionData(tx, events);
   await pressAndRelease(DeviceLabels.TAP_TO_CONTINUE);
   await waitFor(DeviceLabels.FEES);
@@ -77,18 +77,22 @@ export async function sendCardano(tx: Transaction) {
   return sendCardanoButtonDevice(tx);
 }
 
+const TOUCH_DELEGATE_STEPS = [
+  [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;
+
 const DELEGATE_STEPS_CONFIG = {
-  [DeviceModelId.stax || DeviceModelId.europa]: [
-    [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.stax]: TOUCH_DELEGATE_STEPS,
+  [DeviceModelId.europa]: TOUCH_DELEGATE_STEPS,
+  [DeviceModelId.apex]: TOUCH_DELEGATE_STEPS,
   [DeviceModelId.nanoS]: [
     [DeviceLabels.NEW_ORDINARY, "right"],
     [DeviceLabels.TRANSACTION_FEE, "both"],
@@ -115,8 +119,22 @@ const DELEGATE_STEPS_CONFIG = {
   ] as const,
 };
 
+function getConfirmButtonCoords(): { x: number; y: number } {
+  const speculosModel = getSpeculosModel();
+
+  switch (speculosModel) {
+    case DeviceModelId.stax:
+      return { x: 152, y: 532 };
+    case DeviceModelId.apex:
+      return { x: 114, y: 305 };
+    case DeviceModelId.europa:
+    default:
+      return { x: 186, y: 446 };
+  }
+}
+
 async function delegateTouchDevicesAction(label: DeviceLabels) {
-  const CONFIRM_BUTTON_COORDS = { x: 139, y: 532 };
+  const CONFIRM_BUTTON_COORDS = getConfirmButtonCoords();
   await waitFor(label);
   switch (label) {
     case DeviceLabels.TAP_TO_CONTINUE:
@@ -164,7 +182,7 @@ async function executeDelegateStep(label: DeviceLabels, action: ActionType) {
 export async function delegateCardano() {
   const speculosModel = getSpeculosModel();
   const steps =
-    speculosModel === DeviceModelId.stax || speculosModel === DeviceModelId.europa
+    isTouchDevice() && DELEGATE_STEPS_CONFIG[speculosModel]
       ? DELEGATE_STEPS_CONFIG[speculosModel]
       : speculosModel === DeviceModelId.nanoS
         ? DELEGATE_STEPS_CONFIG[DeviceModelId.nanoS]

package/src/e2e/index.ts

@@ -1,6 +1,7 @@
 import { EnvName } from "@ledgerhq/live-env";
 import { Feature, FeatureId } from "@ledgerhq/types-live";
 import { getFeature, DEFAULT_FEATURES } from "../featureFlags";
+import axios, { AxiosError } from "axios";
 
 export const getAllFeatureFlags = (
   appLanguage?: string,
@@ -53,3 +54,22 @@ export const formatEnvData = (data: { [key in EnvName]: unknown }) => {
   }
   return allureData;
 };
+
+export const sanitizeError = (error: unknown): Error => {
+  if (!axios.isAxiosError(error)) {
+    return error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
+  }
+
+  const err = error as AxiosError;
+  const sanitized = new Error(err.message || "Axios request failed");
+
+  Object.assign(sanitized, {
+    name: err.name,
+    code: err.code,
+    url: err.config?.url,
+    method: err.config?.method,
+    status: err.response?.status,
+  });
+
+  return sanitized;
+};