@ledgerhq/live-common 34.52.0-nightly.1 → 34.52.0-nightly.3

package/src/e2e/data/deviceLabelsData.ts

@@ -114,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.VERIFY_SOLANA_ADDRESS,
+      [AppInfos.SOLANA.name]: DeviceLabels.PUBKEY,
       default: DeviceLabels.ADDRESS,
     },
     receiveConfirm: {
@@ -124,14 +124,13 @@ 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.REVIEW_TRANSACTION,
+      [AppInfos.SOLANA.name]: DeviceLabels.DELEGATE_FROM,
       default: DeviceLabels.REVIEW_OPERATION,
     },
     delegateConfirm: {
@@ -141,7 +140,6 @@ 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,
     },
@@ -160,6 +158,7 @@ export const DEVICE_LABELS_CONFIG: DeviceLabelsConfig = {
       [AppInfos.BITCOIN.name]: DeviceLabels.SIGN_TRANSACTION,
       [AppInfos.KASPA.name]: DeviceLabels.APPROVE,
       [AppInfos.DOGECOIN.name]: DeviceLabels.ACCEPT,
+      [AppInfos.BITCOIN_CASH.name]: DeviceLabels.ACCEPT,
       default: DeviceLabels.CAPS_APPROVE,
     },
   },

package/src/e2e/deviceInteraction/TouchDeviceSimulator.ts

@@ -12,14 +12,21 @@ function getSpeculosInfo(): {
 }
 export async function pressAndRelease(deviceLabel: string, x?: number, y?: number) {
   const { speculosApiPort, speculosAddress } = getSpeculosInfo();
-  const { x: coordX, y: coordY } = await getDeviceLabelCoordinates(deviceLabel, speculosApiPort);
-  x = x === undefined ? coordX : x;
-  y = y === undefined ? coordY : y;
+  let xCoord: number;
+  let yCoord: number;
+  if (x && y) {
+    xCoord = x;
+    yCoord = y;
+  } else {
+    const coords = await getDeviceLabelCoordinates(deviceLabel, speculosApiPort);
+    xCoord = coords.x;
+    yCoord = coords.y;
+  }
   await retryAxiosRequest(() =>
     axios.post(`${speculosAddress}:${speculosApiPort}/finger`, {
       action: "press-and-release",
-      x: x,
-      y: y,
+      x: xCoord,
+      y: yCoord,
     }),
   );
 }

package/src/e2e/speculos.ts

