@ledgerhq/device-core 0.2.1-next.1 → 0.3.0-nightly.0

package/src/commands/use-cases/app-backup/backupAppStorage.ts

@@ -0,0 +1,97 @@
+import Transport, { StatusCodes, TransportStatusError } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+import type { APDU } from "../../entities/APDU";
+import {
+  GenerateAesKeyFailed,
+  InternalComputeAesCmacFailed,
+  InternalCryptoOperationFailed,
+  InvalidBackupState,
+  InvalidContext,
+} from "../../../errors";
+
+/**
+ * Name in documentation: INS_APP_STORAGE_BACKUP
+ * cla: 0xe0
+ * ins: 0x6b
+ * p1: 0x00
+ * p2: 0x00
+ * lc: 0x00
+ */
+const BACKUP_APP_STORAGE = [0xe0, 0x6b, 0x00, 0x00] as const;
+
+/**
+ * 0x9000: Success.
+ * 0x5123: Invalid context, Get Info must be called.
+ * 0x5419: Failed to generate AES key.
+ * 0x541A: Internal error, crypto operation failed.
+ * 0x541B: Internal error, failed to compute AES CMAC.
+ * 0x541C: Failed to encrypt the app storage backup.
+ * 0x662F: Invalid device state, recovery mode.
+ * 0x6642: Invalid backup state, backup already performed.
+ */
+const RESPONSE_STATUS_SET: number[] = [
+  StatusCodes.OK,
+  StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+  StatusCodes.GEN_AES_KEY_FAILED,
+  StatusCodes.INTERNAL_CRYPTO_OPERATION_FAILED,
+  StatusCodes.INTERNAL_COMPUTE_AES_CMAC_FAILED,
+  StatusCodes.ENCRYPT_APP_STORAGE_FAILED,
+  StatusCodes.DEVICE_IN_RECOVERY_MODE,
+  StatusCodes.INVALID_BACKUP_STATE,
+];
+
+/**
+ * Retrieves the app storage information (chunk) from the device and returns it
+ * as a buffer.
+ *
+ * @param transport - The transport object used to communicate with the device.
+ * @returns A promise that resolves to the app storage information as a buffer.
+ */
+export async function backupAppStorage(transport: Transport): Promise<Buffer> {
+  const tracer = new LocalTracer("hw", {
+    transport: transport.getTraceContext(),
+    function: "backupAppStorage",
+  });
+  tracer.trace("Start");
+
+  const apdu: Readonly<APDU> = [...BACKUP_APP_STORAGE, Buffer.from([0x00])];
+
+  const response = await transport.send(...apdu, RESPONSE_STATUS_SET);
+
+  return parseResponse(response);
+}
+
+/**
+ * Parses the response data buffer, check the status code and return the data.
+ *
+ * @param data - The response data buffer w/ status code.
+ * @returns The response data as a buffer w/o status code.
+ */
+export function parseResponse(data: Buffer): Buffer {
+  const tracer = new LocalTracer("hw", {
+    function: "parseResponse@backupAppStorage",
+  });
+  const status = data.readUInt16BE(data.length - 2);
+  tracer.trace("Result status from 0xe06b0000", { status });
+
+  switch (status) {
+    case StatusCodes.OK:
+      return data.subarray(0, data.length - 2);
+    case StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT:
+      throw new InvalidContext("Invalid context, getAppStorageInfo must be called.");
+    case StatusCodes.GEN_AES_KEY_FAILED:
+      throw new GenerateAesKeyFailed("Failed to generate AES key.");
+    case StatusCodes.INTERNAL_CRYPTO_OPERATION_FAILED:
+      throw new InternalCryptoOperationFailed("Internal error, crypto operation failed.");
+    case StatusCodes.INTERNAL_COMPUTE_AES_CMAC_FAILED:
+      throw new InternalComputeAesCmacFailed("Internal error, failed to compute AES CMAC.");
+    case StatusCodes.ENCRYPT_APP_STORAGE_FAILED:
+      throw new GenerateAesKeyFailed("Failed to encrypt the app storage backup.");
+    case StatusCodes.DEVICE_IN_RECOVERY_MODE:
+      break;
+    case StatusCodes.INVALID_BACKUP_STATE:
+      throw new InvalidBackupState("Invalid backup state, backup already performed.");
+  }
+
+  throw new TransportStatusError(status);
+}

