@ledgerhq/device-core 0.1.0

package/src/capabilities/isEditDeviceNameSupported.test.ts

@@ -0,0 +1,18 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { isEditDeviceNameSupported } from "./isEditDeviceNameSupported";
+
+const supportedDevices = [DeviceModelId.stax, DeviceModelId.nanoX, DeviceModelId.europa];
+const unsupportedDevices = [DeviceModelId.nanoS, DeviceModelId.blue, DeviceModelId.nanoSP];
+
+describe("isEditDeviceNameSupported", () => {
+  it("should return true for supported devices", () => {
+    supportedDevices.forEach((deviceModelId: DeviceModelId) => {
+      expect(isEditDeviceNameSupported(deviceModelId)).toBe(true);
+    });
+  });
+  it("should return false for unsupported devices", () => {
+    unsupportedDevices.forEach((deviceModelId: DeviceModelId) => {
+      expect(isEditDeviceNameSupported(deviceModelId)).toBe(false);
+    });
+  });
+});

package/src/capabilities/isEditDeviceNameSupported.ts

@@ -0,0 +1,5 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+
+export function isEditDeviceNameSupported(deviceModelId: DeviceModelId) {
+  return [DeviceModelId.stax, DeviceModelId.nanoX, DeviceModelId.europa].includes(deviceModelId);
+}

package/src/capabilities/isSyncOnboardingSupported.test.ts

@@ -0,0 +1,16 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+import { isSyncOnboardingSupported } from "./isSyncOnboardingSupported";
+
+describe("isSyncOnboardingSupported", () => {
+  it("should return true if sync onboarding is supported", () => {
+    expect(isSyncOnboardingSupported(DeviceModelId.stax)).toBe(true);
+    expect(isSyncOnboardingSupported(DeviceModelId.europa)).toBe(true);
+  });
+
+  it("should return false if sync onboarding is not supported", () => {
+    expect(isSyncOnboardingSupported(DeviceModelId.nanoS)).toBe(false);
+    expect(isSyncOnboardingSupported(DeviceModelId.nanoSP)).toBe(false);
+    expect(isSyncOnboardingSupported(DeviceModelId.nanoX)).toBe(false);
+    expect(isSyncOnboardingSupported(DeviceModelId.blue)).toBe(false);
+  });
+});

package/src/capabilities/isSyncOnboardingSupported.ts

@@ -0,0 +1,5 @@
+import { DeviceModelId } from "@ledgerhq/devices";
+
+export function isSyncOnboardingSupported(deviceModelId: DeviceModelId) {
+  return [DeviceModelId.stax, DeviceModelId.europa].includes(deviceModelId);
+}

package/src/commands/entities/APDU.ts

@@ -0,0 +1,12 @@
+export type APDU = [
+  /* 1 byte unsigned int */
+  cla: number,
+  /* 1 byte unsigned int */
+  ins: number,
+  /* 1 byte unsigned int */
+  p1: number,
+  /* 1 byte unsigned int */
+  p2: number,
+  /* data (optional) */
+  data: Buffer | undefined,
+];

package/src/commands/entities/FirmwareInfoEntity.ts

@@ -0,0 +1,14 @@
+export type FirmwareInfoEntity = {
+  isBootloader: boolean;
+  rawVersion: string; // if SE seVersion, if BL blVersion
+  targetId: number; // if SE seTargetId, if BL mcuTargetId
+  seVersion?: string;
+  mcuVersion: string; // NB historically not undefined. but will be ""
+  mcuBlVersion?: string;
+  mcuTargetId?: number;
+  seTargetId?: number;
+  flags: Buffer;
+  bootloaderVersion?: string;
+  hardwareVersion?: number;
+  languageId?: number;
+};

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

@@ -0,0 +1,38 @@
+import Transport, { StatusCodes } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+import { APDU } from "../entities/APDU";
+import { parseGetDeviceNameResponse } from "./parseGetDeviceNameResponse";
+
+/**
+ * A first APDU that we send because getDeviceName sometimes misbehaves on LNX
+ * if it's not sent.
+ * cf. https://github.com/LedgerHQ/ledger-live/pull/2250 where it was removed
+ * cf. https://github.com/LedgerHQ/ledger-live/pull/2401 where it was added back
+ */
+const CLEANING_APDU: APDU = [0xe0, 0x50, 0x00, 0x00, undefined];
+
+const GET_DEVICE_NAME_APDU: APDU = [0xe0, 0xd2, 0x00, 0x00, Buffer.from([])];
+
+export async function getDeviceName(transport: Transport): Promise<string> {
+  const tracer = new LocalTracer("hw", {
+    transport: transport.getTraceContext(),
+    function: "getDeviceName",
+  });
+  tracer.trace("Start");
+
+  try {
+    // Legacy: prevents bad apdu response for LNX
+    await transport.send(...CLEANING_APDU);
+  } catch (error) {
+    tracer.trace(`Error on 0xe0500000: ${error}`, { error });
+  }
+  tracer.trace("Sent cleaning 0xe0500000");
+
+  const res = await transport.send(...GET_DEVICE_NAME_APDU, [
+    StatusCodes.OK,
+    StatusCodes.DEVICE_NOT_ONBOARDED,
+    StatusCodes.DEVICE_NOT_ONBOARDED_2,
+  ]);
+
+  return parseGetDeviceNameResponse(res);
+}

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

@@ -0,0 +1,23 @@
+import Transport from "@ledgerhq/hw-transport";
+import { FirmwareInfoEntity } from "../entities/FirmwareInfoEntity";
+import { APDU } from "../entities/APDU";
+import { parseGetVersionResponse } from "./parseGetVersionResponse";
+
+export const GET_VERSION_APDU: APDU = [0xe0, 0x01, 0x00, 0x00, undefined];
+
+/**
+ * Get the FirmwareInfo of a given device
+ *
+ * @param transport
+ * @param options - Contains optional options:
+ *  - abortTimeoutMs: aborts the APDU exchange after a given timeout
+ */
+export async function getVersion(
+  transport: Transport,
+  { abortTimeoutMs }: { abortTimeoutMs?: number } = {},
+): Promise<FirmwareInfoEntity> {
+  const res = await transport.send(...GET_VERSION_APDU, undefined, {
+    abortTimeoutMs,
+  });
+  return parseGetVersionResponse(res);
+}

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

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

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

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

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,
+  };
+}