@ledgerhq/device-core 0.1.1-nightly.0

package/src/managerApi/repositories/HttpManagerApiRepository.ts

@@ -0,0 +1,284 @@
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
+import network from "@ledgerhq/live-network/network";
+import { FirmwareNotRecognized, NetworkDown } from "@ledgerhq/errors";
+import { getUserHashes } from "../use-cases/getUserHashes";
+import URL from "url";
+import { ManagerApiRepository } from "./ManagerApiRepository";
+import { FinalFirmware, OsuFirmware } from "../entities/FirmwareUpdateContextEntity";
+import { DeviceVersionEntity } from "../entities/DeviceVersionEntity";
+import { ApplicationV2Entity } from "../entities/AppEntity";
+import { DeviceInfoEntity } from "../entities/DeviceInfoEntity";
+import {
+  LanguagePackageEntity,
+  LanguagePackageResponseEntity,
+} from "../entities/LanguagePackageEntity";
+import { getProviderIdUseCase } from "../use-cases/getProviderIdUseCase";
+
+export class HttpManagerApiRepository implements ManagerApiRepository {
+  private readonly managerApiBase: string;
+  private readonly liveCommonVersion: string;
+
+  constructor(managerApiBase: string, liveCommonVersion: string) {
+    this.managerApiBase = managerApiBase;
+    this.liveCommonVersion = liveCommonVersion;
+  }
+
+  // NB: we are explicitly specifying the type because TypeScript cannot infer
+  // properly the return type of `makeLRUCache` without using `any` for the
+  // parameters.
+  readonly fetchLatestFirmware: ManagerApiRepository["fetchLatestFirmware"] = makeLRUCache(
+    async ({ current_se_firmware_final_version, device_version, providerId, userId }) => {
+      const salt = getUserHashes(userId).firmwareSalt;
+      const {
+        data,
+      }: {
+        data: {
+          result: string;
+          se_firmware_osu_version: OsuFirmware;
+        };
+      } = await network({
+        method: "POST",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/get_latest_firmware`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+            salt,
+          },
+        }),
+        data: {
+          current_se_firmware_final_version,
+          device_version,
+          provider: providerId,
+        },
+      });
+
+      if (data.result === "null") {
+        return null;
+      }
+
+      return data.se_firmware_osu_version;
+    },
+    a => `${a.current_se_firmware_final_version}_${a.device_version}_${a.providerId}`,
+  );
+
+  readonly fetchMcus: ManagerApiRepository["fetchMcus"] = makeLRUCache(
+    async () => {
+      const { data } = await network({
+        method: "GET",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/mcu_versions`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+          },
+        }),
+      });
+      return data;
+    },
+    () => "",
+  );
+
+  readonly getDeviceVersion: ManagerApiRepository["getDeviceVersion"] = makeLRUCache(
+    async ({ targetId, providerId }) => {
+      const {
+        data,
+      }: {
+        data: DeviceVersionEntity;
+      } = await network({
+        method: "POST",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/get_device_version`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+          },
+        }),
+        data: {
+          provider: providerId,
+          target_id: targetId,
+        },
+      }).catch(error => {
+        const status = error?.status || error?.response?.status;
+
+        if (status === 404)
+          throw new FirmwareNotRecognized("manager api did not recognize targetId=" + targetId, {
+            targetId,
+          });
+
+        throw error;
+      });
+      return data;
+    },
+    ({ targetId, providerId }) => `${targetId}_${providerId}`,
+  );
+
+  readonly getCurrentOSU: ManagerApiRepository["getCurrentOSU"] = makeLRUCache(
+    async input => {
+      const { data } = await network({
+        method: "POST",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/get_osu_version`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+          },
+        }),
+        data: {
+          device_version: input.deviceId,
+          version_name: `${input.version}-osu`,
+          provider: input.providerId,
+        },
+      });
+      return data;
+    },
+    a => `${a.version}_${a.deviceId}_${a.providerId}`,
+  );
+
+  readonly getCurrentFirmware: ManagerApiRepository["getCurrentFirmware"] = makeLRUCache(
+    async input => {
+      const {
+        data,
+      }: {
+        data: FinalFirmware;
+      } = await network({
+        method: "POST",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/get_firmware_version`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+          },
+        }),
+        data: {
+          device_version: input.deviceId,
+          version_name: input.version,
+          provider: input.providerId,
+        },
+      }).catch(error => {
+        const status = error?.status || error?.response?.status;
+
+        if (status === 404) throw new FirmwareNotRecognized();
+
+        throw error;
+      });
+      return data;
+    },
+    a => `${a.version}_${a.deviceId}_${a.providerId}`,
+  );
+
+  readonly getFinalFirmwareById: ManagerApiRepository["getFinalFirmwareById"] = makeLRUCache(
+    async id => {
+      const {
+        data,
+      }: {
+        data: FinalFirmware;
+      } = await network({
+        method: "GET",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/firmware_final_versions/${id}`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+          },
+        }),
+      });
+      return data;
+    },
+    id => String(id),
+  );
+
+  readonly getAppsByHash: ManagerApiRepository["getAppsByHash"] = makeLRUCache(
+    async hashes => {
+      const {
+        data,
+      }: {
+        data: Array<ApplicationV2Entity | null>;
+      } = await network({
+        method: "POST",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/v2/apps/hash`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+          },
+        }),
+        data: hashes,
+      });
+
+      if (!data || !Array.isArray(data)) {
+        throw new NetworkDown("");
+      }
+
+      return data;
+    },
+    hashes => `${this.managerApiBase}_${hashes.join("-")}`,
+  );
+
+  readonly catalogForDevice: ManagerApiRepository["catalogForDevice"] = makeLRUCache(
+    async params => {
+      const { provider, targetId, firmwareVersion } = params;
+      const {
+        data,
+      }: {
+        data: Array<ApplicationV2Entity>;
+      } = await network({
+        method: "GET",
+        url: URL.format({
+          pathname: `${this.managerApiBase}/v2/apps/by-target`,
+          query: {
+            livecommonversion: this.liveCommonVersion,
+            provider,
+            target_id: targetId,
+            firmware_version_name: firmwareVersion,
+          },
+        }),
+      });
+
+      if (!data || !Array.isArray(data)) {
+        throw new NetworkDown("");
+      }
+
+      return data;
+    },
+    a => `${this.managerApiBase}_${a.provider}_${a.targetId}_${a.firmwareVersion}`,
+  );
+
+  readonly getLanguagePackagesForDevice = async (
+    deviceInfo: DeviceInfoEntity,
+    forceProvider?: number,
+  ) => {
+    const deviceVersion = await this.getDeviceVersion({
+      targetId: deviceInfo.targetId,
+      providerId: getProviderIdUseCase({ deviceInfo, forceProvider }),
+    });
+
+    const seFirmwareVersion = await this.getCurrentFirmware({
+      version: deviceInfo.version,
+      deviceId: deviceVersion.id,
+      providerId: getProviderIdUseCase({ deviceInfo, forceProvider }),
+    });
+
+    const { data }: { data: LanguagePackageResponseEntity[] } = await network({
+      method: "GET",
+      url: URL.format({
+        pathname: `${this.managerApiBase}/language-package`,
+        query: {
+          livecommonversion: this.liveCommonVersion,
+        },
+      }),
+    });
+
+    const allPackages: LanguagePackageEntity[] = data.reduce(
+      (acc, response) => [
+        ...acc,
+        ...response.language_package_version.map(p => ({
+          ...p,
+          language: response.language,
+        })),
+      ],
+      [] as LanguagePackageEntity[],
+    );
+
+    const packages = allPackages.filter(
+      pack =>
+        pack.device_versions.includes(deviceVersion.id) &&
+        pack.se_firmware_final_versions.includes(seFirmwareVersion.id),
+    );
+
+    return packages;
+  };
+}

package/src/managerApi/repositories/ManagerApiRepository.ts

@@ -0,0 +1,68 @@
+import { McuVersion } from "@ledgerhq/types-live";
+import { ApplicationV2Entity } from "../entities/AppEntity";
+import { DeviceInfoEntity } from "../entities/DeviceInfoEntity";
+import { DeviceVersionEntity } from "../entities/DeviceVersionEntity";
+import { FinalFirmware, OsuFirmware } from "../entities/FirmwareUpdateContextEntity";
+import { Id } from "../entities/Id";
+import { LanguagePackageEntity } from "../entities/LanguagePackageEntity";
+
+export interface ManagerApiRepository {
+  fetchLatestFirmware(params: {
+    current_se_firmware_final_version: Id;
+    device_version: Id;
+    providerId: number;
+    userId: string;
+  }): Promise<OsuFirmware | null | undefined>;
+
+  fetchMcus(): Promise<McuVersion[]>;
+
+  getDeviceVersion({
+    targetId,
+    providerId,
+  }: {
+    targetId: string | number;
+    providerId: number;
+  }): Promise<DeviceVersionEntity>;
+
+  getCurrentOSU(params: {
+    deviceId: string | number;
+    providerId: string | number;
+    version: string;
+  }): Promise<OsuFirmware>;
+
+  getCurrentFirmware(params: {
+    version: string;
+    deviceId: string | number;
+    providerId: number;
+  }): Promise<FinalFirmware>;
+
+  getFinalFirmwareById(id: number): Promise<FinalFirmware>;
+
+  /**
+   * Resolve applications details by hashes.
+   * Order of outputs matches order of inputs.
+   * If an application version is not found, a null is returned instead.
+   * If several versions match the same hash, only the latest one is returned.
+   *
+   * Given an array of hashes that we can obtain by either listInstalledApps in this same
+   * API (a websocket connection to a scriptrunner) or via direct apdus using hw/listApps.ts
+   * retrieve all the information needed from the backend for those applications.
+   */
+  getAppsByHash(hashes: string[]): Promise<Array<ApplicationV2Entity | null>>;
+
+  /**
+   * Return a list of App that are available for a given firmware version on a provider.
+   * Prevents the call to ManagerAPI.listApps which includes all versions of all apps and
+   * was causing slower access to the manager.
+   */
+  catalogForDevice: (params: {
+    provider: number;
+    targetId: number | string;
+    firmwareVersion: string;
+  }) => Promise<Array<ApplicationV2Entity>>;
+
+  getLanguagePackagesForDevice: (
+    deviceInfo: DeviceInfoEntity,
+    forceProvider?: number,
+  ) => Promise<LanguagePackageEntity[]>;
+}

package/src/managerApi/repositories/StubManagerApiRepository.ts

@@ -0,0 +1,49 @@
+import { DeviceVersionEntity } from "../entities/DeviceVersionEntity";
+import { FinalFirmware, OsuFirmware } from "../entities/FirmwareUpdateContextEntity";
+import { aDeviceVersionBuilder } from "../entities/mocks/aDeviceVersion";
+import { aFinalFirmwareBuilder } from "../entities/mocks/aFinalFirmware";
+import { aOsuFirmwareBuilder } from "../entities/mocks/aOsuFirmware";
+import { ManagerApiRepository } from "./ManagerApiRepository";
+
+export class StubManagerApiRepository implements ManagerApiRepository {
+  readonly fetchLatestFirmware = () => {
+    const result: OsuFirmware = aOsuFirmwareBuilder();
+    return Promise.resolve(result);
+  };
+
+  readonly fetchMcus = () => {
+    return Promise.resolve([]);
+  };
+
+  readonly getDeviceVersion = () => {
+    const result: DeviceVersionEntity = aDeviceVersionBuilder();
+    return Promise.resolve(result);
+  };
+
+  readonly getCurrentOSU = () => {
+    const result: OsuFirmware = aOsuFirmwareBuilder();
+    return Promise.resolve(result);
+  };
+
+  readonly getCurrentFirmware = () => {
+    const result: FinalFirmware = aFinalFirmwareBuilder();
+    return Promise.resolve(result);
+  };
+
+  readonly getFinalFirmwareById = () => {
+    const result: FinalFirmware = aFinalFirmwareBuilder();
+    return Promise.resolve(result);
+  };
+
+  readonly getAppsByHash = () => {
+    return Promise.resolve([]);
+  };
+
+  readonly catalogForDevice = () => {
+    return Promise.resolve([]);
+  };
+
+  readonly getLanguagePackagesForDevice = () => {
+    return Promise.resolve([]);
+  };
+}

package/src/managerApi/use-cases/fetchMcus.ts

@@ -0,0 +1,5 @@
+import { ManagerApiRepository } from "../repositories/ManagerApiRepository";
+
+export function fetchMcus(managerApiRepository: ManagerApiRepository) {
+  return managerApiRepository.fetchMcus();
+}

package/src/managerApi/use-cases/getLatestFirmwareForDevice.test.ts

@@ -0,0 +1,196 @@
+import { getLatestFirmwareForDevice } from "./getLatestFirmwareForDevice";
+import { ManagerApiRepository } from "../repositories/ManagerApiRepository";
+import { DeviceVersion, FinalFirmware, McuVersion, OsuFirmware } from "@ledgerhq/types-live";
+import { UnknownMCU } from "@ledgerhq/errors";
+import { StubManagerApiRepository } from "../repositories/StubManagerApiRepository";
+import { aDeviceInfoBuilder } from "../entities/mocks/aDeviceInfo";
+
+jest.mock("../repositories/ManagerApiRepository");
+
+describe("getLatestFirmwareForDevice", () => {
+  let mockedManagerApiRepository: ManagerApiRepository;
+
+  beforeEach(() => {
+    // Clear the methods we are using in our test
+    jest.resetAllMocks();
+    mockedManagerApiRepository = new StubManagerApiRepository();
+  });
+
+  it("throws an Error for unknown mcu", async () => {
+    // given
+    // Using a fixture builder - we could create that for all our entities
+    const deviceInfo = aDeviceInfoBuilder({ mcuVersion: "42", isOSU: true });
+
+    jest.spyOn(mockedManagerApiRepository, "fetchMcus").mockResolvedValue([]);
+    jest
+      .spyOn(mockedManagerApiRepository, "getDeviceVersion")
+      .mockResolvedValue({ id: 42 } as DeviceVersion);
+    jest.spyOn(mockedManagerApiRepository, "getCurrentOSU").mockResolvedValue({} as OsuFirmware);
+
+    const params = {
+      deviceInfo,
+      providerId: 42,
+      userId: "",
+      managerApiRepository: mockedManagerApiRepository,
+    };
+
+    // when
+    const response = getLatestFirmwareForDevice(params);
+    // then
+    expect(response).rejects.toBeInstanceOf(UnknownMCU);
+  });
+
+  it("should return an update without flashing mcu", async () => {
+    // Given
+    const deviceInfo = aDeviceInfoBuilder({ isOSU: false, mcuVersion: "42" });
+
+    jest
+      .spyOn(mockedManagerApiRepository, "getDeviceVersion")
+      .mockResolvedValue({ id: 42 } as DeviceVersion);
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchMcus")
+      .mockResolvedValue(Promise.resolve([{ name: "42", id: 42 } as McuVersion]));
+    jest
+      .spyOn(mockedManagerApiRepository, "getCurrentFirmware")
+      .mockResolvedValue({ se_firmware: 21 } as FinalFirmware);
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchLatestFirmware")
+      .mockResolvedValue({} as OsuFirmware);
+    jest
+      .spyOn(mockedManagerApiRepository, "getFinalFirmwareById")
+      .mockResolvedValue({ mcu_versions: [42] } as FinalFirmware);
+
+    const params = {
+      deviceInfo,
+      providerId: 42,
+      userId: "",
+      managerApiRepository: mockedManagerApiRepository,
+    };
+
+    // When
+    const result = await getLatestFirmwareForDevice(params);
+
+    // Then
+    expect(result).toMatchObject({ shouldFlashMCU: false });
+  });
+
+  it("shouldn't return an available update when no mcu found", async () => {
+    // Given
+    const deviceInfo = aDeviceInfoBuilder({ isOSU: false, mcuVersion: "42" });
+
+    jest
+      .spyOn(mockedManagerApiRepository, "getDeviceVersion")
+      .mockResolvedValue({ id: 42 } as DeviceVersion);
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchMcus")
+      .mockResolvedValue(Promise.resolve([{ name: "42", id: 42 } as McuVersion]));
+    jest
+      .spyOn(mockedManagerApiRepository, "getCurrentFirmware")
+      .mockResolvedValue({ id: 21 } as FinalFirmware);
+    jest.spyOn(mockedManagerApiRepository, "fetchLatestFirmware").mockResolvedValue(null);
+
+    const params = {
+      deviceInfo,
+      providerId: 42,
+      userId: "",
+      managerApiRepository: mockedManagerApiRepository,
+    };
+
+    // When
+    const result = await getLatestFirmwareForDevice(params);
+
+    // Then
+    expect(result).toBeNull();
+  });
+
+  it("should return an available OS update", async () => {
+    // Given
+    const deviceInfo = aDeviceInfoBuilder({ isOSU: false, mcuVersion: "42" });
+
+    jest
+      .spyOn(mockedManagerApiRepository, "getDeviceVersion")
+      .mockResolvedValue({ id: 42 } as DeviceVersion);
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchMcus")
+      .mockResolvedValue(Promise.resolve([{ name: "42", id: 42 } as McuVersion]));
+    jest
+      .spyOn(mockedManagerApiRepository, "getCurrentFirmware")
+      .mockResolvedValue({ se_firmware: 21 } as FinalFirmware);
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchLatestFirmware")
+      .mockResolvedValue({} as OsuFirmware);
+    jest.spyOn(mockedManagerApiRepository, "getFinalFirmwareById").mockResolvedValue({
+      name: "VERSION_UPDATE_TEST",
+      mcu_versions: [42],
+    } as FinalFirmware);
+
+    const params = {
+      deviceInfo,
+      providerId: 42,
+      userId: "",
+      managerApiRepository: mockedManagerApiRepository,
+    };
+
+    // When
+    const result = await getLatestFirmwareForDevice(params);
+
+    // Then
+    expect(result).toHaveProperty(["final"]);
+    expect(result).toHaveProperty(["osu"]);
+    expect(result).toHaveProperty(["shouldFlashMCU"]);
+  });
+
+  test("should return an update with device isOSU true", async () => {
+    const deviceInfo = aDeviceInfoBuilder({ mcuVersion: "42" });
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchMcus")
+      .mockResolvedValue(Promise.resolve([{ name: "42", id: 42 } as McuVersion]));
+    jest
+      .spyOn(mockedManagerApiRepository, "getDeviceVersion")
+      .mockResolvedValue({ id: 42 } as DeviceVersion);
+    jest.spyOn(mockedManagerApiRepository, "getCurrentOSU").mockResolvedValue({} as OsuFirmware);
+    jest.spyOn(mockedManagerApiRepository, "getFinalFirmwareById").mockResolvedValue({
+      name: "VERSION_UPDATE_TEST",
+      mcu_versions: [42],
+    } as FinalFirmware);
+    const params = {
+      deviceInfo,
+      providerId: 42,
+      userId: "",
+      managerApiRepository: mockedManagerApiRepository,
+    };
+
+    // When
+    const result = await getLatestFirmwareForDevice(params);
+
+    // Then
+    expect(result).toHaveProperty(["final"]);
+    expect(result).toHaveProperty(["osu"]);
+    expect(result).toHaveProperty(["shouldFlashMCU"]);
+  });
+
+  test("shouldn't return an update with device isOSU true", async () => {
+    const deviceInfo = aDeviceInfoBuilder({ mcuVersion: "42" });
+    jest
+      .spyOn(mockedManagerApiRepository, "fetchMcus")
+      .mockResolvedValue(Promise.resolve([{ name: "42", id: 42 } as McuVersion]));
+    jest
+      .spyOn(mockedManagerApiRepository, "getDeviceVersion")
+      .mockResolvedValue({ id: 42 } as DeviceVersion);
+    jest
+      .spyOn(mockedManagerApiRepository, "getCurrentOSU")
+      .mockResolvedValue(null as unknown as OsuFirmware);
+    const params = {
+      deviceInfo,
+      providerId: 42,
+      userId: "",
+      managerApiRepository: mockedManagerApiRepository,
+    };
+
+    // When
+    const result = await getLatestFirmwareForDevice(params);
+
+    // Then
+    expect(result).toBeNull();
+  });
+});

package/src/managerApi/use-cases/getLatestFirmwareForDevice.ts

@@ -0,0 +1,66 @@
+import { UnknownMCU } from "@ledgerhq/errors";
+import { DeviceInfoEntity } from "../entities/DeviceInfoEntity";
+import { FirmwareUpdateContextEntity } from "../entities/FirmwareUpdateContextEntity";
+import { ManagerApiRepository } from "../repositories/ManagerApiRepository";
+
+type GetLatestFirmwareForDeviceParams = {
+  deviceInfo: DeviceInfoEntity;
+  providerId: number;
+  userId: string;
+  managerApiRepository: ManagerApiRepository;
+};
+
+export async function getLatestFirmwareForDevice({
+  deviceInfo,
+  providerId,
+  userId,
+  managerApiRepository,
+}: GetLatestFirmwareForDeviceParams): Promise<FirmwareUpdateContextEntity | null> {
+  const mcusPromise = managerApiRepository.fetchMcus();
+
+  // Gets device infos from targetId
+  const deviceVersion = await managerApiRepository.getDeviceVersion({
+    targetId: deviceInfo.targetId,
+    providerId,
+  });
+  let osu;
+
+  if (deviceInfo.isOSU) {
+    osu = await managerApiRepository.getCurrentOSU({
+      deviceId: deviceVersion.id,
+      providerId,
+      version: deviceInfo.version,
+    });
+  } else {
+    // Gets firmware infos with firmware name and device version
+    const seFirmwareVersion = await managerApiRepository.getCurrentFirmware({
+      version: deviceInfo.version,
+      deviceId: deviceVersion.id,
+      providerId,
+    });
+    // Fetches next possible firmware
+    osu = await managerApiRepository.fetchLatestFirmware({
+      current_se_firmware_final_version: seFirmwareVersion.id,
+      device_version: deviceVersion.id,
+      userId,
+      providerId,
+    });
+  }
+
+  if (!osu) {
+    return null;
+  }
+
+  const mcus = await mcusPromise;
+  const currentMcuVersion = mcus.find(mcu => mcu.name === deviceInfo.mcuVersion);
+
+  if (!currentMcuVersion) throw new UnknownMCU();
+
+  const final = await managerApiRepository.getFinalFirmwareById(osu.next_se_firmware_final_version);
+  const shouldFlashMCU = !final.mcu_versions.includes(currentMcuVersion.id);
+  return {
+    final,
+    osu,
+    shouldFlashMCU,
+  };
+}

package/src/managerApi/use-cases/getProviderIdUseCase.ts

@@ -0,0 +1,24 @@
+import { DeviceInfoEntity } from "../entities/DeviceInfoEntity";
+
+export const PROVIDERS: Record<string, number> = {
+  default: 1,
+  das: 2,
+  club: 3,
+  shitcoins: 4,
+  ee: 5,
+};
+
+export function getProviderIdUseCase({
+  deviceInfo,
+  forceProvider,
+}: {
+  deviceInfo: DeviceInfoEntity | undefined | null;
+  forceProvider?: number;
+}): number {
+  if (forceProvider && forceProvider !== PROVIDERS.default) return forceProvider;
+  if (!deviceInfo) return PROVIDERS.default;
+  const { providerName } = deviceInfo;
+  const maybeProvider = providerName && PROVIDERS[providerName];
+  if (maybeProvider) return maybeProvider;
+  return 1;
+}