package/src/commands/use-cases/app-backup/getAppStorageInfo.test.ts

@@ -0,0 +1,63 @@
+import Transport, { StatusCodes } from "@ledgerhq/hw-transport";
+import { getAppStorageInfo, parseResponse } from "./getAppStorageInfo";
+import { AppStorageInfo } from "../../entities/AppStorageInfo";
+import { InvalidAppNameLength } from "../../../errors";
+
+jest.mock("@ledgerhq/hw-transport");
+
+describe("getAppStorageInfo", () => {
+  let transport: Transport;
+  const response = Buffer.from([
+    0x00, 0x00, 0x04, 0xd2, 0x31, 0x2e, 0x30, 0x31, 0x01, 0x01, 0x68, 0x61, 0x73, 0x68, 0x68, 0x61,
+    0x73, 0x68, 0x31, 0x32, 0x33, 0x34, 0x68, 0x61, 0x73, 0x68, 0x68, 0x61, 0x73, 0x68, 0x68, 0x61,
+    0x73, 0x68, 0x68, 0x61, 0x73, 0x68, 0x68, 0x61, 0x73, 0x68, 0x90, 0x00,
+  ]);
+
+  beforeEach(() => {
+    transport = {
+      send: jest.fn().mockResolvedValue(response),
+      getTraceContext: jest.fn().mockResolvedValue(undefined),
+    } as unknown as Transport;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the send function with correct parameters", async () => {
+    const appName = "MyApp";
+    await getAppStorageInfo(transport, appName);
+    expect(transport.send).toHaveBeenCalledWith(
+      0xe0,
+      0x6a,
+      0x00,
+      0x00,
+      Buffer.from([0x05, 0x4d, 0x79, 0x41, 0x70, 0x70]),
+      [
+        StatusCodes.OK,
+        StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+        StatusCodes.DEVICE_IN_RECOVERY_MODE,
+        StatusCodes.INVALID_APP_NAME_LENGTH,
+      ],
+    );
+  });
+
+  describe("parseResponse", () => {
+    it("should parse the response data correctly", () => {
+      const expected: AppStorageInfo = {
+        size: 1234,
+        dataVersion: "1.01",
+        hasSettings: true,
+        hasData: true,
+        hash: "hashhash1234hashhashhashhashhash",
+      };
+      expect(parseResponse(response)).toStrictEqual(expected);
+    });
+    it("should throw TransportStatusError if the response status is invalid", () => {
+      const data = Buffer.from([0x67, 0x0a]);
+      expect(() => parseResponse(data)).toThrow(
+        new InvalidAppNameLength("Invalid application name length, two chars minimum."),
+      );
+    });
+  });
+});

package/src/commands/use-cases/app-backup/getAppStorageInfo.ts

