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

package/src/bridge/generic-alpaca/tests/prepareTransaction.test.ts

@@ -1,254 +1,172 @@
 import { genericPrepareTransaction } from "../prepareTransaction";
 import { getAlpacaApi } from "../alpaca";
+import { transactionToIntent } from "../utils";
 import BigNumber from "bignumber.js";
-import * as accountModule from "@ledgerhq/coin-framework/account/index";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import { Account } from "@ledgerhq/types-live";
 
 jest.mock("../alpaca", () => ({
   getAlpacaApi: jest.fn(),
 }));
 
+jest.mock("../utils", () => ({
+  transactionToIntent: jest.fn(),
+}));
+
 describe("genericPrepareTransaction", () => {
   const network = "testnet";
   const kind = "local";
 
+  const account = {
+    id: "test-account",
+    address: "0xabc",
+    currency: { id: "ethereum" },
+  } as any;
+
+  const baseTransaction = {
+    amount: new BigNumber(100_000),
+    fees: new BigNumber(500),
+    recipient: "0xrecipient",
+    family: "family",
+  };
+
+  const txIntent = { mock: "intent" };
+
   beforeEach(() => {
     jest.clearAllMocks();
+    (transactionToIntent as jest.Mock).mockReturnValue(txIntent);
   });
 
-  it("embeds assets info, if existing", async () => {
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 500n }),
-      getAssetFromToken: jest.fn().mockImplementation((token, owner) => {
-        return {
-          assetOwner: owner,
-          assetReference: token.contractAddress,
-        };
-      }),
-    });
-    jest.spyOn(accountModule, "decodeTokenAccountId").mockImplementation(accountId => {
-      const token =
-        accountId === "ethereum_usdc_sub_account"
-          ? ({ contractAddress: "usdc_contract" } as TokenCurrency)
-          : undefined;
+  it("updates fees if they differ", async () => {
+    const newFee = new BigNumber(700);
 
-      return { accountId, token };
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const resultUsdcToken = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] }, freshAddress: "0xabc" } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        subAccountId: "ethereum_usdc_sub_account",
-      },
-    );
+    const result = await prepareTransaction(account, { ...baseTransaction });
 
-    expect(resultUsdcToken).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(500),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "usdc_contract",
-      assetOwner: "0xabc",
-      subAccountId: "ethereum_usdc_sub_account",
-    });
-
-    const resultUnknownToken = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        subAccountId: "ethereum_unknown_sub_account",
-      },
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(transactionToIntent).toHaveBeenCalledWith(
+      account,
+      expect.objectContaining(baseTransaction),
+      undefined,
     );
-
-    expect(resultUnknownToken).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(500),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-      subAccountId: "ethereum_unknown_sub_account",
-    });
   });
 
-  it.each([
-    ["all native amount", { useAllAmount: true }, new BigNumber(42)],
-    ["all native amount on staking scenarios", { mode: "stake" }, new BigNumber(42)],
-    ["all native amount on unstaking scenarios", { mode: "unstake" }, new BigNumber(42)],
-    [
-      "all token amount",
-      { subAccountId: "ethereum_usdc_sub_account", useAllAmount: true },
-      new BigNumber(5),
-    ],
-    [
-      "all token amount on staking scenarios",
-      { subAccountId: "ethereum_usdc_sub_account", mode: "stake" },
-      new BigNumber(5),
-    ],
-    [
-      "all token amount on unstaking scenarios",
-      { subAccountId: "ethereum_usdc_sub_account", mode: "unstake" },
-      new BigNumber(5),
-    ],
-  ] as const)("uses %s, updating the amount", async (_s, partialTransaction, expectedAmount) => {
-    (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 8n }),
-      getAssetFromToken: jest.fn().mockImplementation((token, owner) => {
-        return {
-          assetOwner: owner,
-          assetReference: token.contractAddress,
-        };
-      }),
-    });
-    jest.spyOn(accountModule, "decodeTokenAccountId").mockImplementation(accountId => {
-      const token =
-        accountId === "ethereum_usdc_sub_account"
-          ? ({ contractAddress: "usdc_contract" } as TokenCurrency)
-          : undefined;
+  it("returns original transaction if fees are the same", async () => {
+    const sameFee = baseTransaction.fees;
 
-      return { accountId, token };
+    (getAlpacaApi as jest.Mock).mockReturnValue({
+      estimateFees: jest.fn().mockResolvedValue({ value: sameFee }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      {
-        currency: { id: "ethereum", units: [{}] },
-        spendableBalance: new BigNumber(50),
-        subAccounts: [{ id: "ethereum_usdc_sub_account", spendableBalance: new BigNumber(5) }],
-      } as Account,
-      {
-        amount: new BigNumber(0),
-        recipient: "0xrecipient",
-        family: "family",
-        ...partialTransaction,
-      },
-    );
+    const result = await prepareTransaction(account, baseTransaction);
 
-    expect(result).toMatchObject({
-      amount: expectedAmount,
-      fees: new BigNumber(8),
-      recipient: "0xrecipient",
-      family: "family",
-    });
+    expect(result).toBe(baseTransaction);
   });
 
-  it("updates fees from the estimation", async () => {
+  it("sets fee if original fees are undefined", async () => {
+    const newFee = new BigNumber(1234);
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 700n }),
+      estimateFees: jest.fn().mockResolvedValue({ value: newFee }),
     });
 
+    const txWithoutFees = { ...baseTransaction, fees: undefined as any };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-      },
-    );
+    const result = await prepareTransaction(account, txWithoutFees);
 
-    expect(result).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(700),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-    });
+    expect((result as any).fees.toString()).toBe(newFee.toString());
+    expect(result).not.toBe(txWithoutFees);
   });
 
