@ledgerhq/live-common 27.0.0 → 27.0.1-next.0

package/src/hw/hooks/useGenuineCheck.test.ts

@@ -0,0 +1,232 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import { of, throwError } from "rxjs";
+import {
+  UserRefusedAllowManager,
+  DisconnectedDeviceDuringOperation,
+} from "@ledgerhq/errors";
+import { useGenuineCheck } from "./useGenuineCheck";
+import { getGenuineCheckFromDeviceId } from "../getGenuineCheckFromDeviceId";
+
+jest.mock("../getGenuineCheckFromDeviceId");
+jest.useFakeTimers();
+
+const mockedGetGenuineCheckFromDeviceId = jest.mocked(
+  getGenuineCheckFromDeviceId
+);
+
+describe("useGenuineCheck", () => {
+  afterEach(() => {
+    mockedGetGenuineCheckFromDeviceId.mockClear();
+    jest.clearAllTimers();
+  });
+
+  describe("When the genuine check requests for a device permission", () => {
+    it("should notify the hook consumer of the request", async () => {
+      mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+        of({
+          socketEvent: { type: "device-permission-requested", wording: "" },
+          deviceIsLocked: false,
+        })
+      );
+      const { result } = renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.devicePermissionState).toEqual("requested");
+      expect(result.current.genuineState).toEqual("unchecked");
+      expect(result.current.error).toBeNull();
+    });
+
+    it("should notify the hook consumer if the device permission is granted", async () => {
+      mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+        of({
+          socketEvent: { type: "device-permission-granted" },
+          deviceIsLocked: false,
+        })
+      );
+      const { result } = renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.devicePermissionState).toEqual("granted");
+      expect(result.current.genuineState).toEqual("unchecked");
+      expect(result.current.error).toBeNull();
+    });
+
+    it("should notify the hook consumer if the device permission is refused", async () => {
+      mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+        throwError(new UserRefusedAllowManager())
+      );
+      const { result } = renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.devicePermissionState).toEqual("refused");
+      expect(result.current.genuineState).toEqual("unchecked");
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe("When an error occurred during the genuine check", () => {
+    it("should notify the hook consumer that an error occurred", async () => {
+      mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+        throwError(new DisconnectedDeviceDuringOperation())
+      );
+      const { result } = renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.genuineState).toEqual("unchecked");
+      expect(result.current.error).toBeInstanceOf(
+        DisconnectedDeviceDuringOperation
+      );
+    });
+  });
+
+  describe("When the genuine check is completed", () => {
+    describe("and it is a success", () => {
+      it("should notify the hook consumer of the success", async () => {
+        mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+          of({
+            socketEvent: { type: "result", payload: "0000" },
+            deviceIsLocked: false,
+          })
+        );
+        const { result } = renderHook(() =>
+          useGenuineCheck({
+            getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+            deviceId: "A_DEVICE_ID",
+          })
+        );
+
+        await act(async () => {
+          jest.advanceTimersByTime(1);
+        });
+
+        expect(result.current.genuineState).toEqual("genuine");
+        expect(result.current.error).toBeNull();
+      });
+    });
+
+    describe("and the device is not genuine", () => {
+      it("should notify the hook consumer that the device is not genuine", async () => {
+        mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+          of({
+            socketEvent: { type: "result", payload: "1111" },
+            deviceIsLocked: false,
+          })
+        );
+        const { result } = renderHook(() =>
+          useGenuineCheck({
+            getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+            deviceId: "A_DEVICE_ID",
+          })
+        );
+
+        await act(async () => {
+          jest.advanceTimersByTime(1);
+        });
+
+        expect(result.current.genuineState).toEqual("non-genuine");
+        expect(result.current.error).toBeNull();
+      });
+    });
+  });
+
+  describe("When the hook consumer requests to reset the genuine check state", () => {
+    it("should reset the device permission and genuine states", async () => {
+      // In the case of an unsuccessful genuine check
+      mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+        of(
+          {
+            socketEvent: { type: "device-permission-granted" },
+            deviceIsLocked: false,
+          },
+          {
+            socketEvent: { type: "result", payload: "1111" },
+            deviceIsLocked: false,
+          }
+        )
+      );
+
+      const { result } = renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+          isHookEnabled: true,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.devicePermissionState).toEqual("granted");
+      expect(result.current.genuineState).toEqual("non-genuine");
+      expect(result.current.error).toBeNull();
+
+      // We ask to reset the genuine check state
+      await act(async () => {
+        result.current.resetGenuineCheckState();
+      });
+
+      expect(result.current.devicePermissionState).toEqual("unrequested");
+      expect(result.current.genuineState).toEqual("unchecked");
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe("When the device is locked before doing a genuine check, and it timed out", () => {
+    it("should notify the hook consumer of the need to unlock the device", async () => {
+      mockedGetGenuineCheckFromDeviceId.mockReturnValue(
+        of({
+          socketEvent: null,
+          deviceIsLocked: true,
+        })
+      );
+
+      const { result } = renderHook(() =>
+        useGenuineCheck({
+          getGenuineCheckFromDeviceId: mockedGetGenuineCheckFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.devicePermissionState).toEqual("unlock-needed");
+      expect(result.current.genuineState).toEqual("unchecked");
+      expect(result.current.error).toBeNull();
+    });
+  });
+});

package/src/hw/hooks/useGenuineCheck.ts

@@ -0,0 +1,138 @@
+import { useCallback, useEffect, useState } from "react";
+import { UserRefusedAllowManager } from "@ledgerhq/errors";
+import type { DeviceId } from "@ledgerhq/types-live";
+import { getGenuineCheckFromDeviceId as defaultGetGenuineCheckFromDeviceId } from "../getGenuineCheckFromDeviceId";
+import type {
+  GetGenuineCheckFromDeviceIdArgs,
+  GetGenuineCheckFromDeviceIdResult,
+  GetGenuineCheckFromDeviceIdOutput,
+} from "../getGenuineCheckFromDeviceId";
+
+export type GenuineState = "unchecked" | "genuine" | "non-genuine";
+export type DevicePermissionState =
+  | "unrequested"
+  | "unlock-needed"
+  | "unlocked"
+  | "requested"
+  | "granted"
+  | "refused";
+
+export type UseGenuineCheckArgs = {
+  isHookEnabled?: boolean;
+  deviceId: DeviceId;
+  lockedDeviceTimeoutMs?: number;
+};
+
+export type UseGenuineCheckDependencies = {
+  getGenuineCheckFromDeviceId?: (
+    args: GetGenuineCheckFromDeviceIdArgs
+  ) => GetGenuineCheckFromDeviceIdOutput;
+};
+
+export type UseGenuineCheckResult = {
+  genuineState: GenuineState;
+  devicePermissionState: DevicePermissionState;
+  error: Error | null;
+  resetGenuineCheckState: () => void;
+};
+
+const SOCKET_EVENT_PAYLOAD_GENUINE = "0000";
+
+/**
+ * Hook to check that a device is genuine
+ * It replaces a DeviceAction if we're only interested in getting the genuine check
+ * @param getGenuineCheckFromDeviceId An optional function to get a genuine check for a given device id,
+ * by default set to live-common/hw/getGenuineCheckFromDeviceId.
+ * This dependency injection is needed for LLD to have the hook working on the internal thread
+ * @param isHookEnabled A boolean to enable (true, default value) or disable (false) the hook
+ * @param deviceId A device id, or an empty string if device is usb plugged
+ * @param lockedDeviceTimeoutMs Time of no response from device after which the device is considered locked, in ms. Default 1000ms.
+ * @returns An object containing:
+ * - genuineState: the current GenuineState
+ * - devicePermissionState: the current DevicePermissionState
+ * - error: any error that occurred during the genuine check, or null
+ */
+export const useGenuineCheck = ({
+  getGenuineCheckFromDeviceId = defaultGetGenuineCheckFromDeviceId,
+  isHookEnabled = true,
+  deviceId,
+  lockedDeviceTimeoutMs = 1000,
+}: UseGenuineCheckArgs &
+  UseGenuineCheckDependencies): UseGenuineCheckResult => {
+  const [genuineState, setGenuineState] = useState<GenuineState>("unchecked");
+  const [devicePermissionState, setDevicePermissionState] =
+    useState<DevicePermissionState>("unrequested");
+  const [error, setError] = useState<Error | null>(null);
+
+  const resetGenuineCheckState = useCallback(() => {
+    setDevicePermissionState("unrequested");
+    setGenuineState("unchecked");
+  }, []);
+
+  useEffect(() => {
+    if (!isHookEnabled) {
+      return;
+    }
+
+    const sub = getGenuineCheckFromDeviceId({
+      deviceId,
+      lockedDeviceTimeoutMs,
+    }).subscribe({
+      next: ({
+        socketEvent,
+        deviceIsLocked,
+      }: GetGenuineCheckFromDeviceIdResult) => {
+        if (socketEvent) {
+          switch (socketEvent.type) {
+            case "device-permission-requested":
+              setDevicePermissionState("requested");
+              break;
+            case "device-permission-granted":
+              setDevicePermissionState("granted");
+              break;
+            case "result":
+              if (socketEvent.payload === SOCKET_EVENT_PAYLOAD_GENUINE) {
+                setGenuineState("genuine");
+              } else {
+                setGenuineState("non-genuine");
+              }
+              break;
+          }
+        } else {
+          // If no socketEvent, the device is locked or has been unlocked
+          if (deviceIsLocked) {
+            setDevicePermissionState("unlock-needed");
+          } else {
+            setDevicePermissionState("unlocked");
+          }
+        }
+      },
+      error: (e: any) => {
+        if (e instanceof UserRefusedAllowManager) {
+          setDevicePermissionState("refused");
+        } else if (e instanceof Error) {
+          // Probably an error of type DisconnectedDeviceDuringOperation or something else
+          setError(e);
+        } else {
+          setError(new Error(`Unknown error: ${e}`));
+        }
+      },
+    });
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }, [
+    isHookEnabled,
+    deviceId,
+    lockedDeviceTimeoutMs,
+    getGenuineCheckFromDeviceId,
+  ]);
+
+  return {
+    genuineState,
+    devicePermissionState,
+    error,
+    resetGenuineCheckState,
+  };
+};

package/src/hw/hooks/useGetLatestAvailableFirmware.test.ts

@@ -0,0 +1,111 @@
+import { FirmwareUpdateContext } from "@ledgerhq/types-live";
+import { renderHook, act } from "@testing-library/react-hooks";
+import { of } from "rxjs";
+import { getLatestAvailableFirmwareFromDeviceId } from "../getLatestAvailableFirmwareFromDeviceId";
+import { useGetLatestAvailableFirmware } from "./useGetLatestAvailableFirmware";
+
+jest.mock("../getLatestAvailableFirmwareFromDeviceId");
+jest.useFakeTimers();
+
+const mockedGetLatestAvailableFirmwareFromDeviceId = jest.mocked(
+  getLatestAvailableFirmwareFromDeviceId
+);
+
+const aLatestFirmwareContext: FirmwareUpdateContext = {
+  osu: {
+    next_se_firmware_final_version: 1,
+    previous_se_firmware_final_version: [],
+    id: 0,
+    name: "OSU",
+    description: null,
+    display_name: null,
+    notes: null,
+    perso: "",
+    firmware: "",
+    firmware_key: "",
+    hash: "",
+    date_creation: "",
+    date_last_modified: "",
+    device_versions: [],
+    providers: [],
+  },
+  final: {
+    id: 1,
+    name: "FINAL",
+    description: null,
+    display_name: null,
+    notes: null,
+    perso: "",
+    firmware: "",
+    firmware_key: "",
+    hash: "",
+    date_creation: "",
+    date_last_modified: "",
+    device_versions: [],
+    providers: [],
+    version: "",
+    se_firmware: 1,
+    osu_versions: [],
+    mcu_versions: [],
+    application_versions: [],
+  },
+  shouldFlashMCU: false,
+};
+
+// TODO: rename into useGetLatestAvailableFirmware ?
+describe("useGetLatestAvailableFirmware", () => {
+  afterEach(() => {
+    mockedGetLatestAvailableFirmwareFromDeviceId.mockClear();
+    jest.clearAllTimers();
+  });
+
+  describe("When no new firmware update is available for a device", () => {
+    it("should notify the hook consumer that there is no latest available firmware", async () => {
+      mockedGetLatestAvailableFirmwareFromDeviceId.mockReturnValue(
+        of({
+          firmwareUpdateContext: undefined,
+        })
+      );
+      const { result } = renderHook(() =>
+        useGetLatestAvailableFirmware({
+          getLatestAvailableFirmwareFromDeviceId:
+            mockedGetLatestAvailableFirmwareFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.status).toEqual("no-available-firmware");
+      expect(result.current.error).toBeNull();
+      expect(result.current.latestFirmware).toBeNull();
+    });
+  });
+
+  describe("When a new firmware update is available for a device", () => {
+    it("should notify the hook consumer that there is a new latest available firmware", async () => {
+      mockedGetLatestAvailableFirmwareFromDeviceId.mockReturnValue(
+        of({
+          firmwareUpdateContext: aLatestFirmwareContext,
+        })
+      );
+      const { result } = renderHook(() =>
+        useGetLatestAvailableFirmware({
+          getLatestAvailableFirmwareFromDeviceId:
+            mockedGetLatestAvailableFirmwareFromDeviceId,
+          deviceId: "A_DEVICE_ID",
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.status).toEqual("available-firmware");
+      expect(result.current.error).toBeNull();
+      expect(result.current.latestFirmware).toEqual(aLatestFirmwareContext);
+    });
+  });
+});

package/src/hw/hooks/useGetLatestAvailableFirmware.ts

@@ -0,0 +1,90 @@
+import { useEffect, useState } from "react";
+import type { FirmwareUpdateContext, DeviceId } from "@ledgerhq/types-live";
+import type {
+  GetLatestAvailableFirmwareFromDeviceIdArgs,
+  GetLatestAvailableFirmwareFromDeviceIdResult,
+  GetLatestAvailableFirmwareFromDeviceIdOutput,
+} from "../getLatestAvailableFirmwareFromDeviceId";
+import { getLatestAvailableFirmwareFromDeviceId as defaultGetLatestAvailableFirmwareFromDeviceId } from "../getLatestAvailableFirmwareFromDeviceId";
+
+export type FirmwareUpdateGettingStatus =
+  | "unchecked"
+  | "checking"
+  | "no-available-firmware"
+  | "available-firmware";
+
+export type useGetLatestAvailableFirmwareDependencies = {
+  getLatestAvailableFirmwareFromDeviceId?: (
+    args: GetLatestAvailableFirmwareFromDeviceIdArgs
+  ) => GetLatestAvailableFirmwareFromDeviceIdOutput;
+};
+
+export type useGetLatestAvailableFirmwareArgs = {
+  isHookEnabled?: boolean;
+  deviceId: DeviceId;
+};
+
+export type useGetLatestAvailableFirmwareResult = {
+  latestFirmware: FirmwareUpdateContext | null;
+  status: FirmwareUpdateGettingStatus;
+  error: Error | null;
+};
+
+/**
+ * Hook to get the latest available firmware for a device
+ * @param getLatestAvailableFirmwareFromDeviceId An optional function to get the latest available firmware
+ * for a given device id, by default set to live-common/hw/getLatestAvailableFirmwareFromDeviceId.
+ * This dependency injection is needed for LLD to have the hook working on the internal thread
+ * @param isHookEnabled A boolean to enable (true, default value) or disable (false) the hook
+ * @param deviceId A device id, or an empty string if device is usb plugged
+ * @returns An object containing:
+ * - latestFirmware A FirmwareUpdateContext if found, or null if still processing or no available firmware update
+ * - status A FirmwareUpdateGettingStatus to notify consumer on the hook state
+ * - error: any error that occurred during the process, or null
+ */
+export const useGetLatestAvailableFirmware = ({
+  getLatestAvailableFirmwareFromDeviceId = defaultGetLatestAvailableFirmwareFromDeviceId,
+  isHookEnabled = true,
+  deviceId,
+}: useGetLatestAvailableFirmwareArgs &
+  useGetLatestAvailableFirmwareDependencies): useGetLatestAvailableFirmwareResult => {
+  const [latestFirmware, setLatestFirmware] =
+    useState<FirmwareUpdateContext | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [status, setStatus] =
+    useState<FirmwareUpdateGettingStatus>("unchecked");
+
+  useEffect(() => {
+    if (!isHookEnabled) {
+      return;
+    }
+    setStatus("checking");
+
+    const sub = getLatestAvailableFirmwareFromDeviceId({ deviceId }).subscribe({
+      next: ({
+        firmwareUpdateContext,
+      }: GetLatestAvailableFirmwareFromDeviceIdResult) => {
+        if (!firmwareUpdateContext) {
+          setLatestFirmware(null);
+          setStatus("no-available-firmware");
+        } else {
+          setLatestFirmware(firmwareUpdateContext);
+          setStatus("available-firmware");
+        }
+      },
+      error: (e: any) => {
+        if (e instanceof Error) {
+          setError(e);
+        } else {
+          setError(new Error(`Unknown error: ${e}`));
+        }
+      },
+    });
+
+    return () => {
+      sub.unsubscribe();
+    };
+  }, [deviceId, getLatestAvailableFirmwareFromDeviceId, isHookEnabled]);
+
+  return { latestFirmware, error, status };
+};

package/src/load/speculos.ts

@@ -49,6 +49,7 @@ export async function createSpeculosDevice(
 ): Promise<{
   transport: SpeculosTransport;
   id: string;
+  appPath: string;
 }> {
   const { model, firmware, appName, appVersion, seed, coinapps, dependency } =
     arg;
@@ -202,6 +203,7 @@ export async function createSpeculosDevice(
   return {
     id: speculosID,
     transport,
+    appPath,
   };
 }
 export type AppCandidate = {

package/src/mock/fixtures/cryptoCurrencies.ts

@@ -0,0 +1,88 @@
+import BigNumber from "bignumber.js";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import type { Account } from "@ledgerhq/types-live";
+import { cryptocurrenciesById } from "@ledgerhq/cryptoassets";
+
+export function createFixtureCryptoCurrency(family: string): CryptoCurrency {
+  return {
+    type: "CryptoCurrency",
+    id: "testCoinId",
+    coinType: 8008,
+    name: "MyCoin",
+    managerAppName: "MyCoin",
+    ticker: "MYC",
+    countervalueTicker: "MYC",
+    scheme: "mycoin",
+    color: "#ff0000",
+    family,
+    units: [
+      {
+        name: "MYC",
+        code: "MYC",
+        magnitude: 8,
+      },
+      {
+        name: "SmallestUnit",
+        code: "SMALLESTUNIT",
+        magnitude: 0,
+      },
+    ],
+    explorerViews: [
+      {
+        address: "https://mycoinexplorer.com/account/$address",
+        tx: "https://mycoinexplorer.com/transaction/$hash",
+        token: "https://mycoinexplorer.com/token/$contractAddress/?a=$address",
+      },
+    ],
+  };
+}
+
+const defaultEthCryptoFamily = cryptocurrenciesById["ethereum"];
+
+export function createFixtureAccount(
+  id = "00",
+  currency: CryptoCurrency = defaultEthCryptoFamily
+): Account {
+  return {
+    type: "Account",
+    id: `ethereumjs:2:ethereum:0x0${id}:`,
+    seedIdentifier: "0x01",
+    derivationMode: "ethM",
+    index: 0,
+    freshAddress: "0x01",
+    freshAddressPath: "44'/60'/0'/0/0",
+    freshAddresses: [],
+    name: "Ethereum 1",
+    starred: false,
+    used: false,
+    balance: new BigNumber("51281813126095913"),
+    spendableBalance: new BigNumber("51281813126095913"),
+    creationDate: new Date(),
+    blockHeight: 8168983,
+    currency,
+    unit: {
+      name: "satoshi",
+      code: "BTC",
+      magnitude: 5,
+    },
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: {
+        balances: [],
+        latestDate: undefined,
+      },
+      DAY: {
+        balances: [],
+        latestDate: undefined,
+      },
+      WEEK: {
+        balances: [],
+        latestDate: undefined,
+      },
+    },
+    swapHistory: [],
+  };
+}