@@ -0,0 +1,102 @@
+import Transport, { StatusCodes, TransportStatusError } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+import type { AppStorageInfo } from "../../entities/AppStorageInfo";
+import type { APDU } from "../../entities/APDU";
+import { AppNotFound, InvalidAppNameLength } from "../../../errors";
+
+/**
+ * Name in documentation: INS_APP_STORAGE_GET_INFO
+ * cla: 0xe0
+ * ins: 0x6a
+ * p1: 0x00
+ * p2: 0x00
+ * data: APP_NAME_LEN (1 byte) + APP_NAME (variable) to configure at runtime
+ */
+const GET_APP_STORAGE_INFO = [0xe0, 0x6a, 0x00, 0x00] as const;
+
+/**
+ * 0x9000: Success.
+ * 0x5123: Application not found.
+ * 0x662F: If the device is in recovery mode.
+ * 0x670A: Invalid application name length, two chars minimum.
+ */
+const RESPONSE_STATUS_SET: number[] = [
+  StatusCodes.OK,
+  StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+  StatusCodes.DEVICE_IN_RECOVERY_MODE,
+  StatusCodes.INVALID_APP_NAME_LENGTH,
+];
+
+/**
+ * Retrieves the application storage information from the device.
+ *
+ * @param transport - The transport object used to communicate with the device.
+ * @param appName - The name of the application to retrieve the storage information for.
+ * @returns A promise that resolves to the application storage information object.
+ * @throws {TransportStatusError} If the response status is invalid.
+ */
+export async function getAppStorageInfo(
+  transport: Transport,
+  appName: string,
+): Promise<AppStorageInfo> {
+  const tracer = new LocalTracer("hw", {
+    transport: transport.getTraceContext(),
+    function: "getAppStorageInfo",
+  });
+  tracer.trace("Start");
+
+  const params: Buffer = Buffer.concat([
+    Buffer.from([appName.length]),
+    Buffer.from(appName, "ascii"),
+  ]);
+  const apdu: Readonly<APDU> = [...GET_APP_STORAGE_INFO, params];
+
+  const response = await transport.send(...apdu, RESPONSE_STATUS_SET);
+
+  return parseResponse(response);
+}
+
+/**
+ * Parses the response data from the device into a string.
+ *
+ * @param data - The response data received from the device.
+ * @returns A string representing the parsed response.
+ */
+export function parseResponse(data: Buffer): AppStorageInfo {
+  const tracer = new LocalTracer("hw", {
+    function: "parseResponse@getAppStorageInfo",
+  });
+  const status = data.readUInt16BE(data.length - 2);
+  tracer.trace("Result status from 0xe06a0000", { status });
+
+  switch (status) {
+    case StatusCodes.OK: {
+      /**
+       * The backup size is a 4-byte unsigned integer.
+       * The data version is a 4-byte string.
+       * The hasSettings and hasData flags are 1-byte booleans.
+       * The hash is a 32-byte string.
+       */
+      let offset = 0;
+      const size = data.readUInt32BE(offset); // Len = 4
+      offset += 4;
+      const dataVersion = data.subarray(offset, offset + 4).toString(); // Len = 4
+      offset += 4;
+      const hasSettings = data.readUIntBE(offset, 1) === 1; // Len = 1
+      offset += 1;
+      const hasData = data.readUIntBE(offset, 1) === 1; // Len = 1
+      offset += 1;
+      const hash = data.subarray(offset, offset + 32).toString(); // Len = 32
+
+      return { size, dataVersion, hasSettings, hasData, hash };
+    }
+    case StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT:
+      throw new AppNotFound("Application not found.");
+    case StatusCodes.DEVICE_IN_RECOVERY_MODE:
+      break;
+    case StatusCodes.INVALID_APP_NAME_LENGTH:
+      throw new InvalidAppNameLength("Invalid application name length, two chars minimum.");
+  }
+
+  throw new TransportStatusError(status);
+}

package/src/commands/use-cases/app-backup/restoreAppStorage.test.ts

@@ -0,0 +1,57 @@
+import Transport, { StatusCodes } from "@ledgerhq/hw-transport";
+import { restoreAppStorage, parseResponse } from "./restoreAppStorage";
+import { InvalidRestoreState } from "../../../errors";
+
+jest.mock("@ledgerhq/hw-transport");
+
+describe("restoreAppStorage", () => {
+  let transport: Transport;
+  const response = Buffer.from([0x90, 0x00]);
+
+  beforeEach(() => {
+    transport = {
+      send: jest.fn().mockResolvedValue(response),
+      getTraceContext: jest.fn().mockResolvedValue(undefined),
+    } as unknown as Transport;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the send function with correct parameters", async () => {
+    const chunk = Buffer.from("106RueduTemple");
+    await restoreAppStorage(transport, chunk);
+    expect(transport.send).toHaveBeenCalledWith(
+      0xe0,
+      0x6d,
+      0x00,
+      0x00,
+      Buffer.from([
+        0x0e, 0x31, 0x30, 0x36, 0x52, 0x75, 0x65, 0x64, 0x75, 0x54, 0x65, 0x6d, 0x70, 0x6c, 0x65,
+      ]),
+      [
+        StatusCodes.OK,
+        StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+        StatusCodes.GEN_AES_KEY_FAILED,
+        StatusCodes.INTERNAL_CRYPTO_OPERATION_FAILED,
+        StatusCodes.DEVICE_IN_RECOVERY_MODE,
+        StatusCodes.INVALID_RESTORE_STATE,
+        StatusCodes.INVALID_CHUNK_LENGTH,
+        StatusCodes.INVALID_BACKUP_HEADER,
+      ],
+    );
+  });
+
+  describe("parseResponse", () => {
+    it("should parse the response data correctly", () => {
+      expect(() => parseResponse(response)).not.toThrow();
+    });
+    it("should throw TransportStatusError if the response status is invalid", () => {
+      const data = Buffer.from([0x66, 0x43]);
+      expect(() => parseResponse(data)).toThrow(
+        new InvalidRestoreState("Invalid restore state, restore already performed."),
+      );
+    });
+  });
+});

