@ledgerhq/live-common 26.0.0 → 26.1.0-next.1

package/src/__tests__/hw/getDeviceInfo.ts

@@ -515,3 +515,140 @@ test("Nano X BL >= 2", async () => {
     pinValidated: true,
   });
 });
+test("Nano X 1.2.4-6", async () => {
+  const t = await openTransportReplayer(
+    RecordStore.fromString(`
+    => b001000000
+    <= 01054f4c4f5300072e322e342d36009000
+    => e001000000
+    <= 3300000407312e322e342d3604a600000004322e31329000
+    `)
+  );
+  const res = await getDeviceInfo(t);
+  expect(res).toMatchObject({
+    version: "1.2.4-6",
+    mcuVersion: "2.12",
+    seVersion: "1.2.4-6",
+    majMin: "1.2",
+    providerName: null,
+    targetId: 855638020,
+    seTargetId: 855638020,
+    isOSU: false,
+    isBootloader: false,
+    isRecoveryMode: false,
+    managerAllowed: false,
+    pinValidated: true,
+    onboarded: true,
+  });
+});
+test("Nano X 2.0.0", async () => {
+  const t = await openTransportReplayer(
+    RecordStore.fromString(`
+    => b001000000
+    <= 0105424f4c4f5305322e302e309000
+    => e001000000
+    <= 3300000405322e302e3004a600000004322e323804312e313601009000
+    `)
+  );
+  const res = await getDeviceInfo(t);
+  expect(res).toMatchObject({
+    version: "2.0.0",
+    mcuVersion: "2.28",
+    seVersion: "2.0.0",
+    majMin: "2.0",
+    providerName: null,
+    targetId: 855638020,
+    seTargetId: 855638020,
+    isOSU: false,
+    isBootloader: false,
+    isRecoveryMode: false,
+    managerAllowed: false,
+    pinValidated: true,
+    onboarded: true,
+    bootloaderVersion: "1.16",
+    hardwareVersion: 0,
+  });
+});
+test("Nano X 2.1.0-lo2", async () => {
+  const t = await openTransportReplayer(
+    RecordStore.fromString(`
+    => b001000000
+    <= 0105424f4c4f5309322e312e302d6c6f329000
+    => e001000000
+    <= 3300000409322e312e302d6c6f3204e600000004322e333004312e3136010001019000
+    `)
+  );
+  const res = await getDeviceInfo(t);
+  expect(res).toMatchObject({
+    version: "2.1.0-lo2",
+    mcuVersion: "2.30",
+    seVersion: "2.1.0-lo2",
+    majMin: "2.1",
+    providerName: null,
+    targetId: 855638020,
+    seTargetId: 855638020,
+    isOSU: false,
+    isBootloader: false,
+    isRecoveryMode: false,
+    managerAllowed: false,
+    pinValidated: true,
+    onboarded: true,
+    bootloaderVersion: "1.16",
+    hardwareVersion: 0,
+    languageId: 1,
+  });
+});
+test("Nano S 2.1.0", async () => {
+  const t = await openTransportReplayer(
+    RecordStore.fromString(`
+    => b001000000
+    <= 0105424f4c4f5305322e312e309000
+    => e001000000
+    <= 3110000405322e312e3004a600000004312e313204302e31319000
+    `)
+  );
+  const res = await getDeviceInfo(t);
+  expect(res).toMatchObject({
+    version: "2.1.0",
+    mcuVersion: "1.12",
+    seVersion: "2.1.0",
+    majMin: "2.1",
+    providerName: null,
+    targetId: 823132164,
+    seTargetId: 823132164,
+    isOSU: false,
+    isBootloader: false,
+    isRecoveryMode: false,
+    managerAllowed: false,
+    pinValidated: true,
+    onboarded: true,
+    bootloaderVersion: "0.11",
+  });
+});
+test("Nano S+ 1.0.2", async () => {
+  const t = await openTransportReplayer(
+    RecordStore.fromString(`
+    => b001000000
+    <= 0105424f4c4f5305312e302e329000
+    => e001000000
+    <= 3310000405312e302e3204a600000004342e303204332e31329000
+    `)
+  );
+  const res = await getDeviceInfo(t);
+  expect(res).toMatchObject({
+    version: "1.0.2",
+    mcuVersion: "4.02",
+    seVersion: "1.0.2",
+    majMin: "1.0",
+    providerName: null,
+    targetId: 856686596,
+    seTargetId: 856686596,
+    isOSU: false,
+    isBootloader: false,
+    isRecoveryMode: false,
+    managerAllowed: false,
+    pinValidated: true,
+    onboarded: true,
+    bootloaderVersion: "3.12",
+  });
+});

