@ledgerhq/live-common 34.53.0-nightly.20251119110540 → 34.53.0-nightly.20251120135143

package/src/__tests__/accounts/groupPerDay.ts

@@ -2,8 +2,7 @@ import flatMap from "lodash/flatMap";
 import { fromAccountRaw, groupAccountOperationsByDay } from "../../account";
 import { TezosAccountRaw } from "../../families/tezos/types";
 import { setSupportedCurrencies } from "../../currencies";
-import type { CryptoAssetsStore } from "@ledgerhq/types-live";
-import { setup } from "../../bridge/impl";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 setSupportedCurrencies(["tezos"]);
 
@@ -14,8 +13,7 @@ LiveConfig.setConfig({
   },
 });
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-setup({} as CryptoAssetsStore);
+setupMockCryptoAssetsStore();
 
 let account: Awaited<ReturnType<typeof fromAccountRaw>>;
 

package/src/__tests__/csvExport.ts

@@ -5,10 +5,10 @@ import { getCryptoCurrencyById } from "../currencies";
 import { accountsOpToCSV } from "../csvExport";
 import { initialState, loadCountervalues } from "@ledgerhq/live-countervalues/logic";
 import { getFiatCurrencyByTicker, setSupportedCurrencies } from "../currencies";
-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();
 setSupportedCurrencies(["ethereum", "ripple"]);
 setEnv("MOCK", "1");
 setEnv("MOCK_COUNTERVALUES", "1");

package/src/__tests__/currencies.ts