package/src/commands/use-cases/app-backup/restoreAppStorage.ts

@@ -0,0 +1,93 @@
+import Transport, { StatusCodes, TransportStatusError } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+import type { APDU } from "../../entities/APDU";
+import {
+  GenerateAesKeyFailed,
+  InternalCryptoOperationFailed,
+  InvalidBackupHeader,
+  InvalidChunkLength,
+  InvalidContext,
+  InvalidRestoreState,
+} from "../../../errors";
+
+/**
+ * Name in documentation: INS_APP_STORAGE_GET_INFO
+ * cla: 0xe0
+ * ins: 0x6d
+ * p1: 0x00
+ * p2: 0x00
+ * data: CHUNK_LEN + CHUNK to configure at runtime
+ */
+const RESTORE_APP_STORAGE = [0xe0, 0x6d, 0x00, 0x00] as const;
+
+/**
+ * 0x9000: Success.
+ * 0x5123: Invalid context, Restore Init must be called first.
+ * 0x5419: Failed to generate AES key.
+ * 0x541A: Failed to decrypt the app storage backup.
+ * 0x662F: Invalid device state, recovery mode.
+ * 0x6643: Invalid restore state, restore already performed.
+ * 0x6734: Invalid CHUNK_LEN.
+ * 0x684A: Invalid backup, app storage header is not valid.
+ */
+const RESPONSE_STATUS_SET: number[] = [
+  StatusCodes.OK,
+  StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+  StatusCodes.GEN_AES_KEY_FAILED,
+  StatusCodes.INTERNAL_CRYPTO_OPERATION_FAILED,
+  StatusCodes.DEVICE_IN_RECOVERY_MODE,
+  StatusCodes.INVALID_RESTORE_STATE,
+  StatusCodes.INVALID_CHUNK_LENGTH,
+  StatusCodes.INVALID_BACKUP_HEADER,
+];
+
+/**
+ * Restores the application storage.
+ *
+ * @param transport - The transport object used for communication with the device.
+ * @param chunk - The chunk of data to restore.
+ * @returns A promise that resolves to void.
+ */
+export async function restoreAppStorage(transport: Transport, chunk: Buffer): Promise<void> {
+  const tracer = new LocalTracer("hw", {
+    transport: transport.getTraceContext(),
+    function: "restoreAppStorage",
+  });
+  tracer.trace("Start");
+
+  const params = Buffer.concat([Buffer.from([chunk.length]), chunk]);
+  const apdu: Readonly<APDU> = [...RESTORE_APP_STORAGE, params];
+
+  const response = await transport.send(...apdu, RESPONSE_STATUS_SET);
+
+  parseResponse(response);
+}
+
+export function parseResponse(data: Buffer): void {
+  const tracer = new LocalTracer("hw", {
+    function: "parseResponse@restoreAppStorage",
+  });
+  const status = data.readUInt16BE(data.length - 2);
+  tracer.trace("Result status from 0xe06d0000", { status });
+
+  switch (status) {
+    case StatusCodes.OK:
+      return;
+    case StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT:
+      throw new InvalidContext("Invalid context, restoreAppStorageInit must be called first.");
+    case StatusCodes.GEN_AES_KEY_FAILED:
+      throw new GenerateAesKeyFailed("Failed to generate AES key.");
+    case StatusCodes.INTERNAL_CRYPTO_OPERATION_FAILED:
+      throw new InternalCryptoOperationFailed("Failed to decrypt the app storage backup.");
+    case StatusCodes.DEVICE_IN_RECOVERY_MODE:
+      break;
+    case StatusCodes.INVALID_RESTORE_STATE:
+      throw new InvalidRestoreState("Invalid restore state, restore already performed.");
+    case StatusCodes.INVALID_CHUNK_LENGTH:
+      throw new InvalidChunkLength("Invalid chunk length.");
+    case StatusCodes.INVALID_BACKUP_HEADER:
+      throw new InvalidBackupHeader("Invalid backup, app storage header is not valid.");
+  }
+
+  throw new TransportStatusError(status);
+}