package/src/api/Manager.ts

@@ -30,6 +30,8 @@ import { getEnv } from "../env";
 import { makeLRUCache } from "../cache";
 import { getUserHashes } from "../user";
 import {
+  LanguagePackage,
+  LanguagePackageResponse,
   Application,
   ApplicationVersion,
   Category,
@@ -41,6 +43,7 @@ import {
   OsuFirmware,
   SocketEvent,
 } from "@ledgerhq/types-live";
+import { getProviderId } from "../manager/provider";
 
 declare global {
   namespace NodeJS {
@@ -205,6 +208,50 @@ const findBestMCU = (compatibleMCU: McuVersion[]): McuVersion | undefined => {
   return best;
 };
 
+const getLanguagePackagesForDevice = async (
+  deviceInfo: DeviceInfo
+): Promise<LanguagePackage[]> => {
+  const deviceVersion = await getDeviceVersion(
+    deviceInfo.targetId,
+    getProviderId(deviceInfo)
+  );
+
+  const seFirmwareVersion = await getCurrentFirmware({
+    version: deviceInfo.version,
+    deviceId: deviceVersion.id,
+    provider: getProviderId(deviceInfo),
+  });
+
+  const { data }: { data: LanguagePackageResponse[] } = await network({
+    method: "GET",
+    url: URL.format({
+      pathname: `${getEnv("MANAGER_API_BASE")}/language-package`,
+      query: {
+        livecommonversion,
+      },
+    }),
+  });
+
+  const allPackages: LanguagePackage[] = data.reduce(
+    (acc, response) => [
+      ...acc,
+      ...response.language_package_version.map((p) => ({
+        ...p,
+        language: response.language,
+      })),
+    ],
+    [] as LanguagePackage[]
+  );
+
+  const packages = allPackages.filter(
+    (pack) =>
+      pack.device_versions.includes(deviceVersion.id) &&
+      pack.se_firmware_final_versions.includes(seFirmwareVersion.id)
+  );
+
+  return packages;
+};
+
 const getLatestFirmware: (arg0: {
   current_se_firmware_final_version: Id;
   device_version: Id;
@@ -340,8 +387,8 @@ const getDeviceVersion: (
         target_id: targetId,
       },
     }).catch((error) => {
-      const status = // FIXME LLD is doing error remapping already. we probably need to move the remapping in live-common
-        error && (error.status || (error.response && error.response.status));
+      const status =
+        error && (error.status || (error.response && error.response.status)); // FIXME LLD is doing error remapping already. we probably need to move the remapping in live-common
 
       if (status === 404) {
         throw new FirmwareNotRecognized(
@@ -528,6 +575,7 @@ const API = {
   listInstalledApps,
   listCategories,
   getMcus,
+  getLanguagePackagesForDevice,
   getLatestFirmware,
   getCurrentOSU,
   compatibleMCUForDeviceInfo,

package/src/ble/hooks/useBleDevicePairing.test.ts

@@ -0,0 +1,91 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import { from } from "rxjs";
+import { DeviceModelId } from "@ledgerhq/devices";
+import Transport from "@ledgerhq/hw-transport";
+import { withDevice } from "../../hw/deviceAccess";
+import getVersion from "../../hw/getVersion";
+import { useBleDevicePairing } from "./useBleDevicePairing";
+
+jest.mock("../../hw/deviceAccess");
+jest.mock("../../hw/getVersion");
+jest.mock("@ledgerhq/hw-transport");
+jest.useFakeTimers();
+
+const mockedGetVersion = jest.mocked(getVersion);
+const mockedWithDevice = jest.mocked(withDevice);
+
+mockedWithDevice.mockReturnValue((job) => from(job(new Transport())));
+
+const aFirmwareInfo = {
+  isBootloader: false,
+  rawVersion: "",
+  targetId: 0,
+  mcuVersion: "",
+  flags: Buffer.from([]),
+};
+
+const aDevice = {
+  deviceId: "DEVICE_ID_A",
+  deviceName: "DEVICE_NAME_A",
+  modelId: DeviceModelId.nanoFTS,
+  wired: false,
+};
+
+// FIXME: once we have our own definition of BleError class, this won't be needed
+class BleError extends Error {
+  errorCode: number;
+  constructor(message: string, errorCode: number) {
+    super(message);
+    this.errorCode = errorCode;
+  }
+}
+
+describe("useBleDevicePairing", () => {
+  afterEach(() => {
+    mockedGetVersion.mockClear();
+    jest.clearAllTimers();
+  });
+
+  describe("When the request sent with the BLE transport to the device gets a success response", () => {
+    beforeEach(() => {
+      mockedGetVersion.mockResolvedValue(aFirmwareInfo);
+    });
+
+    it("should inform the hook consumer that the device is paired", async () => {
+      const { result } = renderHook(() =>
+        useBleDevicePairing({
+          deviceId: aDevice.deviceId,
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.isPaired).toBe(true);
+      expect(result.current.pairingError).toBeNull();
+    });
+  });
+
+  describe("When the request sent with the BLE transport is rejected with an error", () => {
+    beforeEach(() => {
+      const bleError = new BleError("An error during pairing", 201);
+      mockedGetVersion.mockRejectedValue(bleError);
+    });
+
+    it("should inform the hook consumer an error occurred", async () => {
+      const { result } = renderHook(() =>
+        useBleDevicePairing({
+          deviceId: aDevice.deviceId,
+        })
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1);
+      });
+
+      expect(result.current.isPaired).toBe(false);
+      expect(result.current.pairingError).not.toBeNull();
+    });
+  });
+});

package/src/ble/hooks/useBleDevicePairing.ts

@@ -0,0 +1,51 @@
+import { useState, useEffect } from "react";
+import { from } from "rxjs";
+import { first } from "rxjs/operators";
+import type { FirmwareInfo } from "@ledgerhq/types-live";
+import { withDevice } from "../../hw/deviceAccess";
+import getVersion from "../../hw/getVersion";
+import { BleError } from "../types";
+
+export type useBleDevicePairingArgs = {
+  deviceId: string;
+};
+
+export type PairingError = BleError | null;
+
+export type useBleDevicePairingResult = {
+  isPaired: boolean;
+  pairingError: PairingError;
+};
+
+/**
+ * Triggers a BLE pairing with a device
+ * @param deviceId A BLE device id
+ * @returns An object containing:
+ * - isPaired: a boolean set to true if the device has been paired, false otherwise
+ * - pairingError: any PairingError that occurred, null otherwise
+ */
+export const useBleDevicePairing = ({
+  deviceId,
+}: useBleDevicePairingArgs): useBleDevicePairingResult => {
+  const [isPaired, setIsPaired] = useState<boolean>(false);
+  const [pairingError, setPairingError] = useState<PairingError>(null);
+
+  useEffect(() => {
+    const requestObservable = withDevice(deviceId)((t) =>
+      from(getVersion(t))
+    ).pipe(first());
+
+    requestObservable.subscribe({
+      next: (_value: FirmwareInfo) => {
+        setIsPaired(true);
+        setPairingError(null);
+      },
+      error: (error: BleError) => {
+        setIsPaired(false);
+        setPairingError(error);
+      },
+    });
+  }, [deviceId]);
+
+  return { isPaired, pairingError };
+};

package/src/ble/hooks/useBleDevicesScanning.test.ts

@@ -0,0 +1,252 @@
+import { renderHook, act } from "@testing-library/react-hooks";
+import type {
+  Observer as TransportObserver,
+  Subscription as TransportSubscription,
+  DescriptorEvent,
+} from "@ledgerhq/hw-transport";
+import { DeviceModelId, getDeviceModel } from "@ledgerhq/devices";
+import { useBleDevicesScanning } from "./useBleDevicesScanning";
+import type { TransportBleDevice } from "../types";
+
+jest.useFakeTimers();
+
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const nanoXServiceUuid = getDeviceModel(DeviceModelId.nanoX).bluetoothSpec![0]
+  .serviceUuid;
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const nanoFTSServiceUuid = getDeviceModel(DeviceModelId.nanoFTS)
+  .bluetoothSpec![0].serviceUuid;
+
+// Fake devices info we would get from the bluetooth transport listen
+const aTransportBleDevice = (overrideProps?: Partial<TransportBleDevice>) => {
+  return {
+    id: "aBleNanoId",
+    name: "aBleNano",
+    localName: null,
+    rssi: 50,
+    mtu: 50,
+    serviceUUIDs: [nanoXServiceUuid],
+    ...overrideProps,
+  };
+};
+
+type bleTransportListenObserver = TransportObserver<
+  DescriptorEvent<TransportBleDevice | null>
+>;
+
+// HOF creating a mocked Transport listen method to be given to useBleDevicesScanning
+const setupMockBleTransportListen =
+  (mockEmitValuesByObserver: (observer: bleTransportListenObserver) => void) =>
+  (observer: bleTransportListenObserver): TransportSubscription => {
+    mockEmitValuesByObserver(observer);
+
+    const unsubscribe = () => {};
+
+    return {
+      unsubscribe,
+    };
+  };
+
+describe("useBleDevicesScanning", () => {
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  describe("When several unique devices are found by the scanner", () => {
+    const deviceIdA = "ID_A";
+    const deviceIdB = "ID_B";
+    const deviceIdC = "ID_C";
+
+    const mockEmitValuesByObserver = (observer: bleTransportListenObserver) => {
+      observer.next({
+        type: "add",
+        descriptor: aTransportBleDevice({ id: deviceIdA }),
+      });
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({
+            id: deviceIdB,
+            serviceUUIDs: [nanoFTSServiceUuid],
+          }),
+        });
+      }, 1000);
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({ id: deviceIdC }),
+        });
+      }, 2000);
+    };
+
+    describe("and when no filters are applied to the scanning", () => {
+      it("should update the list of scanned devices for each new scanned device", async () => {
+        const { result } = renderHook(() =>
+          useBleDevicesScanning({
+            bleTransportListen: setupMockBleTransportListen(
+              mockEmitValuesByObserver
+            ),
+          })
+        );
+
+        expect(result.current.scannedDevices).toHaveLength(1);
+        expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+        // The model was correctly deduced from the ble spec
+        expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+
+        await act(async () => {
+          jest.advanceTimersByTime(1000);
+        });
+
+        expect(result.current.scannedDevices).toHaveLength(2);
+        expect(result.current.scannedDevices[1].deviceId).toBe(deviceIdB);
+        expect(result.current.scannedDevices[1].deviceModel.id).toBe(
+          DeviceModelId.nanoFTS
+        );
+      });
+    });
+
+    describe("and when filterModelIds is not null", () => {
+      it("should filter the scanning result by the given model ids", async () => {
+        const { result } = renderHook(() =>
+          useBleDevicesScanning({
+            bleTransportListen: setupMockBleTransportListen(
+              mockEmitValuesByObserver
+            ),
+            filterByModelIds: [DeviceModelId.nanoX],
+          })
+        );
+
+        // The first scanned device was a nanoX
+        expect(result.current.scannedDevices).toHaveLength(1);
+        expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+        // The model was correctly deduced from the ble spec
+        expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+
+        await act(async () => {
+          jest.advanceTimersByTime(1000);
+        });
+
+        // The second scanned device was a nanoFTS, and was filtered out
+        expect(result.current.scannedDevices).toHaveLength(1);
+
+        await act(async () => {
+          jest.advanceTimersByTime(1000);
+        });
+
+        // The third scanned device was a nanoX
+        expect(result.current.scannedDevices).toHaveLength(2);
+        expect(result.current.scannedDevices[1].deviceId).toBe(deviceIdC);
+        expect(result.current.scannedDevices[1].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+      });
+    });
+
+    describe("and when the hook consumer stops the scanning", () => {
+      it("should stop the scanning", async () => {
+        let stopBleScanning = false;
+
+        const { result, rerender } = renderHook(() =>
+          useBleDevicesScanning({
+            bleTransportListen: setupMockBleTransportListen(
+              mockEmitValuesByObserver
+            ),
+            stopBleScanning,
+          })
+        );
+
+        // At first the scanning finds device(s)
+        expect(result.current.scannedDevices).toHaveLength(1);
+        expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+        expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+          DeviceModelId.nanoX
+        );
+
+        // Then the consumer stops the scanning
+        stopBleScanning = true;
+        rerender({
+          bleTransportListen: setupMockBleTransportListen(
+            mockEmitValuesByObserver
+          ),
+          stopBleScanning,
+        });
+
+        await act(async () => {
+          jest.advanceTimersByTime(2000);
+        });
+
+        // It should not find any new devices
+        expect(result.current.scannedDevices).toHaveLength(1);
+      });
+    });
+  });
+
+  describe("When the same device is being scanned several times", () => {
+    const deviceIdA = "ID_A";
+    const deviceIdB = "ID_B";
+
+    const mockEmitValuesByObserver = (observer: bleTransportListenObserver) => {
+      observer.next({
+        type: "add",
+        descriptor: aTransportBleDevice({ id: deviceIdA }),
+      });
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({ id: deviceIdA }),
+        });
+      }, 1000);
+
+      setTimeout(() => {
+        observer.next({
+          type: "add",
+          descriptor: aTransportBleDevice({ id: deviceIdB }),
+        });
+      }, 2000);
+    };
+
+    it("should update the list of scanned devices without any duplicate", async () => {
+      const { result } = renderHook(() =>
+        useBleDevicesScanning({
+          bleTransportListen: setupMockBleTransportListen(
+            mockEmitValuesByObserver
+          ),
+        })
+      );
+
+      // The first time it gets the device from the scanning
+      expect(result.current.scannedDevices).toHaveLength(1);
+      expect(result.current.scannedDevices[0].deviceId).toBe(deviceIdA);
+      expect(result.current.scannedDevices[0].deviceModel.id).toBe(
+        DeviceModelId.nanoX
+      );
+
+      await act(async () => {
+        jest.advanceTimersByTime(1000);
+      });
+
+      // The second time it gets the same device from the scanning
+      // It should not have been added to the list
+      expect(result.current.scannedDevices).toHaveLength(1);
+
+      await act(async () => {
+        jest.advanceTimersByTime(1000);
+      });
+
+      // The third time it gets a new device
+      expect(result.current.scannedDevices).toHaveLength(2);
+      expect(result.current.scannedDevices[1].deviceId).toBe(deviceIdB);
+      expect(result.current.scannedDevices[1].deviceModel.id).toBe(
+        DeviceModelId.nanoX
+      );
+    });
+  });
+});