@@ -654,7 +654,12 @@ export async function activateLedgerSync() {
 export async function activateExpertMode() {
   if (isTouchDevice()) {
     await goToSettings();
-    await pressAndRelease(DeviceLabels.SETTINGS_TOGGLE_1);
+    const SettingsToggle1Coordinates = { x: 344, y: 136 };
+    await pressAndRelease(
+      DeviceLabels.SETTINGS_TOGGLE_1,
+      SettingsToggle1Coordinates.x,
+      SettingsToggle1Coordinates.y,
+    );
   } else {
     await pressUntilTextFound(DeviceLabels.EXPERT_MODE);
     await pressBoth();
@@ -723,26 +728,23 @@ export function getDeviceLabels(appInfo: AppInfos): DeviceLabelsReturn {
 export async function expectValidAddressDevice(account: Account, addressDisplayed: string) {
   if (account.currency === Currency.SUI_USDC) {
     providePublicKey();
+  }
+  const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(account.currency.speculosApp);
+  await waitFor(receiveVerifyLabel);
+  if (isTouchDevice()) {
+    const events = await pressUntilTextFound(receiveConfirmLabel);
+    const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
+    expect(isAddressCorrect).toBeTruthy();
+    await pressAndRelease(DeviceLabels.CONFIRM);
   } else {
     const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(
       account.currency.speculosApp,
     );
     await waitFor(receiveVerifyLabel);
-    if (isTouchDevice()) {
-      const events = await pressUntilTextFound(receiveConfirmLabel);
-      const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
-      expect(isAddressCorrect).toBeTruthy();
-      await pressAndRelease(DeviceLabels.CONFIRM);
-    } else {
-      const { receiveVerifyLabel, receiveConfirmLabel } = getDeviceLabels(
-        account.currency.speculosApp,
-      );
-      await waitFor(receiveVerifyLabel);
-      const events = await pressUntilTextFound(receiveConfirmLabel);
-      const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
-      expect(isAddressCorrect).toBeTruthy();
-      await pressBoth();
-    }
+    const events = await pressUntilTextFound(receiveConfirmLabel);
+    const isAddressCorrect = containsSubstringInEvent(addressDisplayed, events);
+    expect(isAddressCorrect).toBeTruthy();
+    await pressBoth();
   }
 }
 

package/src/families/bitcoin/satstack.test.ts

@@ -236,6 +236,7 @@ describe("editSatStackConfig", () => {
   setCryptoAssetsStoreForCoinFramework({
     findTokenById: (_: string) => undefined,
     findTokenByAddressInCurrency: (_: string, __: string) => undefined,
+    getTokensSyncHash: (_: string) => Promise.resolve("0"),
   } as CryptoAssetsStore);
   const config = {
     node: { ...mockConfig, tls: false },

package/src/hooks/useDeviceTransactionConfig.test.tsx

@@ -0,0 +1,200 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import { TextDecoder, TextEncoder } from "util";
+
+// Polyfill for TextDecoder/TextEncoder required by Cardano dependencies
+global.TextDecoder = TextDecoder as any;
+global.TextEncoder = TextEncoder as any;
+
+// Mock the deviceTransactionConfig module before importing anything else
+jest.mock("../transaction/deviceTransactionConfig", () => ({
+  getDeviceTransactionConfig: jest.fn(),
+}));
+
+import { renderHook, waitFor } from "@testing-library/react";
+import { useDeviceTransactionConfig } from "./useDeviceTransactionConfig";
+import { getDeviceTransactionConfig } from "../transaction/deviceTransactionConfig";
+import { Account } from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "../generated/types";
+import BigNumber from "bignumber.js";
+import { getCryptoCurrencyById } from "../currencies/index";
+
+const mockGetDeviceTransactionConfig = getDeviceTransactionConfig as jest.MockedFunction<
+  typeof getDeviceTransactionConfig
+>;
+
+const btc = getCryptoCurrencyById("bitcoin");
+
+describe("useDeviceTransactionConfig", () => {
+  const mockAccount: Account = {
+    type: "Account",
+    id: "test-account-id",
+    seedIdentifier: "seed-id",
+    derivationMode: "" as const,
+    index: 0,
+    freshAddress: "test-address",
+    freshAddressPath: "44'/0'/0'/0/0",
+    used: true,
+    balance: new BigNumber(1000000),
+    spendableBalance: new BigNumber(1000000),
+    creationDate: new Date(),
+    blockHeight: 100,
+    currency: btc,
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    swapHistory: [],
+  };
+
+  const mockTransaction: Transaction = {
+    family: "bitcoin" as any,
+    amount: new BigNumber(100),
+    recipient: "test-recipient",
+    useAllAmount: false,
+  } as Transaction;
+
+  const mockStatus: TransactionStatus = {
+    errors: {},
+    warnings: {},
+    estimatedFees: new BigNumber(10),
+    amount: new BigNumber(100),
+    totalSpent: new BigNumber(110),
+  } as TransactionStatus;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should load device transaction config fields successfully", async () => {
+    const mockFields = [
+      { type: "amount", label: "Amount" },
+      { type: "fees", label: "Fees" },
+    ];
+
+    mockGetDeviceTransactionConfig.mockResolvedValue(mockFields as any);
+
+    const { result } = renderHook(() =>
+      useDeviceTransactionConfig({
+        account: mockAccount,
+        parentAccount: null,
+        transaction: mockTransaction,
+        status: mockStatus,
+      }),
+    );
+
+    // Initially loading
+    expect(result.current.loading).toBe(true);
+    expect(result.current.fields).toEqual([]);
+
+    // Wait for async operation
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual(mockFields);
+    expect(mockGetDeviceTransactionConfig).toHaveBeenCalledWith({
+      account: mockAccount,
+      parentAccount: null,
+      transaction: mockTransaction,
+      status: mockStatus,
+    });
+  });
+
+  it("should handle errors gracefully", async () => {
+    const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+    mockGetDeviceTransactionConfig.mockRejectedValue(new Error("Test error"));
+
+    const { result } = renderHook(() =>
+      useDeviceTransactionConfig({
+        account: mockAccount,
+        parentAccount: null,
+        transaction: mockTransaction,
+        status: mockStatus,
+      }),
+    );
+
+    expect(result.current.loading).toBe(true);
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual([]);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      "Failed to load device transaction config:",
+      expect.any(Error),
+    );
+
+    consoleErrorSpy.mockRestore();
+  });
+
+  it("should reload fields when dependencies change", async () => {
+    const mockFields1 = [{ type: "amount", label: "Amount 1" }];
+    const mockFields2 = [{ type: "amount", label: "Amount 2" }];
+
+    mockGetDeviceTransactionConfig
+      .mockResolvedValueOnce(mockFields1 as any)
+      .mockResolvedValueOnce(mockFields2 as any);
+
+    const { result, rerender } = renderHook(
+      ({ transaction }) =>
+        useDeviceTransactionConfig({
+          account: mockAccount,
+          parentAccount: null,
+          transaction,
+          status: mockStatus,
+        }),
+      {
+        initialProps: { transaction: mockTransaction },
+      },
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual(mockFields1);
+
+    // Change transaction
+    const newTransaction = {
+      ...mockTransaction,
+      amount: new BigNumber(200),
+    };
+
+    rerender({ transaction: newTransaction });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.fields).toEqual(mockFields2);
+    expect(mockGetDeviceTransactionConfig).toHaveBeenCalledTimes(2);
+  });
+
+  it("should cleanup on unmount", async () => {
+    const mockFields = [{ type: "amount", label: "Amount" }];
+    mockGetDeviceTransactionConfig.mockResolvedValue(mockFields as any);
+
+    const { unmount } = renderHook(() =>
+      useDeviceTransactionConfig({
+        account: mockAccount,
+        parentAccount: null,
+        transaction: mockTransaction,
+        status: mockStatus,
+      }),
+    );
+
+    unmount();
+
+    // Should not throw any errors
+    expect(mockGetDeviceTransactionConfig).toHaveBeenCalled();
+  });
+});

package/src/hooks/useDeviceTransactionConfig.ts

@@ -0,0 +1,65 @@
+import { useState, useEffect } from "react";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { Transaction, TransactionStatus } from "../generated/types";
+import {
+  getDeviceTransactionConfig,
+  DeviceTransactionField,
+} from "../transaction/deviceTransactionConfig";
+
+type UseDeviceTransactionConfigParams = {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+};
+
+/**
+ * Hook to fetch device transaction configuration fields asynchronously.
+ * This anticipates the future async nature of crypto assets store operations.
+ */
+export function useDeviceTransactionConfig({
+  account,
+  parentAccount,
+  transaction,
+  status,
+}: UseDeviceTransactionConfigParams): {
+  fields: DeviceTransactionField[];
+  loading: boolean;
+} {
+  const [fields, setFields] = useState<DeviceTransactionField[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    let mounted = true;
+
+    async function loadFields() {
+      try {
+        setLoading(true);
+        const result = await getDeviceTransactionConfig({
+          account,
+          parentAccount,
+          transaction,
+          status,
+        });
+        if (mounted) {
+          setFields(result);
+          setLoading(false);
+        }
+      } catch (error) {
+        console.error("Failed to load device transaction config:", error);
+        if (mounted) {
+          setFields([]);
+          setLoading(false);
+        }
+      }
+    }
+
+    loadFields();
+
+    return () => {
+      mounted = false;
+    };
+  }, [account, parentAccount, transaction, status]);
+
+  return { fields, loading };
+}

package/src/modularDrawer/__mocks__/currencies.mock.ts

@@ -7,6 +7,7 @@ export const mockArbitrumCryptoCurrency = getCryptoCurrencyById("arbitrum");
 export const mockBaseCryptoCurrency = getCryptoCurrencyById("base");
 export const mockScrollCryptoCurrency = getCryptoCurrencyById("scroll");
 export const mockInjectiveCryptoCurrency = getCryptoCurrencyById("injective");
+export const mockBscCryptoCurrency = getCryptoCurrencyById("bsc");
 
 export const arbitrumToken: TokenCurrency = {
   type: "TokenCurrency",
@@ -41,6 +42,45 @@ export const usdcToken: TokenCurrency = {
   ],
 };
 
+export const maticEth: TokenCurrency = {
+  type: "TokenCurrency" as const,
+  id: "ethereum/erc20/matic",
+  ledgerSignature: "",
+  contractAddress: "0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0",
+  parentCurrency: mockEthCryptoCurrency,
+  tokenType: "erc20" as const,
+  name: "Matic",
+  ticker: "MATIC",
+  delisted: false,
+  disableCountervalue: false,
+  units: [
+    {
+      name: "Matic",
+      code: "MATIC",
+      magnitude: 18,
+    },
+  ],
+};
+
+export const maticBsc: TokenCurrency = {
+  type: "TokenCurrency" as const,
+  id: "bsc/bep20/matic_token",
+  ledgerSignature: "",
+  contractAddress: "0xCC42724C6683B7E57334c4E856f4c9965ED682bD",
+  parentCurrency: mockBscCryptoCurrency,
+  tokenType: "bep20" as const,
+  name: "Matic Token",
+  ticker: "MATIC",
+  delisted: false,
+  disableCountervalue: false,
+  units: [
+    {
+      name: "Matic Token",
+      code: "MATIC",
+      magnitude: 18,
+    },
+  ],
+};
 export const findCryptoCurrencyById = (id: string) =>
   [mockBtcCryptoCurrency, mockEthCryptoCurrency, mockArbitrumCryptoCurrency].find(a => a.id === id);
 export const getTokenOrCryptoCurrencyById = (id: string) =>

package/src/modularDrawer/utils/index.ts

@@ -2,17 +2,13 @@ import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
 export { groupCurrenciesByProvider } from "./groupCurrenciesByProvider";
 export { sortAccountsByFiatValue } from "./sortAccountsByFiatValue";
 
-function isCorrespondingCurrency(
+const getBaseId = (currency: CryptoOrTokenCurrency) =>
+  currency.type === "CryptoCurrency" ? currency.id : currency.parentCurrency.id;
+
+function belongsToSameNetwork(
   elem: CryptoOrTokenCurrency,
   network: CryptoOrTokenCurrency,
 ): boolean {
-  if (elem.type === "TokenCurrency") {
-    return elem.parentCurrency?.id === network.id || elem.id === network.id;
-  }
-  if (elem.type === "CryptoCurrency") {
-    return elem.id === network.id;
-  }
-  return false;
+  return getBaseId(elem) === getBaseId(network);
 }
-
-export { isCorrespondingCurrency };
+export { getBaseId, belongsToSameNetwork };

package/src/transaction/deviceTransactionConfig.ts

@@ -6,14 +6,14 @@ import { getMainAccount } from "../account";
 import type { Account, AccountLike } from "@ledgerhq/types-live";
 
 export type DeviceTransactionField = CommonDeviceTransactionField | ExtraDeviceTransactionField;
-export function getDeviceTransactionConfig(arg: {
+export async function getDeviceTransactionConfig(arg: {
   account: AccountLike;
   parentAccount: Account | null | undefined;
   transaction: Transaction;
   status: TransactionStatus;
-}): Array<DeviceTransactionField> {
+}): Promise<Array<DeviceTransactionField>> {
   const mainAccount = getMainAccount(arg.account, arg.parentAccount);
   const f = perFamily[mainAccount.currency.family];
   if (!f) return [];
-  return f(arg);
+  return await f(arg);
 }

package/src/modularDrawer/utils/index.test.ts

@@ -1,43 +0,0 @@
-import { isCorrespondingCurrency } from "./index";
-
-import { createFixtureCryptoCurrency } from "../../mock/fixtures/cryptoCurrencies";
-import { cryptocurrenciesById } from "@ledgerhq/cryptoassets";
-import type { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
-
-describe("isCorrespondingCurrency", () => {
-  const evmCurrency = createFixtureCryptoCurrency("evm");
-  const usdcToken: CryptoOrTokenCurrency = {
-    type: "TokenCurrency",
-    id: "ethereum/erc20/usdc",
-    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    parentCurrency: evmCurrency,
-    tokenType: "erc20",
-    name: "USD Coin",
-    ticker: "USDC",
-    units: [{ name: "USD Coin", code: "USDC", magnitude: 6 }],
-  };
-  const evmCrypto: CryptoOrTokenCurrency = evmCurrency;
-
-  it("returns true for a token whose parentCurrency.id matches the reference crypto", () => {
-    expect(isCorrespondingCurrency(usdcToken, evmCurrency)).toBe(true);
-  });
-
-  it("returns true for a token whose id matches the reference crypto", () => {
-    expect(isCorrespondingCurrency(usdcToken, usdcToken)).toBe(true);
-  });
-
-  it("returns true for a crypto whose id matches the reference crypto", () => {
-    expect(isCorrespondingCurrency(evmCrypto, evmCurrency)).toBe(true);
-  });
-
-  it("returns false for a token whose parentCurrency is different", () => {
-    const bitcoinCurrency = cryptocurrenciesById["bitcoin"];
-    const tokenWithOtherParent = { ...usdcToken, parentCurrency: bitcoinCurrency };
-    expect(isCorrespondingCurrency(tokenWithOtherParent, evmCurrency)).toBe(false);
-  });
-
-  it("returns false for a crypto whose id is different", () => {
-    const bitcoinCurrency = cryptocurrenciesById["bitcoin"];
-    expect(isCorrespondingCurrency(bitcoinCurrency, evmCurrency)).toBe(false);
-  });
-});