package/src/commands/use-cases/app-backup/restoreAppStorageCommit.test.ts

@@ -0,0 +1,45 @@
+import Transport, { StatusCodes } from "@ledgerhq/hw-transport";
+import { restoreAppStorageCommit, parseResponse } from "./restoreAppStorageCommit";
+import { InvalidChunkLength } from "../../../errors";
+
+jest.mock("@ledgerhq/hw-transport");
+
+describe("restoreAppStorageCommit", () => {
+  let transport: Transport;
+  const response = Buffer.from([0x90, 0x00]);
+
+  beforeEach(() => {
+    transport = {
+      send: jest.fn().mockResolvedValue(response),
+      getTraceContext: jest.fn().mockResolvedValue(undefined),
+    } as unknown as Transport;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the send function with correct parameters", async () => {
+    await restoreAppStorageCommit(transport);
+    expect(transport.send).toHaveBeenCalledWith(0xe0, 0x6e, 0x00, 0x00, Buffer.from([0x00]), [
+      StatusCodes.OK,
+      StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+      StatusCodes.GEN_AES_KEY_FAILED,
+      StatusCodes.INTERNAL_COMPUTE_AES_CMAC_FAILED,
+      StatusCodes.DEVICE_IN_RECOVERY_MODE,
+      StatusCodes.INVALID_CHUNK_LENGTH,
+    ]);
+  });
+
+  describe("parseResponse", () => {
+    it("should parse the response data correctly", () => {
+      expect(() => parseResponse(response)).not.toThrow();
+    });
+    it("should throw TransportStatusError if the response status is invalid", () => {
+      const data = Buffer.from([0x67, 0x34]);
+      expect(() => parseResponse(data)).toThrow(
+        new InvalidChunkLength("Invalid size of the restored app storage."),
+      );
+    });
+  });
+});

package/src/commands/use-cases/app-backup/restoreAppStorageCommit.ts

