@ledgerhq/device-core 0.1.1-next.0

package/src/commands/use-cases/isDeviceLocalizationSupported.test.ts

@@ -0,0 +1,48 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { isDeviceLocalizationSupported } from "./isDeviceLocalizationSupported";
+const { nanoS, nanoSP, nanoX, stax } = DeviceModelId;
+
+test("isDeviceLocalizationSupported", () => {
+  /**
+   * Nano X
+   * */
+  expect(isDeviceLocalizationSupported("2.0.0", nanoX)).toBe(false);
+  expect(isDeviceLocalizationSupported("2.0.0-whatever0", nanoX)).toBe(false);
+
+  expect(isDeviceLocalizationSupported("2.1.0", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.1.0-rc1", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.1.1", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.1.1-whatever0", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.2.0", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.2.0-whatever0", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("3.0.0", nanoX)).toBe(true);
+  expect(isDeviceLocalizationSupported("3.0.0-whatever0", nanoX)).toBe(true);
+
+  /**
+   * Nano SP
+   * */
+  expect(isDeviceLocalizationSupported("1.0.0", nanoSP)).toBe(false);
+  expect(isDeviceLocalizationSupported("1.0.0-whatever", nanoSP)).toBe(false);
+
+  expect(isDeviceLocalizationSupported("1.1.0", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("1.1.0-rc1", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("1.1.2", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("1.1.2-whatever0", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("1.2.0", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("1.2.0-whatever0", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.0.0", nanoSP)).toBe(true);
+  expect(isDeviceLocalizationSupported("2.0.0-whatever0", nanoSP)).toBe(true);
+
+  /**
+   * Stax
+   * */
+  expect(isDeviceLocalizationSupported("0.9.0", stax)).toBe(false);
+  expect(isDeviceLocalizationSupported("9.0.0", stax)).toBe(true);
+  expect(isDeviceLocalizationSupported("9.0.0-whatever", stax)).toBe(true);
+
+  /**
+   * NanoS
+   * */
+  expect(isDeviceLocalizationSupported("9.0.0", nanoS)).toBe(false);
+  expect(isDeviceLocalizationSupported("9.0.0-whatever", nanoS)).toBe(false);
+});

package/src/commands/use-cases/isDeviceLocalizationSupported.ts

@@ -0,0 +1,20 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { satisfies as versionSatisfies, coerce as semverCoerce } from "semver";
+
+const deviceVersionRangesForLocalization: { [key in DeviceModelId]?: string } = {
+  nanoX: ">=2.1.0",
+  nanoSP: ">=1.1.0",
+  stax: ">=1.0.0",
+  europa: ">=1.0.0",
+};
+
+export const isDeviceLocalizationSupported = (
+  seVersion: string,
+  modelId?: DeviceModelId,
+): boolean =>
+  !!modelId &&
+  !!deviceVersionRangesForLocalization[modelId] &&
+  !!versionSatisfies(
+    semverCoerce(seVersion) || seVersion,
+    deviceVersionRangesForLocalization[modelId] as string,
+  );

package/src/commands/use-cases/isHardwareVersionSupported.test.ts

@@ -0,0 +1,39 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { isHardwareVersionSupported } from "./isHardwareVersionSupported";
+
+const { nanoS, nanoSP, nanoX, stax } = DeviceModelId;
+
+test("isHardwareVersionSupported", () => {
+  /**
+   * Nano S
+   * */
+  expect(isHardwareVersionSupported("2.0.0", nanoS)).toBe(false);
+  expect(isHardwareVersionSupported("2.0.0-whatever0", nanoS)).toBe(false);
+
+  /**
+   * Nano X
+   * */
+  expect(isHardwareVersionSupported("1.9.0", nanoX)).toBe(false);
+  expect(isHardwareVersionSupported("1.9.0-whatever0", nanoX)).toBe(false);
+
+  expect(isHardwareVersionSupported("2.0.0", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("2.0.0-rc1", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("2.0.1", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("2.0.1-whatever0", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("2.1.0", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("2.1.0-whatever0", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("3.0.0", nanoX)).toBe(true);
+  expect(isHardwareVersionSupported("3.0.0-whatever0", nanoX)).toBe(true);
+
+  /**
+   * Nano SP
+   * */
+  expect(isHardwareVersionSupported("2.0.0", nanoSP)).toBe(false);
+  expect(isHardwareVersionSupported("2.0.0-whatever0", nanoSP)).toBe(false);
+
+  /**
+   * Stax
+   * */
+  expect(isHardwareVersionSupported("2.0.0", stax)).toBe(false);
+  expect(isHardwareVersionSupported("2.0.0-whatever0", stax)).toBe(false);
+});

package/src/commands/use-cases/isHardwareVersionSupported.ts

@@ -0,0 +1,20 @@
+import { satisfies as versionSatisfies, coerce as semverCoerce } from "semver";
+import { DeviceModelId } from "@ledgerhq/devices";
+
+const deviceVersionRangesForHardwareVersion: {
+  [key in DeviceModelId]?: string;
+} = {
+  nanoX: ">=2.0.0",
+};
+/**
+ * @returns whether the Hardware Version bytes are included in the result of the
+ * getVersion APDU
+ * */
+
+export const isHardwareVersionSupported = (seVersion: string, modelId?: DeviceModelId): boolean =>
+  !!modelId &&
+  !!deviceVersionRangesForHardwareVersion[modelId] &&
+  !!versionSatisfies(
+    semverCoerce(seVersion) || seVersion,
+    deviceVersionRangesForHardwareVersion[modelId] as string,
+  );

package/src/commands/use-cases/parseGetDeviceNameResponse.test.ts

@@ -0,0 +1,35 @@
+import { parseGetDeviceNameResponse } from "./parseGetDeviceNameResponse";
+
+describe("getDeviceName", () => {
+  it("should return name if available", () => {
+    const responseBuffer = Buffer.from("50756572746f9000", "hex");
+
+    const result = parseGetDeviceNameResponse(responseBuffer);
+
+    expect(result).toMatch("Puerto"); // 🐾
+  });
+
+  it("should return empty name when the device is not onboarded", () => {
+    const responseBuffer = Buffer.from("bababababababa6d07", "hex");
+
+    const result = parseGetDeviceNameResponse(responseBuffer);
+
+    expect(result).toMatch("");
+  });
+
+  it("should return empty name when the device is not onboarded #2", () => {
+    const responseBuffer = Buffer.from("bababababababa6611", "hex");
+
+    const result = parseGetDeviceNameResponse(responseBuffer);
+
+    expect(result).toMatch("");
+  });
+
+  it("should throw for an unexpected bootloader or any other code", () => {
+    const responseBuffer = Buffer.from("662d", "hex");
+
+    expect(() => {
+      parseGetDeviceNameResponse(responseBuffer);
+    }).toThrow(Error);
+  });
+});

package/src/commands/use-cases/parseGetDeviceNameResponse.ts

@@ -0,0 +1,20 @@
+import { StatusCodes, TransportStatusError } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+
+export function parseGetDeviceNameResponse(response: Buffer): string {
+  const tracer = new LocalTracer("hw", {
+    function: "parseGetDeviceNameResponse",
+  });
+  const status = response.readUInt16BE(response.length - 2);
+  if (tracer) tracer.trace("Result status from 0xe0d20000", { status });
+
+  switch (status) {
+    case StatusCodes.OK:
+      return response.slice(0, response.length - 2).toString("utf-8");
+    case StatusCodes.DEVICE_NOT_ONBOARDED:
+    case StatusCodes.DEVICE_NOT_ONBOARDED_2:
+      return "";
+  }
+
+  throw new TransportStatusError(status);
+}

package/src/commands/use-cases/parseGetVersionResponse.test.ts

@@ -0,0 +1,123 @@
+import { parseGetVersionResponse } from "./parseGetVersionResponse";
+
+describe("parseGetVersionResult", () => {
+  it("correctly parses an arbitrary regular result buffer", () => {
+    const responseBuffer = Buffer.from(
+      [
+        "33000004", //   targetId
+        "05", //         device version length
+        "322e322e33", // device version aka `rawVersion`
+        "04", //         flags length
+        "ee000000", //   flags
+        "04", //         mcu version length
+        "322e3330", //   mcu version aka `mcuVersion`
+        "04", //         booloader version length
+        "312e3136", //   bootloader version aka `bootloaderVersion`
+        "01", //         hw version length
+        "01", //         hw version aka `hardwareVersion`
+        "01", //         language id length
+        "00", //         language id
+        "01", // ?
+        "00", // ?
+        "9000", //       status
+      ].join(""),
+      "hex",
+    );
+
+    const expectedParseResult = {
+      isBootloader: false,
+      rawVersion: "2.2.3",
+      targetId: 855638020,
+      seVersion: "2.2.3",
+      mcuVersion: "2.30",
+      mcuBlVersion: undefined,
+      mcuTargetId: undefined,
+      seTargetId: 855638020,
+      flags: Buffer.from([238, 0, 0, 0]),
+      bootloaderVersion: "1.16",
+      hardwareVersion: 1,
+      languageId: 0,
+    };
+
+    const parseResult = parseGetVersionResponse(responseBuffer);
+
+    expect(parseResult).toEqual(expectedParseResult);
+  });
+
+  it("should handle old firmware with zero rawVersionLength", () => {
+    const responseBuffer = Buffer.from(
+      [
+        "33000004", //   targetId
+        "00", //         device version length
+        "04", //         flags length
+        "ee000000", //   flags
+        "04", //         mcu version length
+        "322e3330", //   mcu version aka `mcuVersion`
+        "01", //         hw version length
+        "01", //         hw version aka `hardwareVersion`
+        "01", //         language id length
+        "00", //         language id
+        "01", // ?
+        "00", // ?
+        "9000", //       status
+      ].join(""),
+      "hex",
+    );
+
+    const expectedParseResult = {
+      isBootloader: false,
+      rawVersion: "0.0.0", // Defaults to "0.0.0" for old firmware
+      targetId: 855638020,
+      seVersion: "0.0.0",
+      mcuVersion: "2.30",
+      mcuBlVersion: undefined,
+      mcuTargetId: undefined,
+      seTargetId: 855638020,
+      flags: Buffer.from([]), // Expected to be an empty buffer
+      bootloaderVersion: undefined, // because seVersion is "0.0.0" so isBootloaderVersionSupported will return false
+      hardwareVersion: undefined, // because seVersion is "0.0.0" so isDeviceVersionSupported will return false
+      languageId: undefined, // because seVersion is "0.0.0" so isDeviceLocalizationSupported will return false
+    };
+
+    const parseResult = parseGetVersionResponse(responseBuffer);
+
+    expect(parseResult).toEqual(expectedParseResult);
+  });
+
+  it("correctly parses buffer for a bootloader version", () => {
+    const responseBuffer = Buffer.from(
+      [
+        "05010003", //  targetId, also mcuTargetId
+        "04", //        rawVersion length
+        "312e3136", //  rawVersion, also mcuBlVersion
+        "04", //        flags length
+        "f4d8aa43", //  flags
+        "05", //        seVersion length
+        "322e322e33", //seVersion
+        "04", //        seTargetId length
+        "33000004", //  seTargetId
+        "9000", //      status
+      ].join(""),
+      "hex",
+    );
+
+    const expectedParseResult = {
+      isBootloader: true,
+      rawVersion: "1.16",
+      targetId: 83951619,
+      seVersion: "2.2.3",
+      mcuVersion: "",
+      mcuBlVersion: "1.16",
+      mcuTargetId: 83951619,
+      seTargetId: 855638020,
+      flags: Buffer.from([244, 216, 170, 67]),
+      bootloaderVersion: undefined,
+      hardwareVersion: undefined,
+      languageId: undefined,
+    };
+
+    const parseResult = parseGetVersionResponse(responseBuffer);
+
+    expect(parseResult).toEqual(expectedParseResult);
+  });
+});

package/src/commands/use-cases/parseGetVersionResponse.ts

@@ -0,0 +1,121 @@
+import { identifyTargetId } from "@ledgerhq/devices";
+import { FirmwareInfoEntity } from "../entities/FirmwareInfoEntity";
+import { isDeviceLocalizationSupported } from "./isDeviceLocalizationSupported";
+import { isHardwareVersionSupported } from "./isHardwareVersionSupported";
+import { isBootloaderVersionSupported } from "./isBootloaderVersionSupported";
+
+export function parseGetVersionResponse(response: Buffer): FirmwareInfoEntity {
+  const data = response.slice(0, response.length - 2);
+  let i = 0;
+
+  // parse the target id of either BL or SE
+  const targetId = data.readUIntBE(0, 4);
+  i += 4;
+
+  // parse the version of either BL or SE
+  const rawVersionLength = data[i++];
+  let rawVersion = data.slice(i, i + rawVersionLength).toString();
+  i += rawVersionLength;
+
+  // flags. gives information about manager allowed in SE mode.
+  const flagsLength = data[i++];
+  let flags = data.slice(i, i + flagsLength);
+  i += flagsLength;
+
+  if (!rawVersionLength) {
+    // To support old firmware like bootloader of 1.3.1
+    rawVersion = "0.0.0";
+    flags = Buffer.allocUnsafeSlow(0);
+  }
+
+  let mcuVersion = "";
+  let mcuBlVersion: string | undefined;
+  let seVersion: string | undefined;
+  let bootloaderVersion: string | undefined;
+  let hardwareVersion: number | undefined;
+  let mcuTargetId: number | undefined;
+  let seTargetId: number | undefined;
+  let languageId: number | undefined;
+
+  const isBootloader = (targetId & 4026531840) !== 805306368;
+
+  if (isBootloader) {
+    mcuBlVersion = rawVersion;
+    mcuTargetId = targetId;
+
+    if (i < data.length) {
+      // se part 1
+      const part1Length = data[i++];
+      const part1 = data.slice(i, i + part1Length);
+      i += part1Length;
+
+      // at this time, this is how we branch old & new format
+      if (part1Length >= 5) {
+        seVersion = part1.toString();
+        // se part 2
+        const part2Length = data[i++];
+        const part2 = data.slice(i, i + part2Length);
+        i += flagsLength;
+        seTargetId = part2.readUIntBE(0, 4);
+      } else {
+        seTargetId = part1.readUIntBE(0, 4);
+      }
+    }
+  } else {
+    seVersion = rawVersion;
+    seTargetId = targetId;
+
+    // if SE: mcu version
+    const mcuVersionLength = data[i++];
+    let mcuVersionBuf: Buffer = Buffer.from(data.slice(i, i + mcuVersionLength));
+    i += mcuVersionLength;
+
+    if (mcuVersionBuf[mcuVersionBuf.length - 1] === 0) {
+      mcuVersionBuf = mcuVersionBuf.slice(0, mcuVersionBuf.length - 1);
+    }
+    mcuVersion = mcuVersionBuf.toString();
+
+    const isOSU = rawVersion.includes("-osu");
+
+    if (!isOSU) {
+      const deviceModel = identifyTargetId(targetId);
+
+      if (isBootloaderVersionSupported(seVersion, deviceModel?.id)) {
+        const bootloaderVersionLength = data[i++];
+        let bootloaderVersionBuf: Buffer = Buffer.from(data.slice(i, i + bootloaderVersionLength));
+        i += bootloaderVersionLength;
+
+        if (bootloaderVersionBuf[bootloaderVersionBuf.length - 1] === 0) {
+          bootloaderVersionBuf = bootloaderVersionBuf.slice(0, bootloaderVersionBuf.length - 1);
+        }
+        bootloaderVersion = bootloaderVersionBuf.toString();
+      }
+
+      if (isHardwareVersionSupported(seVersion, deviceModel?.id)) {
+        const hardwareVersionLength = data[i++];
+        hardwareVersion = data.slice(i, i + hardwareVersionLength).readUIntBE(0, 1); // ?? string? number?
+        i += hardwareVersionLength;
+      }
+
+      if (isDeviceLocalizationSupported(seVersion, deviceModel?.id)) {
+        const languageIdLength = data[i++];
+        languageId = data.slice(i, i + languageIdLength).readUIntBE(0, 1);
+      }
+    }
+  }
+
+  return {
+    isBootloader,
+    rawVersion,
+    targetId,
+    seVersion,
+    mcuVersion,
+    mcuBlVersion,
+    mcuTargetId,
+    seTargetId,
+    flags,
+    bootloaderVersion,
+    hardwareVersion,
+    languageId,
+  };
+}

package/src/customLockScreen/screenSpecs.ts

@@ -0,0 +1,87 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import {
+  CLSSupportedDeviceModelId,
+  supportedDeviceModelIds,
+} from "../capabilities/isCustomLockScreenSupported";
+
+type ScreenSpecs = {
+  /** width of the screen in pixels */
+  width: number;
+  /** height of the screen in pixels */
+  height: number;
+  /** number of pixels at the top of the screen which are not visible */
+  paddingTop: number;
+  /** number of pixels at the bottom of the screen which are not visible */
+  paddingBottom: number;
+  /** number of pixels at the left of the screen which are not visible */
+  paddingLeft: number;
+  /** number of pixels at the right of the screen which are not visible */
+  paddingRight: number;
+};
+
+const NO_PADDING = {
+  paddingTop: 0,
+  paddingBottom: 0,
+  paddingLeft: 0,
+  paddingRight: 0,
+} as const;
+
+export const SCREEN_SPECS: Record<CLSSupportedDeviceModelId, ScreenSpecs> = {
+  [DeviceModelId.stax]: {
+    width: 400,
+    height: 672,
+    ...NO_PADDING,
+    paddingBottom: 2,
+  },
+  [DeviceModelId.europa]: {
+    width: 480,
+    height: 600,
+    ...NO_PADDING,
+  },
+};
+
+type Dimensions = {
+  width: number;
+  height: number;
+};
+
+export function getScreenSpecs(deviceModelId: CLSSupportedDeviceModelId) {
+  return SCREEN_SPECS[deviceModelId];
+}
+
+const screenDataDimensions: Record<CLSSupportedDeviceModelId, Dimensions> =
+  supportedDeviceModelIds.reduce(
+    (acc, deviceModelId) => {
+      const { width, height } = SCREEN_SPECS[deviceModelId];
+      acc[deviceModelId] = { width, height };
+      return acc;
+    },
+    {} as Record<CLSSupportedDeviceModelId, Dimensions>,
+  );
+
+export function getScreenDataDimensions(deviceModelId: CLSSupportedDeviceModelId) {
+  return screenDataDimensions[deviceModelId];
+}
+
+const screenVisibleAreaDimensions: Record<CLSSupportedDeviceModelId, Dimensions> =
+  supportedDeviceModelIds.reduce(
+    (acc, deviceModelId) => {
+      const { width, height, paddingTop, paddingBottom, paddingLeft, paddingRight } =
+        SCREEN_SPECS[deviceModelId];
+      acc[deviceModelId] = {
+        width: width - paddingLeft - paddingRight,
+        height: height - paddingTop - paddingBottom,
+      };
+      return acc;
+    },
+    {} as Record<CLSSupportedDeviceModelId, Dimensions>,
+  );
+
+/**
+ *
+ * @param deviceModelId
+ * @returns the dimensions of the visible area of the screen (without padding)
+ */
+export function getScreenVisibleAreaDimensions(deviceModelId: CLSSupportedDeviceModelId) {
+  return screenVisibleAreaDimensions[deviceModelId];
+}

package/src/index.ts

@@ -0,0 +1,33 @@
+// src/managerApi/
+export type { DeviceInfoEntity } from "./managerApi/entities/DeviceInfoEntity";
+export type {
+  FinalFirmware,
+  OsuFirmware,
+  FirmwareUpdateContextEntity,
+} from "./managerApi/entities/FirmwareUpdateContextEntity";
+export type { ManagerApiRepository } from "./managerApi/repositories/ManagerApiRepository";
+export { HttpManagerApiRepository } from "./managerApi/repositories/HttpManagerApiRepository";
+export { StubManagerApiRepository } from "./managerApi/repositories/StubManagerApiRepository";
+export { getLatestFirmwareForDevice } from "./managerApi/use-cases/getLatestFirmwareForDevice";
+export { isDeviceLocalizationSupported } from "./commands/use-cases/isDeviceLocalizationSupported";
+export { PROVIDERS, getProviderIdUseCase } from "./managerApi/use-cases/getProviderIdUseCase";
+export { fetchMcus } from "./managerApi/use-cases/fetchMcus";
+export { aDeviceInfoBuilder } from "./managerApi/entities/mocks/aDeviceInfo";
+// src/commands/
+export type { FirmwareInfoEntity } from "./commands/entities/FirmwareInfoEntity";
+export { GET_VERSION_APDU } from "./commands/use-cases/getVersion";
+export { parseGetVersionResponse } from "./commands/use-cases/parseGetVersionResponse";
+export { getDeviceName } from "./commands/use-cases/getDeviceName";
+export { isHardwareVersionSupported } from "./commands/use-cases/isHardwareVersionSupported";
+export { isBootloaderVersionSupported } from "./commands/use-cases/isBootloaderVersionSupported";
+export { getVersion } from "./commands/use-cases/getVersion";
+// src/capabilities/
+export {
+  type CLSSupportedDeviceModelId,
+  isCustomLockScreenSupported,
+} from "./capabilities/isCustomLockScreenSupported";
+export { isEditDeviceNameSupported } from "./capabilities/isEditDeviceNameSupported";
+export { isSyncOnboardingSupported } from "./capabilities/isSyncOnboardingSupported";
+export { supportedDeviceModelIds } from "./capabilities/isCustomLockScreenSupported";
+// src/customLockScreen/
+export * from "./customLockScreen/screenSpecs";

package/src/managerApi/entities/AppEntity.ts

@@ -0,0 +1,66 @@
+import { Id } from "./Id";
+
+export enum AppType {
+  app = "app", // NB Legacy from v1, drop after we default to v2.
+  currency = "currency",
+  plugin = "plugin",
+  tool = "tool",
+  swap = "swap",
+}
+
+/** App is higher level on top of Application and ApplicationVersion
+with all fields Live needs and in normalized form (but still serializable) */
+export type AppEntity = {
+  id: Id;
+  name: string;
+  displayName: string;
+  version: string;
+  currencyId: string | null | undefined;
+  description: string | null | undefined;
+  dateModified: string;
+  icon: string;
+  authorName: string | null | undefined;
+  supportURL: string | null | undefined;
+  contactURL: string | null | undefined;
+  sourceURL: string | null | undefined;
+  hash: string;
+  perso: string;
+  firmware: string;
+  firmware_key: string;
+  delete: string;
+  delete_key: string;
+  // we use names to identify an app
+  dependencies: string[];
+  bytes: number | null | undefined;
+  warning: string | null | undefined;
+  // -1 if coin not in marketcap, otherwise index in the tickers list of https://countervalues.api.live.ledger.com/tickers
+  indexOfMarketCap: number;
+  isDevTools: boolean;
+  type: AppType;
+};
+
+export type ApplicationV2Entity = {
+  versionId: Id;
+  versionName: string;
+  versionDisplayName: string;
+  version: string;
+  currencyId: string;
+  description: string;
+  applicationType: AppType;
+  dateModified: string;
+  icon: string;
+  authorName: string;
+  supportURL: string;
+  contactURL: string;
+  sourceURL: string;
+  hash: string;
+  perso: string;
+  parentName: string | null;
+  firmware: string;
+  firmwareKey: string;
+  delete: string;
+  deleteKey: string;
+  bytes: number;
+  warning: string | null;
+  isDevTools: boolean;
+};

package/src/managerApi/entities/DeviceInfoEntity.ts

@@ -0,0 +1,26 @@
+export type DeviceInfoEntity = {
+  mcuVersion: string;
+  // the raw mcu version
+  version: string;
+  // the version part, without the -osu
+  majMin: string;
+  // the x.y part of the x.y.z-v version
+  targetId: string | number;
+  // a technical id
+  isBootloader: boolean;
+  isRecoveryMode?: boolean;
+  isOSU: boolean;
+  providerName: string | null | undefined;
+  managerAllowed: boolean;
+  pinValidated: boolean;
+  // more precised raw versions
+  seVersion?: string;
+  mcuBlVersion?: string;
+  mcuTargetId?: number;
+  seTargetId?: number;
+  onboarded?: boolean;
+  hasDevFirmware?: boolean;
+  bootloaderVersion?: string;
+  hardwareVersion?: number;
+  languageId?: number;
+};

package/src/managerApi/entities/DeviceVersionEntity.ts

@@ -0,0 +1,17 @@
+import { Id } from "./Id";
+
+export type DeviceVersionEntity = {
+  id: Id;
+  name: string;
+  display_name: string;
+  target_id: string;
+  description: string;
+  device: Id;
+  providers: Array<Id>;
+  mcu_versions: Array<Id>;
+  se_firmware_final_versions: Array<Id>;
+  osu_versions: Array<Id>;
+  application_versions: Array<Id>;
+  date_creation: string;
+  date_last_modified: string;
+};