@@ -1,6 +1,5 @@
 import { BigNumber } from "bignumber.js";
 import {
-  listTokens,
   getCryptoCurrencyById,
   getFiatCurrencyByTicker,
   formatCurrencyUnit,
@@ -10,43 +9,6 @@ import {
   encodeURIScheme,
   sanitizeValueString,
 } from "../currencies";
-import { byContractAddressAndChainId } from "@ledgerhq/hw-app-eth/erc20";
-
-/*
-  skipped because ledgerjs data is now lighter (from the POV of hw-app-eth)
-  (using cryptoassets-evm-signatures instead of cryptoassets)
-*/
-test.skip("erc20 are all consistent with those on ledgerjs side", () => {
-  const normalList = listTokens();
-  const delistedList = listTokens({
-    withDelisted: true,
-  });
-  expect(delistedList.length).toBeGreaterThan(normalList.length);
-
-  for (const token of delistedList) {
-    if (token.delisted) {
-      expect(normalList.find(o => o.id === token.id)).toBeUndefined();
-    }
-
-    if (token.tokenType === "erc20") {
-      if (token.parentCurrency.family === "filecoin") {
-        continue;
-      }
-      const tokenData = byContractAddressAndChainId(
-        token.contractAddress,
-        token.parentCurrency.ethereumLikeInfo?.chainId || 0,
-      );
-
-      if (!tokenData) {
-        throw new Error(token.name + " not available in ledgerjs data");
-      }
-
-      expect(token.ticker.toLowerCase()).toBe(tokenData.ticker.toLowerCase());
-      expect(token.contractAddress.toLowerCase()).toBe(tokenData.contractAddress.toLowerCase());
-      expect(token.units[0].magnitude).toBe(tokenData.decimals);
-    }
-  }
-});
 
 test("can format a currency unit", () => {
   const btc = getCryptoCurrencyById("bitcoin").units[0];

package/src/__tests__/test-helpers/setup.integration.ts

@@ -0,0 +1,17 @@
+import { setupCalClientStore } from "../../test-helpers/cryptoAssetsStore";
+import "./environment";
+import BigNumber from "bignumber.js";
+
+// Integration tests use the real CAL API
+setupCalClientStore();
+
+jest.setTimeout(360000);
+
+expect.extend({
+  toBeBigNumber(value) {
+    const pass = BigNumber.isBigNumber(value);
+    const message = pass ? () => `${value} is a BigNumber` : () => `${value} is not a BigNumber`;
+
+    return { message, pass };
+  },
+});

package/src/__tests__/test-helpers/setup.ts

@@ -1,11 +1,9 @@
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } 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 { setupMockCryptoAssetsStore } from "../../test-helpers/cryptoAssetsStore";
 import "./environment";
 import BigNumber from "bignumber.js";
 
-initializeLegacyTokens(addTokens);
+// Unit tests use mock store
+setupMockCryptoAssetsStore();
 
 jest.setTimeout(360000);
 
@@ -17,6 +15,3 @@ expect.extend({
     return { message, pass };
   },
 });
-
-// Use legacyCryptoAssetsStore for integration tests so tokens can be found
-setCryptoAssetsStoreForCoinFramework(legacyCryptoAssetsStore);

package/src/account/helpers.test.ts

@@ -1,8 +1,8 @@
 import { loadBlacklistedTokenSections } from "./helpers";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
-jest.mock("../bridge/crypto-assets/index");
+jest.mock("@ledgerhq/cryptoassets/state");
 
 const mockGetCryptoAssetsStore = getCryptoAssetsStore as jest.MockedFunction<
   typeof getCryptoAssetsStore

package/src/account/helpers.ts

@@ -15,7 +15,7 @@ import { isAccountEmpty as isVechainAccountEmpty } from "@ledgerhq/coin-vechain/
 import type { Account, AccountLike } from "@ledgerhq/types-live";
 import { isAccountDelegating } from "../families/tezos/staking";
 import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { getCryptoAssetsStore } from "../bridge/crypto-assets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 
 // TODO: remove this export and prefer import from root file.
 export {

package/src/account/serialization.test.ts

@@ -3,7 +3,7 @@ import { genAccount, genTokenAccount } from "@ledgerhq/coin-framework/mocks/acco
 import { toAccountRaw, fromAccountRaw } from "./serialization";
 import { setWalletAPIVersion } from "../wallet-api/version";
 import { WALLET_API_VERSION } from "../wallet-api/constants";
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { setCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
 import solanaSplTokenData from "../__fixtures__/solana-spl-epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v.json";
 import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
@@ -17,7 +17,7 @@ const Solana = getCryptoCurrencyById("solana");
 const USDC = solanaSplTokenData as TokenCurrency;
 
 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-setCryptoAssetsStoreForCoinFramework({
+setCryptoAssetsStore({
   findTokenById: async (id: string) => {
     if (id === "solana/spl/epjfwdd5aufqssqem2qn1xzybapc8g4weggkzwytdt1v") {
       return USDC;

package/src/bridge/crypto-assets/index.test.ts

@@ -1,54 +1,19 @@
-import { LiveConfig } from "@ledgerhq/live-config/LiveConfig";
-import { getCryptoAssetsStore, setCryptoAssetsStore } from ".";
-import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/legacy/legacy-store";
+import { getCryptoAssetsStore, setCryptoAssetsStore } from "@ledgerhq/cryptoassets/state";
 import type { CryptoAssetsStore } from "@ledgerhq/types-live";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
 describe("Testing CryptoAssetStore", () => {
-  it("should return the default methods from cryptoassets libs when feature flag does not exists", () => {
-    LiveConfig.setConfig({
-      some_other_feature: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    const store = getCryptoAssetsStore();
-    expect(store).toBe(legacyCryptoAssetsStore);
-  });
-
-  it("should return the default methods from cryptoassets libs when feature flag is disabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: false,
-      },
-    });
-
-    const store = getCryptoAssetsStore();
-    expect(store).toBe(legacyCryptoAssetsStore);
+  beforeEach(() => {
+    // Reset the store before each test
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    setCryptoAssetsStore(undefined as unknown as CryptoAssetsStore);
   });
 
-  it("should throw an error when no store is set and feature flag is enabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
-    expect(() => getCryptoAssetsStore()).toThrow(
-      "CryptoAssetsStore is not set. Please call setCryptoAssetsStore first.",
-    );
+  it("should throw an error when no store is set", () => {
+    expect(() => getCryptoAssetsStore()).toThrow("CryptoAssetsStore is not set");
   });
 
-  it("should throw return the new store when feature flag is enabled", () => {
-    LiveConfig.setConfig({
-      feature_cal_lazy_loading: {
-        type: "boolean",
-        default: true,
-      },
-    });
-
+  it("should return the store when it is set", () => {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const newStore = {} as unknown as CryptoAssetsStore;
     setCryptoAssetsStore(newStore);
@@ -56,4 +21,10 @@ describe("Testing CryptoAssetStore", () => {
     const store = getCryptoAssetsStore();
     expect(store).toBe(newStore);
   });
+
+  it("should work with mock store", () => {
+    const mockStore = setupMockCryptoAssetsStore();
+    const store = getCryptoAssetsStore();
+    expect(store).toBe(mockStore);
+  });
 });

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

@@ -0,0 +1,13 @@
+import "../__tests__/test-helpers/setup";
+import { isCryptoCurrency } from "./helpers";
+import { listCryptoCurrencies } from ".";
+
+describe("Currencies helpers", () => {
+  test("listCryptoCurrencies returns only crypto currencies", () => {
+    const currencies = listCryptoCurrencies();
+
+    currencies.forEach(currency => {
+      expect(isCryptoCurrency(currency)).toBeTruthy();
+    });
+  });
+});

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/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/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/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();
+      }
+    },
+);

package/src/e2e/families/aptos.ts

@@ -2,24 +2,36 @@ import expect from "expect";
 import { Transaction } from "../models/Transaction";
 import { waitFor, pressUntilTextFound, containsSubstringInEvent, getSendEvents } from "../speculos";
 import { isTouchDevice } from "../speculosAppVersion";
-import { pressBoth } from "../deviceInteraction/ButtonDeviceSimulator";
 import { DeviceLabels } from "../enum/DeviceLabels";
 import { Delegate } from "../models/Delegate";
 import { longPressAndRelease } from "../deviceInteraction/TouchDeviceSimulator";
+import { withDeviceController } from "../deviceInteraction/DeviceController";
 
-export async function sendAptos(tx: Transaction) {
-  await getSendEvents(tx);
-  if (isTouchDevice()) {
-    await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
-  } else {
-    await pressBoth();
-  }
-}
+export const sendAptos = withDeviceController(
+  ({ getButtonsController }) =>
+    async (tx: Transaction) => {
+      const buttons = getButtonsController();
 
-export async function delegateAptos(delegatingAccount: Delegate) {
-  await waitFor(DeviceLabels.REVIEW_OPERATION);
-  const events = await pressUntilTextFound(DeviceLabels.APPROVE);
-  const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
-  expect(isAmountCorrect).toBeTruthy();
-  await pressBoth();
-}
+      await getSendEvents(tx);
+
+      if (isTouchDevice()) {
+        await longPressAndRelease(DeviceLabels.HOLD_TO_SIGN, 3);
+      } else {
+        await buttons.both();
+      }
+    },
+);
+
+export const delegateAptos = withDeviceController(
+  ({ getButtonsController }) =>
+    async (delegatingAccount: Delegate) => {
+      const buttons = getButtonsController();
+
+      await waitFor(DeviceLabels.REVIEW_OPERATION);
+      const events = await pressUntilTextFound(DeviceLabels.APPROVE);
+      const isAmountCorrect = containsSubstringInEvent(delegatingAccount.amount, events);
+      expect(isAmountCorrect).toBeTruthy();
+
+      await buttons.both();
+    },
+);