@@ -0,0 +1,82 @@
+import Transport, { StatusCodes, TransportStatusError } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+import type { APDU } from "../../entities/APDU";
+import {
+  GenerateAesKeyFailed,
+  InternalComputeAesCmacFailed,
+  InvalidChunkLength,
+  InvalidContext,
+} from "../../../errors";
+
+/**
+ * Name in documentation: INS_APP_STORAGE_RESTORE_COMMIT
+ * cla: 0xe0
+ * ins: 0x6e
+ * p1: 0x00
+ * p2: 0x00
+ * lc: 0x00
+ */
+const RESTORE_APP_STORAGE_COMMIT = [0xe0, 0x6e, 0x00, 0x00] as const;
+
+/**
+ * 0x9000: Success.
+ * 0x5123: Invalid context, Restore Init must be called first.
+ * 0x5419: Internal error, crypto operaiton failed.
+ * 0x541B: Failed to verify backup authenticity.
+ * 0x662F: Invalid device state, recovery mode.
+ * 0x6734: Invalid size of the restored app storage.
+ */
+const RESPONSE_STATUS_SET: number[] = [
+  StatusCodes.OK,
+  StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+  StatusCodes.GEN_AES_KEY_FAILED,
+  StatusCodes.INTERNAL_COMPUTE_AES_CMAC_FAILED,
+  StatusCodes.DEVICE_IN_RECOVERY_MODE,
+  StatusCodes.INVALID_CHUNK_LENGTH,
+];
+
+/**
+ * Restores the application storage commit.
+ *
+ * @param transport - The transport object used for communication with the device.
+ * @returns A promise that resolves to void.
+ */
+
+export async function restoreAppStorageCommit(transport: Transport): Promise<void> {
+  const tracer = new LocalTracer("hw", {
+    transport: transport.getTraceContext(),
+    function: "restoreAppStorageCommit",
+  });
+  tracer.trace("Start");
+
+  const apdu: Readonly<APDU> = [...RESTORE_APP_STORAGE_COMMIT, Buffer.from([0x00])];
+
+  const response = await transport.send(...apdu, RESPONSE_STATUS_SET);
+
+  parseResponse(response);
+}
+
+export function parseResponse(data: Buffer): void {
+  const tracer = new LocalTracer("hw", {
+    function: "parseResponse@restoreAppStorageCommit",
+  });
+  const status = data.readUInt16BE(data.length - 2);
+  tracer.trace("Result status from 0xe06e0000", { status });
+
+  switch (status) {
+    case StatusCodes.OK:
+      return;
+    case StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT:
+      throw new InvalidContext("Invalid context, restoreAppStorageInit must be called first.");
+    case StatusCodes.GEN_AES_KEY_FAILED:
+      throw new GenerateAesKeyFailed("Internal error, crypto operation failed.");
+    case StatusCodes.INTERNAL_COMPUTE_AES_CMAC_FAILED:
+      throw new InternalComputeAesCmacFailed("Failed to verify backup authenticity.");
+    case StatusCodes.DEVICE_IN_RECOVERY_MODE:
+      break;
+    case StatusCodes.INVALID_CHUNK_LENGTH:
+      throw new InvalidChunkLength("Invalid size of the restored app storage.");
+  }
+
+  throw new TransportStatusError(status);
+}

package/src/commands/use-cases/app-backup/restoreAppStorageInit.test.ts

@@ -0,0 +1,55 @@
+import Transport, { StatusCodes } from "@ledgerhq/hw-transport";
+import { restoreAppStorageInit, parseResponse } from "./restoreAppStorageInit";
+import { InvalidAppNameLength } from "../../../errors";
+
+jest.mock("@ledgerhq/hw-transport");
+
+describe("restoreAppStorageInit", () => {
+  let transport: Transport;
+  const response = Buffer.from([0x90, 0x00]);
+
+  beforeEach(() => {
+    transport = {
+      send: jest.fn().mockResolvedValue(response),
+      getTraceContext: jest.fn().mockResolvedValue(undefined),
+    } as unknown as Transport;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call the send function with correct parameters", async () => {
+    const appName = "MyApp";
+    const backupSize = 1234;
+    await restoreAppStorageInit(transport, appName, backupSize);
+    expect(transport.send).toHaveBeenCalledWith(
+      0xe0,
+      0x6c,
+      0x00,
+      0x00,
+      Buffer.from([0x09, 0x00, 0x00, 0x04, 0xd2, 0x4d, 0x79, 0x41, 0x70, 0x70]),
+      [
+        StatusCodes.OK,
+        StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+        StatusCodes.DEVICE_IN_RECOVERY_MODE,
+        StatusCodes.USER_REFUSED_ON_DEVICE,
+        StatusCodes.PIN_NOT_SET,
+        StatusCodes.INVALID_APP_NAME_LENGTH,
+        StatusCodes.INVALID_BACKUP_LENGTH,
+      ],
+    );
+  });
+
+  describe("parseResponse", () => {
+    it("should parse the response data correctly", () => {
+      expect(() => parseResponse(response)).not.toThrow();
+    });
+    it("should throw TransportStatusError if the response status is invalid", () => {
+      const data = Buffer.from([0x67, 0x0a]);
+      expect(() => parseResponse(data)).toThrow(
+        new InvalidAppNameLength("Invalid application name length, two chars minimum."),
+      );
+    });
+  });
+});

package/src/commands/use-cases/app-backup/restoreAppStorageInit.ts