-  it("updates fees from the existing custom", async () => {
+  it("returns original if fees are BigNumber-equal but different instance", async () => {
+    const sameValue = new BigNumber(baseTransaction.fees.toString()); // different instance
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 700n }),
+      estimateFees: jest.fn().mockResolvedValue({ value: sameValue }),
     });
 
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        customFees: { parameters: { fees: new BigNumber(600) } },
-      },
-    );
+    const result = await prepareTransaction(account, baseTransaction);
 
-    expect(result).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(600),
-      customFees: { parameters: { fees: new BigNumber(600) } },
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-    });
+    expect(result).toBe(baseTransaction); // still same reference
   });
 
-  it("propagates estimated 'storageLimit'", async () => {
+  it("propagates storageLimit from second estimation", async () => {
+    const estimatedFee = new BigNumber(491);
+
+    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 300 },
+    });
+
+    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 0 },
+    });
+
     (getAlpacaApi as jest.Mock).mockReturnValue({
       estimateFees: jest
         .fn()
-        .mockResolvedValue({ value: 700n, parameters: { storageLimit: 277n } }),
+        .mockImplementationOnce(() => estimateFeesFirstCall())
+        .mockImplementationOnce(() => estimateFeesSecondCall()),
     });
 
+    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(100_000),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-      },
+    const result = await prepareTransaction(account, txWithoutCustomFees);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        fees: estimatedFee,
+        storageLimit: new BigNumber(0),
+        customFees: {
+          parameters: {
+            fees: undefined,
+          },
+        },
+      }),
     );
 
-    expect(result).toEqual({
-      amount: new BigNumber(100_000),
-      fees: new BigNumber(700),
-      storageLimit: new BigNumber(277),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-    });
+    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
   });
 
-  it("keeps the amount used during the estimation when using all native amount", async () => {
+  it("propagates storageLimit showing new account scenario", async () => {
+    const estimatedFee = new BigNumber(491);
+
+    const estimateFeesFirstCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 300 },
+    });
+
+    const estimateFeesSecondCall = jest.fn().mockResolvedValue({
+      value: estimatedFee,
+      parameters: { storageLimit: 277 },
+    });
+
     (getAlpacaApi as jest.Mock).mockReturnValue({
-      estimateFees: jest.fn().mockResolvedValue({ value: 700n, parameters: { amount: 1000n } }),
+      estimateFees: jest
+        .fn()
+        .mockImplementationOnce(() => estimateFeesFirstCall())
+        .mockImplementationOnce(() => estimateFeesSecondCall()),
     });
 
+    const txWithoutCustomFees = { ...baseTransaction, customFees: undefined };
     const prepareTransaction = genericPrepareTransaction(network, kind);
-    const result = await prepareTransaction(
-      { currency: { id: "ethereum", units: [{}] } } as Account,
-      {
-        amount: new BigNumber(0),
-        fees: new BigNumber(500),
-        recipient: "0xrecipient",
-        family: "family",
-        useAllAmount: true,
-      },
+    const result = await prepareTransaction(account, txWithoutCustomFees);
+
+    expect(result).toEqual(
+      expect.objectContaining({
+        fees: estimatedFee,
+        storageLimit: new BigNumber(277),
+        customFees: {
+          parameters: {
+            fees: undefined,
+          },
+        },
+      }),
     );
 
-    expect(result).toEqual({
-      amount: new BigNumber(1000),
-      fees: new BigNumber(700),
-      recipient: "0xrecipient",
-      family: "family",
-      assetReference: "",
-      assetOwner: "",
-      useAllAmount: true,
-    });
+    expect((getAlpacaApi as jest.Mock)().estimateFees).toHaveBeenCalledTimes(2);
   });
 });

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

