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

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;
+};

package/src/e2e/speculos.ts

@@ -49,6 +49,7 @@ import {
   swipeRight,
 } from "./deviceInteraction/TouchDeviceSimulator";
 import { withDeviceController } from "./deviceInteraction/DeviceController";
+import { sanitizeError } from ".";
 
 const isSpeculosRemote = process.env.REMOTE_SPECULOS === "true";
 
@@ -428,7 +429,7 @@ export async function startSpeculos(
           };
         });
   } catch (e: unknown) {
-    console.error(e);
+    console.error(sanitizeError(e));
     log("engine", `test ${testName} failed with ${String(e)}`);
   }
 }
@@ -610,7 +611,7 @@ export async function takeScreenshot(port?: number): Promise<Buffer | undefined>
     );
     return response.data;
   } catch (error) {
-    console.error("Error downloading speculos screenshot:", error);
+    console.error("Error downloading speculos screenshot:", sanitizeError(error));
   }
 }
 
@@ -668,12 +669,42 @@ export const activateLedgerSync = withDeviceController(({ getButtonsController }
   }
 });
 
+const getSettingsToggle1Coordinates = () => {
+  const deviceModel = getSpeculosModel();
+
+  switch (deviceModel) {
+    case DeviceModelId.stax:
+      return { x: 345, y: 136 };
+    case DeviceModelId.europa:
+      return { x: 420, y: 140 };
+    case DeviceModelId.apex:
+      return { x: 263, y: 100 };
+    default:
+      return { x: 420, y: 140 };
+  }
+};
+
+const getSettingsCogwheelCoordinates = () => {
+  const deviceModel = getSpeculosModel();
+
+  switch (deviceModel) {
+    case DeviceModelId.stax:
+      return { x: 362, y: 43 };
+    case DeviceModelId.europa:
+      return { x: 400, y: 80 };
+    case DeviceModelId.apex:
+      return { x: 253, y: 58 };
+    default:
+      return { x: 400, y: 80 };
+  }
+};
+
 export const activateExpertMode = withDeviceController(({ getButtonsController }) => async () => {
   const buttons = getButtonsController();
 
   if (isTouchDevice()) {
     await goToSettings();
-    const SettingsToggle1Coordinates = { x: 344, y: 136 };
+    const SettingsToggle1Coordinates = getSettingsToggle1Coordinates();
     await pressAndRelease(
       DeviceLabels.SETTINGS_TOGGLE_1,
       SettingsToggle1Coordinates.x,
@@ -698,7 +729,7 @@ export const goToSettings = withDeviceController(({ getButtonsController }) => a
   const buttons = getButtonsController();
 
   if (isTouchDevice()) {
-    const SettingsCogwheelCoordinates = { x: 400, y: 75 };
+    const SettingsCogwheelCoordinates = getSettingsCogwheelCoordinates();
     await pressAndRelease(
       DeviceLabels.SETTINGS,
       SettingsCogwheelCoordinates.x,

package/src/e2e/speculosAppVersion.ts

@@ -3,6 +3,7 @@ import { version } from "../../package.json";
 import { getEnv } from "@ledgerhq/live-env";
 import { DeviceModelId } from "@ledgerhq/devices";
 import { Device as CryptoWallet } from "./enum/Device";
+import { sanitizeError } from "./index";
 import * as fs from "fs";
 import * as path from "path";
 
@@ -18,6 +19,8 @@ export function getSpeculosModel(): DeviceModelId {
     case CryptoWallet.FLEX.name:
     case DeviceModelId.europa:
       return DeviceModelId.europa;
+    case CryptoWallet.NANO_GEN_5.name:
+      return DeviceModelId.apex;
     case CryptoWallet.LNSP.name:
     default:
       return DeviceModelId.nanoSP;
@@ -26,7 +29,9 @@ export function getSpeculosModel(): DeviceModelId {
 
 export function isTouchDevice(): boolean {
   const model = getSpeculosModel();
-  return model === DeviceModelId.stax || model === DeviceModelId.europa;
+  return (
+    model === DeviceModelId.stax || model === DeviceModelId.europa || model === DeviceModelId.apex
+  );
 }
 
 function getDeviceTargetId(device: DeviceModelId): number {
@@ -36,6 +41,7 @@ function getDeviceTargetId(device: DeviceModelId): number {
     [DeviceModelId.nanoSP]: CryptoWallet.LNSP.targetId,
     [DeviceModelId.stax]: CryptoWallet.STAX.targetId,
     [DeviceModelId.europa]: CryptoWallet.FLEX.targetId,
+    [DeviceModelId.apex]: CryptoWallet.NANO_GEN_5.targetId,
   };
   return modelToTargetIdMap[device];
 }
@@ -73,7 +79,7 @@ export async function createNanoAppJsonFile(nanoAppFilePath: string): Promise<vo
     }
     fs.writeFileSync(jsonFilePath, JSON.stringify(appCatalog, null, 2), "utf8");
   } catch (error) {
-    console.error("Unable to create app version file:", error);
+    console.error("Unable to create app version file:", sanitizeError(error));
   }
 }
 

package/src/e2e/swap.ts

@@ -1,11 +1,12 @@
 import { Account } from "./enum/Account";
+import { sanitizeError } from "./index";
 import axios from "axios";
 
 export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Account) {
   try {
     const requestConfig = {
       method: "GET",
-      url: `https://swap-stg.ledger-test.com/v5/quote`,
+      url: "https://swap-stg.ledger-test.com/v5/quote",
       params: {
         from: AccountFrom.currency.id,
         to: AccountTo.currency.id,
@@ -21,9 +22,7 @@ export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Acco
         tradeType: "INPUT",
         uniswapOrderType: "uniswapxv1",
       },
-      headers: {
-        accept: "application/json",
-      },
+      headers: { accept: "application/json" },
     };
 
     const { data } = await axios(requestConfig);
@@ -38,8 +37,10 @@ export async function getMinimumSwapAmount(AccountFrom: Account, AccountTo: Acco
     }
 
     return Math.max(...minimumAmounts);
-  } catch (error) {
-    console.error("Error fetching swap minimum amount:", error);
-    throw error;
+  } catch (error: any) {
+    const sanitizedError = sanitizeError(error);
+    console.error("Error fetching swap minimum amount:", sanitizedError);
+    // throw the sanitized error, not the original circular Axios error
+    throw sanitizedError;
   }
 }

package/src/exchange/swap/api/v5/fetchCurrencyFrom.ts

@@ -45,7 +45,7 @@ export async function fetchCurrencyFrom({
       ...(headers !== undefined ? { headers } : {}),
     });
     return flattenV5CurrenciesToAndFrom(data);
-  } catch (e) {
+  } catch {
     throw Error("Something went wrong in fetchCurrencyFrom call");
   }
 }

package/src/exchange/swap/getIncompatibleCurrencyKeys.ts

@@ -83,6 +83,10 @@ const INCOMPATIBLE_NANO_S_CURRENCY_KEYS: Keys = {
     title: "swap.incompatibility.celo_title",
     description: "swap.incompatibility.celo_description",
   },
+  monad: {
+    title: "swap.incompatibility.monad_title",
+    description: "swap.incompatibility.monad_description",
+  },
 };
 
 export const getIncompatibleCurrencyKeys = (exchange: ExchangeSwap) => {

package/src/exchange/swap/postSwapState.ts

@@ -106,6 +106,7 @@ export const postSwapCancelled: PostSwapCancelled = async ({
   seedIdTo,
   refundAddress,
   payoutAddress,
+  data,
   ...rest
 }) => {
   if (isIntegrationTestEnv()) return mockPostSwapCancelled({ provider, swapId, ...rest });
@@ -138,7 +139,8 @@ export const postSwapCancelled: PostSwapCancelled = async ({
 
     const shouldIncludeAddresses =
       rest.statusCode === "WrongDeviceForAccountPayout" ||
-      rest.statusCode === "WrongDeviceForAccountRefund";
+      rest.statusCode === "WrongDeviceForAccountRefund" ||
+      rest.statusCode === "FeeNotLoaded";
 
     const requestData = {
       provider,
@@ -147,11 +149,14 @@ export const postSwapCancelled: PostSwapCancelled = async ({
       swapIntentWithoutProvider,
       payloadAddressMatchAccountAddress,
       fromAmount,
-      fromAccountAddress: shouldIncludeAddresses ? fromAccountAddress : undefined,
-      toAccountAddress: shouldIncludeAddresses ? toAccountAddress : undefined,
-      payloadRefundAddress: shouldIncludeAddresses ? refundAddress : undefined,
-      payloadPayoutAddress: shouldIncludeAddresses ? payoutAddress : undefined,
+      ...(shouldIncludeAddresses && {
+        fromAccountAddress,
+        toAccountAddress,
+        payloadRefundAddress: refundAddress,
+        payloadPayoutAddress: payoutAddress,
+      }),
       maybeSeedMatch: seedIdFrom === seedIdTo, // Only true if both accounts are from the same seed and from the same chain type
+      data,
       ...rest,
     };