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

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

@@ -107,7 +107,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     extra.memo = op.details.memo as string;
   }
   const bnFees = new BigNumber(op.tx.fees.toString());
-  const hasFailed = op.details?.status === "failed";
+  const hasFailed = op.tx.failed;
 
   let value: BigNumber;
   if (hasFailed) {

package/src/bridge/impl.ts

@@ -20,9 +20,7 @@ import {
 import { getAlpacaAccountBridge } from "./generic-alpaca/accountBridge";
 import { getAlpacaCurrencyBridge } from "./generic-alpaca/currencyBridge";
 import { AddressesSanctionedError } from "@ledgerhq/coin-framework/sanction/errors";
-import type { CryptoAssetsStore } from "@ledgerhq/types-live";
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { getCryptoAssetsStore, setCryptoAssetsStore } from "./crypto-assets";
+// Removed: stores are now managed globally by @ledgerhq/cryptoassets/cal-client/store
 
 const alpacaized = {
   xrp: true,
@@ -105,10 +103,8 @@ export function getAccountBridgeByFamily(family: string, accountId?: string): Ac
   return wrapAccountBridge(jsBridge.accountBridge);
 }
 
-export function setup(store: CryptoAssetsStore) {
-  setCryptoAssetsStore(store);
-  setCryptoAssetsStoreForCoinFramework(getCryptoAssetsStore());
-}
+// Removed: setup() is no longer needed. The store is now managed globally by @ledgerhq/cryptoassets/cal-client/store.
+// Use setupCalClientStore() or setupMockCryptoAssetsStore() from @ledgerhq/cryptoassets/cal-client/test-helpers instead.
 
 function wrapAccountBridge<T extends TransactionCommon>(
   bridge: AccountBridge<T>,

package/src/currencies/cryptoIcons.test.ts

@@ -1,11 +1,30 @@
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens as addTokensLegacy } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "../test-helpers/cryptoAssetsStore";
 import { inferCryptoCurrencyIcon } from "./cryptoIcons";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 beforeAll(() => {
-  initializeLegacyTokens(addTokensLegacy);
+  // Setup mock store for unit tests
+  setupMockCryptoAssetsStore({
+    findTokenById: async (id: string) => {
+      // Return a mock token for the test
+      if (id === "ethereum/erc20/usd_tether__erc20_") {
+        return {
+          type: "TokenCurrency",
+          id: "ethereum/erc20/usd_tether__erc20_",
+          contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+          parentCurrency: getCryptoCurrencyById("ethereum"),
+          tokenType: "erc20",
+          name: "Tether USD",
+          ticker: "USDT",
+          delisted: false,
+          disableCountervalue: false,
+          units: [{ name: "USDT", code: "USDT", magnitude: 6 }],
+        } as any;
+      }
+      return undefined;
+    },
+  });
 });
 
 describe("inferCryptoCurrencyIcon", () => {

package/src/currencies/helpers.test.ts

@@ -1,20 +1,13 @@
 import "../__tests__/test-helpers/setup";
-import { isCryptoCurrency, isTokenCurrency, listCurrencies } from "./helpers";
+import { isCryptoCurrency } from "./helpers";
+import { listCryptoCurrencies } from ".";
 
 describe("Currencies helpers", () => {
-  test("listCurrencies without includeTokens", () => {
-    const currencies = listCurrencies(false);
+  test("listCryptoCurrencies returns only crypto currencies", () => {
+    const currencies = listCryptoCurrencies();
 
     currencies.forEach(currency => {
       expect(isCryptoCurrency(currency)).toBeTruthy();
     });
   });
-
-  test("listCurrencies with includeTokens", () => {
-    const currencies = listCurrencies(true);
-
-    currencies.forEach(currency => {
-      expect(isCryptoCurrency(currency) || isTokenCurrency(currency)).toBeTruthy();
-    });
-  });
 });

package/src/currencies/helpers.ts

@@ -1,12 +1,4 @@
-import {
-  Currency,
-  CryptoCurrency,
-  CryptoOrTokenCurrency,
-  TokenCurrency,
-} from "@ledgerhq/types-cryptoassets";
-import { makeRe } from "minimatch";
-import { listTokens } from "@ledgerhq/cryptoassets";
-import { listSupportedCurrencies } from "@ledgerhq/coin-framework/currencies/index";
+import { Currency, CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 export function isCryptoCurrency(currency: Currency): currency is CryptoCurrency {
   return currency.type === "CryptoCurrency";
@@ -20,39 +12,6 @@ export function isUTXOCompliant(currencyFamily: string): boolean {
   return currencyFamily === "bitcoin" || currencyFamily === "cardano";
 }
 
-export function listCurrencies(includeTokens: boolean): CryptoOrTokenCurrency[] {
-  const currencies = listSupportedCurrencies();
-
-  if (!includeTokens) {
-    return currencies;
-  }
-
-  const allTokens = listTokens();
-
-  return [...currencies, ...allTokens];
-}
-
 export type CurrencyFilters = {
   currencies?: string[];
 };
-
-export function filterCurrencies(
-  currencies: CryptoOrTokenCurrency[],
-  filters: CurrencyFilters,
-): CryptoOrTokenCurrency[] {
-  const filterCurrencyRegexes = filters.currencies
-    ? filters.currencies.map(filter => makeRe(filter))
-    : null;
-
-  return currencies.filter(currency => {
-    if (
-      filterCurrencyRegexes &&
-      filterCurrencyRegexes.length &&
-      !filterCurrencyRegexes.some(regex => currency.id.match(regex))
-    ) {
-      return false;
-    }
-
-    return true;
-  });
-}

package/src/currencies/index.ts

@@ -11,9 +11,6 @@ export {
   findCryptoCurrencyByScheme,
   findCryptoCurrencyByKeyword,
   findCryptoCurrencyByTicker,
-  listTokens,
-  listTokensForCryptoCurrency,
-  listTokenTypesForCryptoCurrency,
   getAbandonSeedAddress,
 } from "@ledgerhq/cryptoassets";
 export {

package/src/currencies/sortByMarketcap.test.ts

@@ -1,31 +1,5 @@
 import { sortCurrenciesByIds } from "./sortByMarketcap";
-import { listCryptoCurrencies, listTokens } from ".";
-import { getBTCValues } from "@ledgerhq/live-countervalues/mock";
 import { CURRENCIES_LIST, IDS } from "./mock";
-import { findCryptoCurrencyByTicker, findFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/index";
-import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
-import { setup } from "../bridge/impl";
-
-initializeLegacyTokens(addTokens);
-setup(legacyCryptoAssetsStore);
-
-test("sortCurrenciesByIds snapshot", async () => {
-  const list = [...listCryptoCurrencies(), ...listTokens()];
-  const ids: string[] = [];
-  for (const k in getBTCValues()) {
-    const c =
-      findCryptoCurrencyByTicker(k) ||
-      findFiatCurrencyByTicker(k) ||
-      (await getCryptoAssetsStore().findTokenById(k));
-    if (c && (c.type == "CryptoCurrency" || c.type == "TokenCurrency")) {
-      ids.push(c.id);
-    }
-  }
-  expect(sortCurrenciesByIds(list, ids).map(c => c.id)[0]).toEqual("bitcoin");
-});
 
 test("sortCurrenciesByIds simulate staking from portfolio", () => {
   expect(sortCurrenciesByIds(CURRENCIES_LIST, IDS).map(c => c.id)).toEqual([

package/src/dada-client/hooks/useAssetsData.ts

@@ -80,6 +80,7 @@ export function useAssetsData({
   return {
     data: joinedPages,
     isLoading: isInitialLoading,
+    isFetchingNextPage,
     error,
     loadNext: hasMore ? fetchNextPage : undefined,
     isSuccess,

package/src/deposit/type.ts

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

package/src/device/use-cases/getDeviceHasBattery.ts

@@ -0,0 +1 @@
+export { getDeviceHasBattery } from "@ledgerhq/device-core";

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

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

package/src/deviceSDK/hooks/useBatteryStatuses.ts

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

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

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

package/src/deviceSDK/tasks/core.ts

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

package/src/deviceSDK/tasks/getDeviceInfo.ts

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

package/src/deviceSDK/tasks/getLatestFirmware.ts

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

package/src/deviceSDK/tasks/updateFirmware.ts

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

package/src/domain/getTokensWithFunds.test.ts

@@ -1,18 +1,47 @@
 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 { getTokensWithFunds } from "./getTokensWithFunds";
-import { initializeLegacyTokens } from "@ledgerhq/cryptoassets/legacy/legacy-data";
-import { addTokens } from "@ledgerhq/cryptoassets/legacy/legacy-utils";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
-initializeLegacyTokens(addTokens);
+// Setup mock store for unit tests
+setupMockCryptoAssetsStore();
 
 const ETH = getCryptoCurrencyById("ethereum");
 
+// 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-2", {
     currency: ETH,
+    tokensData: [ZRX_TOKEN, REP_TOKEN],
   }),
 ];
 

package/src/e2e/data/assetsDrawer.ts

@@ -0,0 +1,8 @@
+export const assetAvailableNetworks = {
+  ETH: {
+    networks: ["Ethereum", "Base", "OP Mainnet", "Linea", "Scroll", "ZKsync"],
+  },
+  USDT: {
+    networks: ["Ethereum", "Solana", "BNB Chain", "TON", "Tron", "Base"],
+  },
+};

package/src/e2e/deviceInteraction/DeviceController.ts

@@ -0,0 +1,85 @@
+import { getEnv } from "@ledgerhq/live-env";
+import { getSpeculosAddress } from "../speculos";
+import {
+  deviceControllerClientFactory,
+  type DeviceControllerClient,
+  type ButtonKey,
+} from "@ledgerhq/speculos-device-controller";
+
+// temp type until DeviceControllerClient exposes buttonFactory type
+type ButtonsController = {
+  left(): Promise<void>;
+  right(): Promise<void>;
+  both(): Promise<void>;
+  pressSequence(keys: ButtonKey[], delayMs?: number): Promise<void>;
+};
+
+type DeviceControllerContext = {
+  getDeviceController: () => DeviceControllerClient;
+  getButtonsController: () => ButtonsController;
+};
+
+const endpointKey = () => `${getSpeculosAddress()}:${getEnv("SPECULOS_API_PORT")}`;
+
+export const getDeviceControllerWithMemo = (() => {
+  let cache: { key: string; client: DeviceControllerClient } | null = null;
+  return () => {
+    const key = endpointKey();
+    if (!cache || cache.key !== key) {
+      cache = {
+        key,
+        client: deviceControllerClientFactory(key, {
+          timeoutMs: 10000,
+        }),
+      };
+    }
+    return cache.client;
+  };
+})();
+
+export const getButtonsWithMemo = (getController: () => DeviceControllerClient) => {
+  let cache: { ctrl: DeviceControllerClient; buttons: ButtonsController } | null = null;
+  return () => {
+    const ctrl = getController();
+    if (!cache || cache.ctrl !== ctrl) {
+      cache = { ctrl, buttons: ctrl.buttonFactory() };
+    }
+    return cache.buttons;
+  };
+};
+
+/**
+ * Wraps a function with access to speculos-device-controller via a tiny DI context.
+ *
+ * @description
+ * Pass a factory that receives a context exposing `getDeviceController()` and `getButtonsController()`.
+ * The factory returns the actual implementation. The returned wrapper preserves the implementation’s
+ * parameter and return types.
+ *
+ * Both accessors are lazy, they get or refresh the underlying controller only when called.
+ *
+ * @param factory - Function invoked immediately with the device context, must return the implementation.
+ * @returns A function with the same parameters and return type as the implementation returned by `factory`.
+ *
+ * @example
+ * ```ts
+ * const accept = withDeviceController(({ getButtonsController }) => async (timeoutMS: number) => {
+ *   const buttons = getButtonsController();
+ *   await waitFor(timeoutMS);
+ *   await buttons.both();
+ * });
+ *
+ * await accept(1000);
+ * ```
+ *
+ */
+export function withDeviceController<A extends unknown[], R>(
+  factory: (ctx: DeviceControllerContext) => (...args: A) => R | Promise<R>,
+): (...args: A) => R | Promise<R> {
+  const ctx: DeviceControllerContext = {
+    getDeviceController: getDeviceControllerWithMemo,
+    getButtonsController: getButtonsWithMemo(getDeviceControllerWithMemo),
+  };
+  const implementation = factory(ctx);
+  return (...args: A) => implementation(...args);
+}

package/src/e2e/enum/Account.ts

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

package/src/e2e/enum/Currency.ts

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

package/src/e2e/enum/ReceiveFundsOptions.ts

@@ -0,0 +1,7 @@
+export const ReceiveFundsOptions = {
+  CRYPTO: "crypto",
+  FIAT: "fiat",
+} as const;
+
+export type ReceiveFundsOptionsType =
+  (typeof ReceiveFundsOptions)[keyof typeof ReceiveFundsOptions];

package/src/e2e/families/algorand.ts

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