@@ -197,18 +197,21 @@ describe("Alpaca utils", () => {
       });
     });
 
-    it("handles FEES operation where value = value + fees", () => {
-      const op = {
-        ...baseOp,
-        type: "FEES",
-        value: BigInt(5),
-        tx: { ...baseOp.tx, fees: BigInt(2) },
-      };
-
-      const result = adaptCoreOperationToLiveOperation(accountId, op);
-
-      expect(result.value.toString()).toEqual("7");
-    });
+    it.each([["FEES"], ["DELEGATE"], ["UNDELEGATE"]])(
+      "handles %s operation where value = value + fees",
+      operationType => {
+        const op = {
+          ...baseOp,
+          type: operationType,
+          value: BigInt(5),
+          tx: { ...baseOp.tx, fees: BigInt(2) },
+        };
+
+        const result = adaptCoreOperationToLiveOperation(accountId, op);
+
+        expect(result.value.toString()).toEqual("7");
+      },
+    );
 
     it("handles non-FEES/OUT operation where value = value only", () => {
       const op = {

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

@@ -61,7 +61,7 @@ export function adaptCoreOperationToLiveOperation(accountId: string, op: CoreOpe
     accountId,
     type: opType,
     value:
-      op.asset.type === "native" && ["OUT", "FEES"].includes(opType)
+      op.asset.type === "native" && ["OUT", "FEES", "DELEGATE", "UNDELEGATE"].includes(opType)
         ? new BigNumber(op.value.toString()).plus(bnFees)
         : new BigNumber(op.value.toString()),
     fee: bnFees,

package/src/config/index.ts

@@ -1,10 +1,8 @@
-import { CryptoCurrency, CryptoCurrencyId } from "@ledgerhq/types-cryptoassets";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import { ConfigInfo, LiveConfig } from "@ledgerhq/live-config/LiveConfig";
 import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
 
-export type CurrencyLiveConfigDefinition = Partial<
-  Record<`config_currency_${CryptoCurrencyId}`, ConfigInfo>
->;
+export type CurrencyLiveConfigDefinition = Record<`config_currency_${string}`, ConfigInfo>;
 
 const getCurrencyConfiguration = <T extends CurrencyConfig>(
   currency: CryptoCurrency,

package/src/currencies/sortByMarketcap.test.ts

@@ -2,18 +2,21 @@ import { sortCurrenciesByIds } from "./sortByMarketcap";
 import { listCryptoCurrencies, listTokens } from ".";
 import { getBTCValues } from "@ledgerhq/live-countervalues/mock";
 import { CURRENCIES_LIST, IDS } from "./mock";
-import { setCryptoAssetsStore as setCryptoAssetsStoreForCoinFramework } from "@ledgerhq/coin-framework/crypto-assets/index";
-import type { CryptoAssetsStore } from "@ledgerhq/types-live";
-import { findCurrencyByTicker } from "@ledgerhq/live-countervalues/findCurrencyByTicker";
+import { findCryptoCurrencyByTicker, findFiatCurrencyByTicker } from "@ledgerhq/cryptoassets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
+import { legacyCryptoAssetsStore } from "@ledgerhq/cryptoassets/tokens";
+import { setup } from "../bridge/impl";
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-setCryptoAssetsStoreForCoinFramework({} as CryptoAssetsStore);
+setup(legacyCryptoAssetsStore);
 
-test("sortCurrenciesByIds snapshot", () => {
+test("sortCurrenciesByIds snapshot", async () => {
   const list = [...listCryptoCurrencies(), ...listTokens()];
   const ids: string[] = [];
   for (const k in getBTCValues()) {
-    const c = findCurrencyByTicker(k);
+    const c =
+      findCryptoCurrencyByTicker(k) ||
+      findFiatCurrencyByTicker(k) ||
+      (await getCryptoAssetsStore().findTokenById(k));
     if (c && (c.type == "CryptoCurrency" || c.type == "TokenCurrency")) {
       ids.push(c.id);
     }

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

@@ -0,0 +1,65 @@
+import { useCallback } from "react";
+import useFeature from "../../featureFlags/useFeature";
+
+interface DrawerConfiguration {
+  assets?: Record<string, unknown>;
+  networks?: Record<string, unknown>;
+}
+
+interface UseCaseConfig {
+  assets?: Record<string, unknown>;
+  networks?: Record<string, unknown>;
+}
+
+type UseCaseConfigs = Record<string, UseCaseConfig>;
+
+/**
+ * Hook that provides drawer configuration functionality with feature flag integration.
+ *
+ * @returns An object containing the createDrawerConfiguration function
+ */
+export function useDrawerConfiguration() {
+  const earnDrawerConfigurationFlag = useFeature("ptxEarnDrawerConfiguration");
+
+  const createDrawerConfiguration = useCallback(
+    (
+      drawerConfiguration: unknown,
+      useCase: string | undefined,
+      customUseCaseConfigs?: UseCaseConfigs,
+    ): DrawerConfiguration => {
+      const config: DrawerConfiguration | undefined = drawerConfiguration!;
+
+      // Default use case configs with earn configuration from feature flag
+      const earnAppDrawerConfig: UseCaseConfig =
+        earnDrawerConfigurationFlag?.enabled && earnDrawerConfigurationFlag.params
+          ? earnDrawerConfigurationFlag.params
+          : {};
+
+      const defaultUseCaseConfigs: UseCaseConfigs = {
+        earn: earnAppDrawerConfig,
+      };
+
+      // Merge with any custom use case configs provided
+      const useCaseConfigs = {
+        ...defaultUseCaseConfigs,
+        ...customUseCaseConfigs,
+      };
+
+      const useCaseConfig = useCase ? useCaseConfigs[useCase] : undefined;
+
+      return {
+        assets: {
+          ...useCaseConfig?.assets,
+          ...config?.assets,
+        },
+        networks: {
+          ...useCaseConfig?.networks,
+          ...config?.networks,
+        },
+      };
+    },
+    [earnDrawerConfigurationFlag],
+  );
+
+  return { createDrawerConfiguration };
+}

package/src/e2e/data/deviceLabelsData.ts

@@ -19,6 +19,14 @@ type LabelConfig = {
     [key: string]: string;
     default: string;
   };
+  sendVerify: {
+    [key: string]: string;
+    default: string;
+  };
+  sendConfirm: {
+    [key: string]: string;
+    default: string;
+  };
 };
 
 type DeviceLabelsConfig = {
@@ -57,6 +65,47 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.TEZOS.name]: DeviceLabels.ACCEPT_RISK,
       default: DeviceLabels.CAPS_APPROVE,
     },
+    sendVerify: {
+      default: DeviceLabels.REVIEW_OPERATION,
+    },
+    sendConfirm: {
+      [AppInfos.SOLANA.name]: DeviceLabels.SIGN_TRANSACTION,
+      [AppInfos.TRON.name]: DeviceLabels.SIGN,
+      [AppInfos.STELLAR.name]: DeviceLabels.SIGN,
+      [AppInfos.RIPPLE.name]: DeviceLabels.SIGN,
+      [AppInfos.APTOS.name]: DeviceLabels.APPROVE,
+      [AppInfos.SUI.name]: DeviceLabels.ACCEPT,
+      [AppInfos.BITCOIN.name]: DeviceLabels.CONTINUE,
+      default: DeviceLabels.CAPS_APPROVE,
+    },
+  },
+  [DeviceModelId.stax]: {
+    receiveVerify: {
+      [AppInfos.BNB_CHAIN.name]: DeviceLabels.VERIFY_BSC,
+      [AppInfos.COSMOS.name]: DeviceLabels.PLEASE_REVIEW,
+      [AppInfos.ETHEREUM.name]: DeviceLabels.VERIFY_ETHEREUM,
+      [AppInfos.POLKADOT.name]: DeviceLabels.PLEASE_REVIEW,
+      [AppInfos.POLYGON.name]: DeviceLabels.VERIFY_POLYGON,
+      [AppInfos.SOLANA.name]: DeviceLabels.VERIFY_SOLANA_ADDRESS,
+      default: DeviceLabels.ADDRESS,
+    },
+    receiveConfirm: {
+      default: DeviceLabels.CONFIRM,
+    },
+    delegateVerify: {
+      [AppInfos.NEAR.name]: DeviceLabels.VIEW_HEADER,
+      default: DeviceLabels.REVIEW_OPERATION,
+    },
+    delegateConfirm: {
+      [AppInfos.NEAR.name]: DeviceLabels.CONTINUE_TO_ACTION,
+      default: DeviceLabels.HOLD_TO_SIGN,
+    },
+    sendVerify: {
+      default: DeviceLabels.REVIEW_OPERATION,
+    },
+    sendConfirm: {
+      default: DeviceLabels.HOLD_TO_SIGN,
+    },
   },
   default: {
     receiveVerify: {
@@ -65,7 +114,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.ETHEREUM.name]: DeviceLabels.VERIFY_ETHEREUM,
       [AppInfos.POLKADOT.name]: DeviceLabels.PLEASE_REVIEW,
       [AppInfos.POLYGON.name]: DeviceLabels.VERIFY_POLYGON,
-      [AppInfos.SOLANA.name]: DeviceLabels.PUBKEY,
+      [AppInfos.SOLANA.name]: DeviceLabels.VERIFY_SOLANA_ADDRESS,
       default: DeviceLabels.ADDRESS,
     },
     receiveConfirm: {
@@ -75,13 +124,14 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.ETHEREUM.name]: DeviceLabels.CONFIRM,
       [AppInfos.POLKADOT.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.POLYGON.name]: DeviceLabels.CONFIRM,
+      [AppInfos.SOLANA.name]: DeviceLabels.CONFIRM,
       default: DeviceLabels.APPROVE,
     },
     delegateVerify: {
       [AppInfos.COSMOS.name]: DeviceLabels.PLEASE_REVIEW,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.RECEIVER,
       [AppInfos.NEAR.name]: DeviceLabels.VIEW_HEADER,
-      [AppInfos.SOLANA.name]: DeviceLabels.DELEGATE_FROM,
+      [AppInfos.SOLANA.name]: DeviceLabels.REVIEW_TRANSACTION,
       default: DeviceLabels.REVIEW_OPERATION,
     },
     delegateConfirm: {
@@ -91,8 +141,26 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.INJECTIVE.name]: DeviceLabels.CAPS_APPROVE,
       [AppInfos.MULTIVERS_X.name]: DeviceLabels.SIGN,
       [AppInfos.NEAR.name]: DeviceLabels.CONTINUE_TO_ACTION,
+      [AppInfos.SOLANA.name]: DeviceLabels.SIGN_TRANSACTION,
       [AppInfos.OSMOSIS.name]: DeviceLabels.CAPS_APPROVE,
       default: DeviceLabels.APPROVE,
     },
+    sendVerify: {
+      [AppInfos.SOLANA.name]: DeviceLabels.TRANSFER,
+      [AppInfos.RIPPLE.name]: DeviceLabels.TRANSACTION_TYPE,
+      default: DeviceLabels.REVIEW_OPERATION,
+    },
+    sendConfirm: {
+      [AppInfos.SOLANA.name]: DeviceLabels.APPROVE,
+      [AppInfos.TRON.name]: DeviceLabels.SIGN,
+      [AppInfos.STELLAR.name]: DeviceLabels.SIGN,
+      [AppInfos.RIPPLE.name]: DeviceLabels.SIGN,
+      [AppInfos.APTOS.name]: DeviceLabels.APPROVE,
+      [AppInfos.SUI.name]: DeviceLabels.ACCEPT,
+      [AppInfos.BITCOIN.name]: DeviceLabels.SIGN_TRANSACTION,
+      [AppInfos.KASPA.name]: DeviceLabels.APPROVE,
+      [AppInfos.DOGECOIN.name]: DeviceLabels.ACCEPT,
+      default: DeviceLabels.CAPS_APPROVE,
+    },
   },
 };

package/src/e2e/deviceInteraction/ButtonDeviceSimulator.ts

@@ -0,0 +1,23 @@
+import { getEnv } from "@ledgerhq/live-env";
+import { getSpeculosAddress, retryAxiosRequest } from "../speculos";
+import axios from "axios";
+
+export async function pressBoth() {
+  const speculosApiPort = getEnv("SPECULOS_API_PORT");
+  const speculosAddress = getSpeculosAddress();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/button/both`, {
+      action: "press-and-release",
+    }),
+  );
+}
+
+export async function pressRightButton(): Promise<void> {
+  const speculosApiPort = getEnv("SPECULOS_API_PORT");
+  const speculosAddress = getSpeculosAddress();
+  await retryAxiosRequest(() =>
+    axios.post(`${speculosAddress}:${speculosApiPort}/button/right`, {
+      action: "press-and-release",
+    }),
+  );
+}