@@ -0,0 +1,96 @@
+import Transport, { StatusCodes, TransportStatusError } from "@ledgerhq/hw-transport";
+import { LocalTracer } from "@ledgerhq/logs";
+import type { APDU } from "../../entities/APDU";
+import { AppNotFound, InvalidAppNameLength, InvalidBackupLength, PinNotSet } from "../../../errors";
+
+/**
+ * Name in documentation: INS_APP_STORAGE_RESTORE_INIT
+ * cla: 0xe0
+ * ins: 0x6c
+ * p1: 0x00
+ * p2: 0x00
+ * data:
+ *  - LC: BACKUP_LEN_LEN (=0x04) + APP_NAME_LEN (1 byte)
+ *  - DATA: BACKUP_LEN + APP_NAME
+ *
+ * For example, the 'bitcoin' app with backup of length 0x00007000:
+ *    1. LC is 0x0b
+ *    2. DATA is 0x00007000 0x626974636f696e
+ */
+const RESTORE_APP_STORAGE_INIT = [0xe0, 0x6c, 0x00, 0x00] as const;
+
+/**
+ * 0x9000: Success.
+ * 0x5123: Application not found.
+ * 0x662F: Invalid device state, recovery mode.
+ * 0x5501: Invalid consent, user rejected.
+ * 0x5502: Invalid consent, pin is not set.
+ * 0x670A: Invalid application name length, two chars minimum.
+ * 0x6733: Invalid BACKUP_LEN value.
+ */
+const RESPONSE_STATUS_SET: number[] = [
+  StatusCodes.OK,
+  StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT,
+  StatusCodes.DEVICE_IN_RECOVERY_MODE,
+  StatusCodes.USER_REFUSED_ON_DEVICE,
+  StatusCodes.PIN_NOT_SET,
+  StatusCodes.INVALID_APP_NAME_LENGTH,
+  StatusCodes.INVALID_BACKUP_LENGTH,
+];
+
+/**
+ * Restores the application storage initialization.
+ *
+ * @param transport - The transport object used for communication with the device.
+ * @param appName - The name of the application to restore the storage for.
+ * @param backupSize - The size of the backup to restore.
+ * @returns A promise that resolves to void.
+ */
+export async function restoreAppStorageInit(
+  transport: Transport,
+  appName: string,
+  backupSize: number,
+): Promise<void> {
+  const tracer = new LocalTracer("hw", {
+    transport: transport.getTraceContext(),
+    function: "restoreAppStorageInit",
+  });
+  tracer.trace("Start");
+
+  const params: Buffer = Buffer.concat([
+    Buffer.from([appName.length + 4]), // LC
+    Buffer.from(backupSize.toString(16).padStart(8, "0"), "hex"), // BACKUP_LEN
+    Buffer.from(appName, "ascii"), // APP_NAME
+  ]);
+  const apdu: Readonly<APDU> = [...RESTORE_APP_STORAGE_INIT, params];
+
+  const response = await transport.send(...apdu, RESPONSE_STATUS_SET);
+
+  parseResponse(response);
+}
+
+export function parseResponse(data: Buffer): void {
+  const tracer = new LocalTracer("hw", {
+    function: "parseResponse@restoreAppStorageInit",
+  });
+  const status = data.readUInt16BE(data.length - 2);
+  tracer.trace("Result status from 0xe06c0000", { status });
+
+  switch (status) {
+    case StatusCodes.OK:
+      return;
+    case StatusCodes.APP_NOT_FOUND_OR_INVALID_CONTEXT:
+      throw new AppNotFound("Application not found.");
+    case StatusCodes.DEVICE_IN_RECOVERY_MODE:
+    case StatusCodes.USER_REFUSED_ON_DEVICE:
+      break;
+    case StatusCodes.PIN_NOT_SET:
+      throw new PinNotSet("Invalid consent, PIN is not set.");
+    case StatusCodes.INVALID_APP_NAME_LENGTH:
+      throw new InvalidAppNameLength("Invalid application name length, two chars minimum.");
+    case StatusCodes.INVALID_BACKUP_LENGTH:
+      throw new InvalidBackupLength("Invalid backup length.");
+  }
+
+  throw new TransportStatusError(status);
+}