@ledgerhq/dmk-ledger-wallet 0.0.0-develop-20260707161641 → 0.0.0-develop-20260708131309

package/lib/cjs/api/command/OsUpdate/Backup/BackupAppStorageCommand.js

@@ -0,0 +1,2 @@
+"use strict";var n=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var C=(a,r)=>{for(var t in r)n(a,t,{get:r[t],enumerable:!0})},g=(a,r,t,p)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of c(r))!u.call(a,o)&&o!==t&&n(a,o,{get:()=>r[o],enumerable:!(p=s(r,o))||p.enumerable});return a};var i=a=>g(n({},"__esModule",{value:!0}),a);var A={};C(A,{BACKUP_APP_STORAGE_ERRORS:()=>d,BackupAppStorageCommand:()=>l,BackupAppStorageCommandError:()=>m});module.exports=i(A);var e=require("@ledgerhq/device-management-kit");const d={5123:{message:"Invalid context. Get info must be called."},5419:{message:"Failed to generate AES key."},"541a":{message:"Internal error, crypto operation failed."},"541b":{message:"Internal error, failed to compute AES CMAC."},"541c":{message:"Failed to encrypt the app storage backup."},"622f":{message:"Invalid device state, recovery mode."},6642:{message:"Invalid backup state, backup already performed."}};class m extends e.DeviceExchangeError{constructor(r){super({tag:"BackupAppStorageCommandError",...r})}}class l{name="BackupAppStorage";header={cla:224,ins:107,p1:0,p2:0};getApdu(){return new e.ApduBuilder(this.header).build()}parseResponse(r){const t=new e.ApduParser(r);if(!e.CommandUtils.isSuccessResponse(r)){const o=t.encodeToHexaString(r.statusCode);return(0,e.isCommandErrorCode)(o,d)?(0,e.CommandResultFactory)({error:new m({...d[o],errorCode:o})}):(0,e.CommandResultFactory)({error:e.GlobalCommandErrorHandler.handle(r)})}const p=t.extractFieldByLength(t.getUnparsedRemainingLength());return p===void 0?(0,e.CommandResultFactory)({error:new e.InvalidStatusWordError("Failed to extract app storage data chunk")}):(0,e.CommandResultFactory)({data:{chunkData:p,chunkSize:p.length}})}}0&&(module.exports={BACKUP_APP_STORAGE_ERRORS,BackupAppStorageCommand,BackupAppStorageCommandError});
+//# sourceMappingURL=BackupAppStorageCommand.js.map

package/lib/cjs/api/command/OsUpdate/Backup/BackupAppStorageCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Backup/BackupAppStorageCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandErrorArgs,\n  type CommandErrors,\n  type CommandResult,\n  CommandResultFactory,\n  CommandUtils,\n  DeviceExchangeError,\n  GlobalCommandErrorHandler,\n  InvalidStatusWordError,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type BackupAppStorageCommandResponse = {\n  chunkData: Uint8Array;\n  chunkSize: number;\n};\n\nexport type BackupAppStorageCommandErrorCodes =\n  | \"5123\"\n  | \"5419\"\n  | \"541a\"\n  | \"541b\"\n  | \"541c\"\n  | \"622f\"\n  | \"6642\";\n\nexport const BACKUP_APP_STORAGE_ERRORS: CommandErrors<BackupAppStorageCommandErrorCodes> =\n  {\n    \"5123\": { message: \"Invalid context. Get info must be called.\" },\n    \"5419\": { message: \"Failed to generate AES key.\" },\n    \"541a\": { message: \"Internal error, crypto operation failed.\" },\n    \"541b\": { message: \"Internal error, failed to compute AES CMAC.\" },\n    \"541c\": { message: \"Failed to encrypt the app storage backup.\" },\n    \"622f\": { message: \"Invalid device state, recovery mode.\" },\n    \"6642\": { message: \"Invalid backup state, backup already performed.\" },\n  };\n\nexport class BackupAppStorageCommandError extends DeviceExchangeError<BackupAppStorageCommandErrorCodes> {\n  constructor(args: CommandErrorArgs<BackupAppStorageCommandErrorCodes>) {\n    super({ tag: \"BackupAppStorageCommandError\", ...args });\n  }\n}\n\nexport type BackupAppStorageCommandResult = CommandResult<\n  BackupAppStorageCommandResponse,\n  BackupAppStorageCommandErrorCodes\n>;\n\nexport class BackupAppStorageCommand\n  implements\n    Command<\n      BackupAppStorageCommandResponse,\n      void,\n      BackupAppStorageCommandErrorCodes\n    >\n{\n  readonly name = \"BackupAppStorage\";\n\n  private readonly header = {\n    cla: 0xe0,\n    ins: 0x6b,\n    p1: 0x00,\n    p2: 0x00,\n  };\n\n  getApdu(): Apdu {\n    return new ApduBuilder(this.header).build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): BackupAppStorageCommandResult {\n    const parser = new ApduParser(apduResponse);\n\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, BACKUP_APP_STORAGE_ERRORS)) {\n        return CommandResultFactory({\n          error: new BackupAppStorageCommandError({\n            ...BACKUP_APP_STORAGE_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    const appStorageDataChunk = parser.extractFieldByLength(\n      parser.getUnparsedRemainingLength(),\n    );\n\n    if (appStorageDataChunk === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\n          \"Failed to extract app storage data chunk\",\n        ),\n      });\n    }\n\n    return CommandResultFactory({\n      data: {\n        chunkData: appStorageDataChunk,\n        chunkSize: appStorageDataChunk.length,\n      },\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,+BAAAE,EAAA,4BAAAC,EAAA,iCAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAeO,2CAgBA,MAAMJ,EACX,CACE,KAAQ,CAAE,QAAS,2CAA4C,EAC/D,KAAQ,CAAE,QAAS,6BAA8B,EACjD,OAAQ,CAAE,QAAS,0CAA2C,EAC9D,OAAQ,CAAE,QAAS,6CAA8C,EACjE,OAAQ,CAAE,QAAS,2CAA4C,EAC/D,OAAQ,CAAE,QAAS,sCAAuC,EAC1D,KAAQ,CAAE,QAAS,iDAAkD,CACvE,EAEK,MAAME,UAAqC,qBAAuD,CACvG,YAAYG,EAA2D,CACrE,MAAM,CAAE,IAAK,+BAAgC,GAAGA,CAAK,CAAC,CACxD,CACF,CAOO,MAAMJ,CAOb,CACW,KAAO,mBAEC,OAAS,CACxB,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EAEA,SAAgB,CACd,OAAO,IAAI,cAAY,KAAK,MAAM,EAAE,MAAM,CAC5C,CAEA,cAAcK,EAA2D,CACvE,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAE1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAME,EAAYD,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBE,EAAWR,CAAyB,KAClD,wBAAqB,CAC1B,MAAO,IAAIE,EAA6B,CACtC,GAAGF,EAA0BQ,CAAS,EACtC,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOF,CAAY,CACtD,CAAC,CACH,CAEA,MAAMG,EAAsBF,EAAO,qBACjCA,EAAO,2BAA2B,CACpC,EAEA,OAAIE,IAAwB,UACnB,wBAAqB,CAC1B,MAAO,IAAI,yBACT,0CACF,CACF,CAAC,KAGI,wBAAqB,CAC1B,KAAM,CACJ,UAAWA,EACX,UAAWA,EAAoB,MACjC,CACF,CAAC,CACH,CACF",
+  "names": ["BackupAppStorageCommand_exports", "__export", "BACKUP_APP_STORAGE_ERRORS", "BackupAppStorageCommand", "BackupAppStorageCommandError", "__toCommonJS", "import_device_management_kit", "args", "apduResponse", "parser", "errorCode", "appStorageDataChunk"]
+}

package/lib/cjs/api/command/OsUpdate/Backup/BackupAppStorageCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var a=require("@ledgerhq/device-management-kit"),s=require("./BackupAppStorageCommand");describe("BackupAppStorageCommand",()=>{describe("Name",()=>{it("name should be 'BackupAppStorage'",()=>{const e=new s.BackupAppStorageCommand().name;expect(e).toBe("BackupAppStorage")})}),describe("Command",()=>{it("should return the correct APDU for backing up app storage",()=>{const t=Uint8Array.from([224,107,0,0,0]),e=new s.BackupAppStorageCommand().getApdu();expect(e.getRawApdu()).toEqual(t)})}),describe("Success response",()=>{it("should return the app storage data chunk as a hex string",()=>{const t=Uint8Array.from([144,0]),e=new a.ApduResponse({statusCode:t,data:Uint8Array.from([171,205,239,1,35])}),o=new s.BackupAppStorageCommand().parseResponse(e);expect((0,a.isSuccessCommandResult)(o)).toBe(!0),expect(o).toEqual({data:{chunkData:Uint8Array.from([171,205,239,1,35]),chunkSize:5},status:"SUCCESS"})})}),describe("Error response",()=>{it.each([{description:"get info was not called first",statusCode:[81,35],expectedMessage:"Invalid context. Get info must be called."},{description:"AES key generation fails",statusCode:[84,25],expectedMessage:"Failed to generate AES key."},{description:"crypto operation fails",statusCode:[84,26],expectedMessage:"Internal error, crypto operation failed."},{description:"AES CMAC computation fails",statusCode:[84,27],expectedMessage:"Internal error, failed to compute AES CMAC."},{description:"encryption of backup fails",statusCode:[84,28],expectedMessage:"Failed to encrypt the app storage backup."},{description:"device is in recovery mode",statusCode:[98,47],expectedMessage:"Invalid device state, recovery mode."},{description:"backup was already performed",statusCode:[102,66],expectedMessage:"Invalid backup state, backup already performed."},{description:"error code is not specific to BackupStorageCommand (global error)",statusCode:[85,21],expectedMessage:"Device is locked."}])("should return error when $description",({statusCode:t,expectedMessage:e})=>{const o=new a.ApduResponse({statusCode:Uint8Array.from(t),data:new Uint8Array([])}),r=new s.BackupAppStorageCommand().parseResponse(o);expect((0,a.isSuccessCommandResult)(r)).toBe(!1),expect(r.error.message).toBe(e)})})});
+//# sourceMappingURL=BackupAppStorageCommand.test.js.map

package/lib/cjs/api/command/OsUpdate/Backup/BackupAppStorageCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Backup/BackupAppStorageCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { BackupAppStorageCommand } from \"./BackupAppStorageCommand\";\n\ndescribe(\"BackupAppStorageCommand\", () => {\n  describe(\"Name\", () => {\n    it(\"name should be 'BackupAppStorage'\", () => {\n      // ARRANGE\n      const command = new BackupAppStorageCommand();\n\n      // ACT\n      const name = command.name;\n\n      // ASSERT\n      expect(name).toBe(\"BackupAppStorage\");\n    });\n  });\n\n  describe(\"Command\", () => {\n    it(\"should return the correct APDU for backing up app storage\", () => {\n      // ARRANGE\n      const expectedApdu = Uint8Array.from([0xe0, 0x6b, 0x00, 0x00, 0x00]);\n\n      // ACT\n      const apdu = new BackupAppStorageCommand().getApdu();\n\n      // ASSERT\n      expect(apdu.getRawApdu()).toEqual(expectedApdu);\n    });\n  });\n\n  describe(\"Success response\", () => {\n    it(\"should return the app storage data chunk as a hex string\", () => {\n      // ARRANGE\n      const statusCode = Uint8Array.from([0x90, 0x00]);\n      const response = new ApduResponse({\n        statusCode,\n        data: Uint8Array.from([0xab, 0xcd, 0xef, 0x01, 0x23]),\n      });\n\n      // ACT\n      const result = new BackupAppStorageCommand().parseResponse(response);\n\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual({\n        data: {\n          chunkData: Uint8Array.from([0xab, 0xcd, 0xef, 0x01, 0x23]),\n          chunkSize: 5,\n        },\n        status: \"SUCCESS\",\n      });\n    });\n  });\n\n  describe(\"Error response\", () => {\n    it.each([\n      {\n        description: \"get info was not called first\",\n        statusCode: [0x51, 0x23],\n        expectedMessage: \"Invalid context. Get info must be called.\",\n      },\n      {\n        description: \"AES key generation fails\",\n        statusCode: [0x54, 0x19],\n        expectedMessage: \"Failed to generate AES key.\",\n      },\n      {\n        description: \"crypto operation fails\",\n        statusCode: [0x54, 0x1a],\n        expectedMessage: \"Internal error, crypto operation failed.\",\n      },\n      {\n        description: \"AES CMAC computation fails\",\n        statusCode: [0x54, 0x1b],\n        expectedMessage: \"Internal error, failed to compute AES CMAC.\",\n      },\n      {\n        description: \"encryption of backup fails\",\n        statusCode: [0x54, 0x1c],\n        expectedMessage: \"Failed to encrypt the app storage backup.\",\n      },\n      {\n        description: \"device is in recovery mode\",\n        statusCode: [0x62, 0x2f],\n        expectedMessage: \"Invalid device state, recovery mode.\",\n      },\n      {\n        description: \"backup was already performed\",\n        statusCode: [0x66, 0x42],\n        expectedMessage: \"Invalid backup state, backup already performed.\",\n      },\n      {\n        description:\n          \"error code is not specific to BackupStorageCommand (global error)\",\n        statusCode: [0x55, 0x15],\n        expectedMessage: \"Device is locked.\",\n      },\n    ])(\n      \"should return error when $description\",\n      ({ statusCode, expectedMessage }) => {\n        // ARRANGE\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from(statusCode),\n          data: new Uint8Array([]),\n        });\n\n        // ACT\n        const result = new BackupAppStorageCommand().parseResponse(response);\n\n        // ASSERT\n        expect(isSuccessCommandResult(result)).toBe(false);\n        expect((result as unknown as { error: Error }).error.message).toBe(\n          expectedMessage,\n        );\n      },\n    );\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAGO,2CAEPC,EAAwC,qCAExC,SAAS,0BAA2B,IAAM,CACxC,SAAS,OAAQ,IAAM,CACrB,GAAG,oCAAqC,IAAM,CAK5C,MAAMC,EAHU,IAAI,0BAAwB,EAGvB,KAGrB,OAAOA,CAAI,EAAE,KAAK,kBAAkB,CACtC,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,4DAA6D,IAAM,CAEpE,MAAMC,EAAe,WAAW,KAAK,CAAC,IAAM,IAAM,EAAM,EAAM,CAAI,CAAC,EAG7DC,EAAO,IAAI,0BAAwB,EAAE,QAAQ,EAGnD,OAAOA,EAAK,WAAW,CAAC,EAAE,QAAQD,CAAY,CAChD,CAAC,CACH,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,2DAA4D,IAAM,CAEnE,MAAME,EAAa,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACzCC,EAAW,IAAI,eAAa,CAChC,WAAAD,EACA,KAAM,WAAW,KAAK,CAAC,IAAM,IAAM,IAAM,EAAM,EAAI,CAAC,CACtD,CAAC,EAGKE,EAAS,IAAI,0BAAwB,EAAE,cAAcD,CAAQ,EAGnE,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQ,CACrB,KAAM,CACJ,UAAW,WAAW,KAAK,CAAC,IAAM,IAAM,IAAM,EAAM,EAAI,CAAC,EACzD,UAAW,CACb,EACA,OAAQ,SACV,CAAC,CACH,CAAC,CACH,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,KAAK,CACN,CACE,YAAa,gCACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,2CACnB,EACA,CACE,YAAa,2BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,6BACnB,EACA,CACE,YAAa,yBACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,0CACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,6CACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,2CACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,sCACnB,EACA,CACE,YAAa,+BACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,iDACnB,EACA,CACE,YACE,oEACF,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,mBACnB,CACF,CAAC,EACC,wCACA,CAAC,CAAE,WAAAF,EAAY,gBAAAG,CAAgB,IAAM,CAEnC,MAAMF,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAKD,CAAU,EACtC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKE,EAAS,IAAI,0BAAwB,EAAE,cAAcD,CAAQ,EAGnE,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAK,EACjD,OAAQA,EAAuC,MAAM,OAAO,EAAE,KAC5DC,CACF,CACF,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_BackupAppStorageCommand", "name", "expectedApdu", "apdu", "statusCode", "response", "result", "expectedMessage"]
+}

package/lib/cjs/api/command/OsUpdate/Backup/GetAppStorageInfoCommand.js

@@ -0,0 +1,2 @@
+"use strict";var m=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var A=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var f=(t,r)=>{for(var o in r)m(t,o,{get:r[o],enumerable:!0})},u=(t,r,o,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let a of A(r))!c.call(t,a)&&a!==o&&m(t,a,{get:()=>r[a],enumerable:!(n=l(r,a))||n.enumerable});return t};var I=t=>u(m({},"__esModule",{value:!0}),t);var G={};f(G,{GET_APP_STORAGE_INFO_ERRORS:()=>d,GetAppStorageInfoCommand:()=>x,GetAppStorageInfoCommandError:()=>S});module.exports=I(G);var e=require("@ledgerhq/device-management-kit");const d={5123:{message:"Application not found."},"662f":{message:"Device is in recovery mode."},"670a":{message:"Invalid application name length, two chars minimum."}};class S extends e.DeviceExchangeError{constructor(r){super({tag:"GetAppStorageInfoCommandError",...r})}}class x{constructor(r){this.args=r}name="GetAppStorageInfo";header={cla:224,ins:106,p1:0,p2:0};getApdu(){const{appName:r}=this.args;return new e.ApduBuilder(this.header).addAsciiStringToData(r).build()}parseResponse(r){const o=new e.ApduParser(r);if(!e.CommandUtils.isSuccessResponse(r)){const s=o.encodeToHexaString(r.statusCode);return(0,e.isCommandErrorCode)(s,d)?(0,e.CommandResultFactory)({error:new S({...d[s],errorCode:s})}):(0,e.CommandResultFactory)({error:e.GlobalCommandErrorHandler.handle(r)})}const n=o.extract32BitUInt();if(n===void 0)return(0,e.CommandResultFactory)({error:new e.InvalidStatusWordError("Failed to extract app storage size")});let a="",i=!1,g=!1,C="";if(n!==0){const s=o.extract32BitUInt();if(s===void 0)return(0,e.CommandResultFactory)({error:new e.InvalidStatusWordError("Failed to extract app storage version")});a=s.toString(16);const p=o.extract16BitUInt();if(p===void 0)return(0,e.CommandResultFactory)({error:new e.InvalidStatusWordError("Failed to extract app storage properties")});i=(p&1)===1,g=(p&2)===2,C=o.encodeToHexaString(o.extractFieldByLength(32))}return(0,e.CommandResultFactory)({data:{storageSize:n,storageVersion:a,hasSettings:i,hasData:g,storageHash:C}})}}0&&(module.exports={GET_APP_STORAGE_INFO_ERRORS,GetAppStorageInfoCommand,GetAppStorageInfoCommandError});
+//# sourceMappingURL=GetAppStorageInfoCommand.js.map

package/lib/cjs/api/command/OsUpdate/Backup/GetAppStorageInfoCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Backup/GetAppStorageInfoCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandErrorArgs,\n  type CommandErrors,\n  type CommandResult,\n  CommandResultFactory,\n  CommandUtils,\n  DeviceExchangeError,\n  GlobalCommandErrorHandler,\n  InvalidStatusWordError,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type GetAppStorageInfoCommandArgs = {\n  appName: string;\n};\n\nexport type GetAppStorageInfoCommandResponse = {\n  storageSize: number;\n  storageVersion: string;\n  hasSettings: boolean;\n  hasData: boolean;\n  storageHash: string;\n};\n\nexport type GetAppStorageInfoCommandErrorCodes = \"5123\" | \"662f\" | \"670a\";\n\nexport const GET_APP_STORAGE_INFO_ERRORS: CommandErrors<GetAppStorageInfoCommandErrorCodes> =\n  {\n    \"5123\": { message: \"Application not found.\" },\n    \"662f\": { message: \"Device is in recovery mode.\" },\n    \"670a\": { message: \"Invalid application name length, two chars minimum.\" },\n  };\n\nexport class GetAppStorageInfoCommandError extends DeviceExchangeError<GetAppStorageInfoCommandErrorCodes> {\n  constructor(args: CommandErrorArgs<GetAppStorageInfoCommandErrorCodes>) {\n    super({ tag: \"GetAppStorageInfoCommandError\", ...args });\n  }\n}\n\nexport type GetAppStorageInfoCommandResult = CommandResult<\n  GetAppStorageInfoCommandResponse,\n  GetAppStorageInfoCommandErrorCodes\n>;\n\nexport class GetAppStorageInfoCommand\n  implements\n    Command<\n      GetAppStorageInfoCommandResponse,\n      GetAppStorageInfoCommandArgs,\n      GetAppStorageInfoCommandErrorCodes\n    >\n{\n  readonly name = \"GetAppStorageInfo\";\n\n  private readonly header = {\n    cla: 0xe0,\n    ins: 0x6a,\n    p1: 0x00,\n    p2: 0x00,\n  };\n\n  constructor(private readonly args: GetAppStorageInfoCommandArgs) {}\n\n  getApdu(): Apdu {\n    const { appName } = this.args;\n    return new ApduBuilder(this.header).addAsciiStringToData(appName).build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): GetAppStorageInfoCommandResult {\n    const parser = new ApduParser(apduResponse);\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, GET_APP_STORAGE_INFO_ERRORS)) {\n        return CommandResultFactory({\n          error: new GetAppStorageInfoCommandError({\n            ...GET_APP_STORAGE_INFO_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    const appStorageSize = parser.extract32BitUInt();\n    if (appStorageSize === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Failed to extract app storage size\"),\n      });\n    }\n\n    let appStorageVersion = \"\";\n    let hasAppStorageSettings = false;\n    let hasAppStorageData = false;\n    let hash = \"\";\n\n    if (appStorageSize !== 0) {\n      const appStorageVersionNumber = parser.extract32BitUInt();\n      if (appStorageVersionNumber === undefined) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\n            \"Failed to extract app storage version\",\n          ),\n        });\n      }\n      appStorageVersion = appStorageVersionNumber.toString(16);\n      /**\n       * The properties byte is a bitfield with the following structure:\n       * - Bit 0: hasSettings\n       * - Bit 1: hasData\n       */\n      const appStorageProperties = parser.extract16BitUInt();\n      if (appStorageProperties === undefined) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\n            \"Failed to extract app storage properties\",\n          ),\n        });\n      }\n\n      hasAppStorageSettings = (appStorageProperties & 1) === 1;\n      hasAppStorageData = (appStorageProperties & 2) === 2;\n      hash = parser.encodeToHexaString(parser.extractFieldByLength(0x20));\n    }\n\n    return CommandResultFactory({\n      data: {\n        storageSize: appStorageSize,\n        storageVersion: appStorageVersion,\n        hasSettings: hasAppStorageSettings,\n        hasData: hasAppStorageData,\n        storageHash: hash,\n      },\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,iCAAAE,EAAA,6BAAAC,EAAA,kCAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAeO,2CAgBA,MAAMJ,EACX,CACE,KAAQ,CAAE,QAAS,wBAAyB,EAC5C,OAAQ,CAAE,QAAS,6BAA8B,EACjD,OAAQ,CAAE,QAAS,qDAAsD,CAC3E,EAEK,MAAME,UAAsC,qBAAwD,CACzG,YAAYG,EAA4D,CACtE,MAAM,CAAE,IAAK,gCAAiC,GAAGA,CAAK,CAAC,CACzD,CACF,CAOO,MAAMJ,CAOb,CAUE,YAA6BI,EAAoC,CAApC,UAAAA,CAAqC,CATzD,KAAO,oBAEC,OAAS,CACxB,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EAIA,SAAgB,CACd,KAAM,CAAE,QAAAC,CAAQ,EAAI,KAAK,KACzB,OAAO,IAAI,cAAY,KAAK,MAAM,EAAE,qBAAqBA,CAAO,EAAE,MAAM,CAC1E,CAEA,cAAcC,EAA4D,CACxE,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAC1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAME,EAAYD,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBE,EAAWT,CAA2B,KACpD,wBAAqB,CAC1B,MAAO,IAAIE,EAA8B,CACvC,GAAGF,EAA4BS,CAAS,EACxC,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOF,CAAY,CACtD,CAAC,CACH,CAEA,MAAMG,EAAiBF,EAAO,iBAAiB,EAC/C,GAAIE,IAAmB,OACrB,SAAO,wBAAqB,CAC1B,MAAO,IAAI,yBAAuB,oCAAoC,CACxE,CAAC,EAGH,IAAIC,EAAoB,GACpBC,EAAwB,GACxBC,EAAoB,GACpBC,EAAO,GAEX,GAAIJ,IAAmB,EAAG,CACxB,MAAMK,EAA0BP,EAAO,iBAAiB,EACxD,GAAIO,IAA4B,OAC9B,SAAO,wBAAqB,CAC1B,MAAO,IAAI,yBACT,uCACF,CACF,CAAC,EAEHJ,EAAoBI,EAAwB,SAAS,EAAE,EAMvD,MAAMC,EAAuBR,EAAO,iBAAiB,EACrD,GAAIQ,IAAyB,OAC3B,SAAO,wBAAqB,CAC1B,MAAO,IAAI,yBACT,0CACF,CACF,CAAC,EAGHJ,GAAyBI,EAAuB,KAAO,EACvDH,GAAqBG,EAAuB,KAAO,EACnDF,EAAON,EAAO,mBAAmBA,EAAO,qBAAqB,EAAI,CAAC,CACpE,CAEA,SAAO,wBAAqB,CAC1B,KAAM,CACJ,YAAaE,EACb,eAAgBC,EAChB,YAAaC,EACb,QAASC,EACT,YAAaC,CACf,CACF,CAAC,CACH,CACF",
+  "names": ["GetAppStorageInfoCommand_exports", "__export", "GET_APP_STORAGE_INFO_ERRORS", "GetAppStorageInfoCommand", "GetAppStorageInfoCommandError", "__toCommonJS", "import_device_management_kit", "args", "appName", "apduResponse", "parser", "errorCode", "appStorageSize", "appStorageVersion", "hasAppStorageSettings", "hasAppStorageData", "hash", "appStorageVersionNumber", "appStorageProperties"]
+}

package/lib/cjs/api/command/OsUpdate/Backup/GetAppStorageInfoCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("@ledgerhq/device-management-kit"),s=require("./GetAppStorageInfoCommand");describe("GetAppStorageInfoCommand",()=>{describe("Name",()=>{it("name should be 'GetAppStorageInfo'",()=>{const t=new s.GetAppStorageInfoCommand({appName:"MyApp"}).name;expect(t).toBe("GetAppStorageInfo")})}),describe("Command",()=>{it("should return the correct APDU for getting the app storage info",()=>{const r=Uint8Array.from([224,106,0,0,5,77,121,65,112,112]),t=new s.GetAppStorageInfoCommand({appName:"MyApp"}).getApdu();expect(t.getRawApdu()).toEqual(r)})}),describe("Success response",()=>{it("should return correct app storage info when app storage size is not 0",()=>{const r=Uint8Array.from([144,0]),t=new e.ApduResponse({statusCode:r,data:Uint8Array.from([0,0,0,1,0,0,0,1,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1])}),a=new s.GetAppStorageInfoCommand({appName:"MyApp"}).parseResponse(t);expect((0,e.isSuccessCommandResult)(a)).toBe(!0),expect(a).toEqual({data:{storageSize:1,storageVersion:"1",hasSettings:!0,hasData:!0,storageHash:"0000000000000000000000000000000000000000000000000000000000000001"},status:"SUCCESS"})}),it("should return correct app storage info when app storage size is 0",()=>{const r=Uint8Array.from([144,0]),t=new e.ApduResponse({statusCode:r,data:Uint8Array.from([0,0,0,0])}),a=new s.GetAppStorageInfoCommand({appName:"MyApp"}).parseResponse(t);expect((0,e.isSuccessCommandResult)(a)).toBe(!0),expect(a).toEqual({data:{storageSize:0,storageVersion:"",hasSettings:!1,hasData:!1,storageHash:""},status:"SUCCESS"})})}),describe("Error response",()=>{it.each([{description:"application is not found",statusCode:[81,35],expectedMessage:"Application not found."},{description:"device is in recovery mode",statusCode:[102,47],expectedMessage:"Device is in recovery mode."},{description:"application name length is invalid",statusCode:[103,10],expectedMessage:"Invalid application name length, two chars minimum."},{description:"error code is not specific to GetAppStorageInfoCommand (global error)",statusCode:[85,21],expectedMessage:"Device is locked."}])("should return error when $description",({statusCode:r,expectedMessage:t})=>{const a=new e.ApduResponse({statusCode:Uint8Array.from(r),data:new Uint8Array([])}),o=new s.GetAppStorageInfoCommand({appName:"MyApp"}).parseResponse(a);expect((0,e.isSuccessCommandResult)(o)).toBe(!1),expect(o.error.message).toBe(t)}),it.each([{description:"app storage size extraction fails",data:new Uint8Array([]),expectedOriginalMessage:"Failed to extract app storage size"},{description:"app storage version extraction fails",data:Uint8Array.from([0,0,0,1]),expectedOriginalMessage:"Failed to extract app storage version"},{description:"app storage properties extraction fails",data:Uint8Array.from([0,0,0,1,0,0,0,1]),expectedOriginalMessage:"Failed to extract app storage properties"}])("should return error when $description",({data:r,expectedOriginalMessage:t})=>{const a=new e.ApduResponse({statusCode:Uint8Array.from([144,0]),data:r}),o=new s.GetAppStorageInfoCommand({appName:"MyApp"}).parseResponse(a);expect((0,e.isSuccessCommandResult)(o)).toBe(!1),expect(o.error).toBeInstanceOf(e.InvalidStatusWordError),expect(o.error.originalError?.message).toBe(t)})})});
+//# sourceMappingURL=GetAppStorageInfoCommand.test.js.map

package/lib/cjs/api/command/OsUpdate/Backup/GetAppStorageInfoCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Backup/GetAppStorageInfoCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { GetAppStorageInfoCommand } from \"./GetAppStorageInfoCommand\";\n\ndescribe(\"GetAppStorageInfoCommand\", () => {\n  describe(\"Name\", () => {\n    it(\"name should be 'GetAppStorageInfo'\", () => {\n      // ARRANGE\n      const command = new GetAppStorageInfoCommand({ appName: \"MyApp\" });\n\n      // ACT\n      const name = command.name;\n\n      // ASSERT\n      expect(name).toBe(\"GetAppStorageInfo\");\n    });\n  });\n\n  describe(\"Command\", () => {\n    it(\"should return the correct APDU for getting the app storage info\", () => {\n      // ARRANGE\n      const expectedApdu = Uint8Array.from([\n        0xe0, 0x6a, 0x00, 0x00, 0x05, 0x4d, 0x79, 0x41, 0x70, 0x70,\n      ]);\n\n      // ACT\n      const apdu = new GetAppStorageInfoCommand({ appName: \"MyApp\" }).getApdu();\n\n      // ASSERT\n      expect(apdu.getRawApdu()).toEqual(expectedApdu);\n    });\n  });\n\n  describe(\"Success response\", () => {\n    it(\"should return correct app storage info when app storage size is not 0\", () => {\n      // ARRANGE\n      const statusCode = Uint8Array.from([0x90, 0x00]);\n      const response = new ApduResponse({\n        statusCode,\n        data: Uint8Array.from([\n          // appStorageSize (32-bit BE) = 1\n          0x00, 0x00, 0x00, 0x01,\n          // appStorageVersion (32-bit BE) = 1\n          0x00, 0x00, 0x00, 0x01,\n          // appStorageProperties (16-bit BE) = 0x0003 (bits 0 and 1 set)\n          0x00, 0x03,\n          // appStorageHash (32 bytes)\n          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\n        ]),\n      });\n\n      // ACT\n      const result = new GetAppStorageInfoCommand({\n        appName: \"MyApp\",\n      }).parseResponse(response);\n\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual({\n        data: {\n          storageSize: 1,\n          storageVersion: \"1\",\n          hasSettings: true,\n          hasData: true,\n          storageHash:\n            \"0000000000000000000000000000000000000000000000000000000000000001\",\n        },\n        status: \"SUCCESS\",\n      });\n    });\n\n    it(\"should return correct app storage info when app storage size is 0\", () => {\n      // ARRANGE\n      const statusCode = Uint8Array.from([0x90, 0x00]);\n      const response = new ApduResponse({\n        statusCode,\n        data: Uint8Array.from([\n          // appStorageSize (32-bit BE) = 0\n          0x00, 0x00, 0x00, 0x00,\n        ]),\n      });\n\n      // ACT\n      const result = new GetAppStorageInfoCommand({\n        appName: \"MyApp\",\n      }).parseResponse(response);\n\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual({\n        data: {\n          storageSize: 0,\n          storageVersion: \"\",\n          hasSettings: false,\n          hasData: false,\n          storageHash: \"\",\n        },\n        status: \"SUCCESS\",\n      });\n    });\n  });\n\n  describe(\"Error response\", () => {\n    it.each([\n      {\n        description: \"application is not found\",\n        statusCode: [0x51, 0x23],\n        expectedMessage: \"Application not found.\",\n      },\n      {\n        description: \"device is in recovery mode\",\n        statusCode: [0x66, 0x2f],\n        expectedMessage: \"Device is in recovery mode.\",\n      },\n      {\n        description: \"application name length is invalid\",\n        statusCode: [0x67, 0x0a],\n        expectedMessage: \"Invalid application name length, two chars minimum.\",\n      },\n      {\n        description:\n          \"error code is not specific to GetAppStorageInfoCommand (global error)\",\n        statusCode: [0x55, 0x15],\n        expectedMessage: \"Device is locked.\",\n      },\n    ])(\n      \"should return error when $description\",\n      ({ statusCode, expectedMessage }) => {\n        // ARRANGE\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from(statusCode),\n          data: new Uint8Array([]),\n        });\n\n        // ACT\n        const result = new GetAppStorageInfoCommand({\n          appName: \"MyApp\",\n        }).parseResponse(response);\n\n        // ASSERT\n        expect(isSuccessCommandResult(result)).toBe(false);\n        expect((result as unknown as { error: Error }).error.message).toBe(\n          expectedMessage,\n        );\n      },\n    );\n\n    it.each([\n      {\n        description: \"app storage size extraction fails\",\n        data: new Uint8Array([]),\n        expectedOriginalMessage: \"Failed to extract app storage size\",\n      },\n      {\n        description: \"app storage version extraction fails\",\n        data: Uint8Array.from([0x00, 0x00, 0x00, 0x01]),\n        expectedOriginalMessage: \"Failed to extract app storage version\",\n      },\n      {\n        description: \"app storage properties extraction fails\",\n        data: Uint8Array.from([0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01]),\n        expectedOriginalMessage: \"Failed to extract app storage properties\",\n      },\n    ])(\n      \"should return error when $description\",\n      ({ data, expectedOriginalMessage }) => {\n        // ARRANGE\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data,\n        });\n\n        // ACT\n        const result = new GetAppStorageInfoCommand({\n          appName: \"MyApp\",\n        }).parseResponse(response);\n\n        // ASSERT\n        expect(isSuccessCommandResult(result)).toBe(false);\n        expect(\n          (result as unknown as { error: InvalidStatusWordError }).error,\n        ).toBeInstanceOf(InvalidStatusWordError);\n        expect(\n          (result as unknown as { error: InvalidStatusWordError }).error\n            .originalError?.message,\n        ).toBe(expectedOriginalMessage);\n      },\n    );\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAIO,2CAEPC,EAAyC,sCAEzC,SAAS,2BAA4B,IAAM,CACzC,SAAS,OAAQ,IAAM,CACrB,GAAG,qCAAsC,IAAM,CAK7C,MAAMC,EAHU,IAAI,2BAAyB,CAAE,QAAS,OAAQ,CAAC,EAG5C,KAGrB,OAAOA,CAAI,EAAE,KAAK,mBAAmB,CACvC,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,kEAAmE,IAAM,CAE1E,MAAMC,EAAe,WAAW,KAAK,CACnC,IAAM,IAAM,EAAM,EAAM,EAAM,GAAM,IAAM,GAAM,IAAM,GACxD,CAAC,EAGKC,EAAO,IAAI,2BAAyB,CAAE,QAAS,OAAQ,CAAC,EAAE,QAAQ,EAGxE,OAAOA,EAAK,WAAW,CAAC,EAAE,QAAQD,CAAY,CAChD,CAAC,CACH,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,wEAAyE,IAAM,CAEhF,MAAME,EAAa,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACzCC,EAAW,IAAI,eAAa,CAChC,WAAAD,EACA,KAAM,WAAW,KAAK,CAEpB,EAAM,EAAM,EAAM,EAElB,EAAM,EAAM,EAAM,EAElB,EAAM,EAEN,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAC5D,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAC5D,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CACxD,CAAC,CACH,CAAC,EAGKE,EAAS,IAAI,2BAAyB,CAC1C,QAAS,OACX,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQ,CACrB,KAAM,CACJ,YAAa,EACb,eAAgB,IAChB,YAAa,GACb,QAAS,GACT,YACE,kEACJ,EACA,OAAQ,SACV,CAAC,CACH,CAAC,EAED,GAAG,oEAAqE,IAAM,CAE5E,MAAMF,EAAa,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACzCC,EAAW,IAAI,eAAa,CAChC,WAAAD,EACA,KAAM,WAAW,KAAK,CAEpB,EAAM,EAAM,EAAM,CACpB,CAAC,CACH,CAAC,EAGKE,EAAS,IAAI,2BAAyB,CAC1C,QAAS,OACX,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQ,CACrB,KAAM,CACJ,YAAa,EACb,eAAgB,GAChB,YAAa,GACb,QAAS,GACT,YAAa,EACf,EACA,OAAQ,SACV,CAAC,CACH,CAAC,CACH,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,KAAK,CACN,CACE,YAAa,2BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,wBACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,6BACnB,EACA,CACE,YAAa,qCACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,qDACnB,EACA,CACE,YACE,wEACF,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,mBACnB,CACF,CAAC,EACC,wCACA,CAAC,CAAE,WAAAF,EAAY,gBAAAG,CAAgB,IAAM,CAEnC,MAAMF,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAKD,CAAU,EACtC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKE,EAAS,IAAI,2BAAyB,CAC1C,QAAS,OACX,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAK,EACjD,OAAQA,EAAuC,MAAM,OAAO,EAAE,KAC5DC,CACF,CACF,CACF,EAEA,GAAG,KAAK,CACN,CACE,YAAa,oCACb,KAAM,IAAI,WAAW,CAAC,CAAC,EACvB,wBAAyB,oCAC3B,EACA,CACE,YAAa,uCACb,KAAM,WAAW,KAAK,CAAC,EAAM,EAAM,EAAM,CAAI,CAAC,EAC9C,wBAAyB,uCAC3B,EACA,CACE,YAAa,0CACb,KAAM,WAAW,KAAK,CAAC,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,EACtE,wBAAyB,0CAC3B,CACF,CAAC,EACC,wCACA,CAAC,CAAE,KAAAC,EAAM,wBAAAC,CAAwB,IAAM,CAErC,MAAMJ,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAAG,CACF,CAAC,EAGKF,EAAS,IAAI,2BAAyB,CAC1C,QAAS,OACX,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAK,EACjD,OACGA,EAAwD,KAC3D,EAAE,eAAe,wBAAsB,EACvC,OACGA,EAAwD,MACtD,eAAe,OACpB,EAAE,KAAKG,CAAuB,CAChC,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_GetAppStorageInfoCommand", "name", "expectedApdu", "apdu", "statusCode", "response", "result", "expectedMessage", "data", "expectedOriginalMessage"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/CommitRestoreAppStorageCommand.js

@@ -0,0 +1,2 @@
+"use strict";var s=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var C=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var l=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},g=(o,e,t,m)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of C(e))!i.call(o,a)&&a!==t&&s(o,a,{get:()=>e[a],enumerable:!(m=p(e,a))||m.enumerable});return o};var R=o=>g(s({},"__esModule",{value:!0}),o);var A={};l(A,{COMMIT_RESTORE_APP_STORAGE_ERRORS:()=>d,CommitRestoreAppStorageCommand:()=>u,CommitRestoreAppStorageCommandError:()=>n});module.exports=R(A);var r=require("@ledgerhq/device-management-kit");const d={5123:{message:"Invalid context, restore init must be called first."},5419:{message:"Internal error, crypto operation failed."},"541b":{message:"Failed to verify backup authenticity."},"662f":{message:"Invalid device state, recovery mode."},6734:{message:"Invalid size of the restored app storage."}};class n extends r.DeviceExchangeError{constructor(e){super({tag:"CommitRestoreAppStorageCommandError",...e})}}class u{name="CommitRestoreAppStorage";header={cla:224,ins:110,p1:0,p2:0};getApdu(){return new r.ApduBuilder(this.header).build()}parseResponse(e){const t=new r.ApduParser(e);if(!r.CommandUtils.isSuccessResponse(e)){const m=t.encodeToHexaString(e.statusCode);return(0,r.isCommandErrorCode)(m,d)?(0,r.CommandResultFactory)({error:new n({...d[m],errorCode:m})}):(0,r.CommandResultFactory)({error:r.GlobalCommandErrorHandler.handle(e)})}return(0,r.CommandResultFactory)({data:void 0})}}0&&(module.exports={COMMIT_RESTORE_APP_STORAGE_ERRORS,CommitRestoreAppStorageCommand,CommitRestoreAppStorageCommandError});
+//# sourceMappingURL=CommitRestoreAppStorageCommand.js.map

package/lib/cjs/api/command/OsUpdate/Restore/CommitRestoreAppStorageCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/CommitRestoreAppStorageCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandErrorArgs,\n  type CommandErrors,\n  type CommandResult,\n  CommandResultFactory,\n  CommandUtils,\n  DeviceExchangeError,\n  GlobalCommandErrorHandler,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type CommitRestoreAppStorageCommandErrorCodes =\n  | \"5123\"\n  | \"5419\"\n  | \"541b\"\n  | \"662f\"\n  | \"6734\";\n\nexport const COMMIT_RESTORE_APP_STORAGE_ERRORS: CommandErrors<CommitRestoreAppStorageCommandErrorCodes> =\n  {\n    \"5123\": { message: \"Invalid context, restore init must be called first.\" },\n    \"5419\": { message: \"Internal error, crypto operation failed.\" },\n    \"541b\": { message: \"Failed to verify backup authenticity.\" },\n    \"662f\": { message: \"Invalid device state, recovery mode.\" },\n    \"6734\": { message: \"Invalid size of the restored app storage.\" },\n  };\n\nexport class CommitRestoreAppStorageCommandError extends DeviceExchangeError<CommitRestoreAppStorageCommandErrorCodes> {\n  constructor(\n    args: CommandErrorArgs<CommitRestoreAppStorageCommandErrorCodes>,\n  ) {\n    super({ tag: \"CommitRestoreAppStorageCommandError\", ...args });\n  }\n}\n\nexport type CommitRestoreAppStorageCommandResult = CommandResult<\n  void,\n  CommitRestoreAppStorageCommandErrorCodes\n>;\n\nexport class CommitRestoreAppStorageCommand\n  implements Command<void, void, CommitRestoreAppStorageCommandErrorCodes>\n{\n  readonly name = \"CommitRestoreAppStorage\";\n\n  private readonly header = {\n    cla: 0xe0,\n    ins: 0x6e,\n    p1: 0x00,\n    p2: 0x00,\n  };\n\n  getApdu(): Apdu {\n    return new ApduBuilder(this.header).build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommitRestoreAppStorageCommandResult {\n    const parser = new ApduParser(apduResponse);\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, COMMIT_RESTORE_APP_STORAGE_ERRORS)) {\n        return CommandResultFactory({\n          error: new CommitRestoreAppStorageCommandError({\n            ...COMMIT_RESTORE_APP_STORAGE_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    return CommandResultFactory({\n      data: undefined,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uCAAAE,EAAA,mCAAAC,EAAA,wCAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAcO,2CASA,MAAMJ,EACX,CACE,KAAQ,CAAE,QAAS,qDAAsD,EACzE,KAAQ,CAAE,QAAS,0CAA2C,EAC9D,OAAQ,CAAE,QAAS,uCAAwC,EAC3D,OAAQ,CAAE,QAAS,sCAAuC,EAC1D,KAAQ,CAAE,QAAS,2CAA4C,CACjE,EAEK,MAAME,UAA4C,qBAA8D,CACrH,YACEG,EACA,CACA,MAAM,CAAE,IAAK,sCAAuC,GAAGA,CAAK,CAAC,CAC/D,CACF,CAOO,MAAMJ,CAEb,CACW,KAAO,0BAEC,OAAS,CACxB,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EAEA,SAAgB,CACd,OAAO,IAAI,cAAY,KAAK,MAAM,EAAE,MAAM,CAC5C,CAEA,cACEK,EACsC,CACtC,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAC1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAME,EAAYD,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBE,EAAWR,CAAiC,KAC1D,wBAAqB,CAC1B,MAAO,IAAIE,EAAoC,CAC7C,GAAGF,EAAkCQ,CAAS,EAC9C,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOF,CAAY,CACtD,CAAC,CACH,CAEA,SAAO,wBAAqB,CAC1B,KAAM,MACR,CAAC,CACH,CACF",
+  "names": ["CommitRestoreAppStorageCommand_exports", "__export", "COMMIT_RESTORE_APP_STORAGE_ERRORS", "CommitRestoreAppStorageCommand", "CommitRestoreAppStorageCommandError", "__toCommonJS", "import_device_management_kit", "args", "apduResponse", "parser", "errorCode"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/CommitRestoreAppStorageCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var s=require("@ledgerhq/device-management-kit"),o=require("./CommitRestoreAppStorageCommand");describe("CommitRestoreAppStorageCommand",()=>{describe("Name",()=>{it("name should be 'CommitRestoreAppStorage'",()=>{const e=new o.CommitRestoreAppStorageCommand().name;expect(e).toBe("CommitRestoreAppStorage")})}),describe("Command",()=>{it("should return the correct APDU for committing an app storage restore",()=>{const t=Uint8Array.from([224,110,0,0,0]),e=new o.CommitRestoreAppStorageCommand().getApdu();expect(e.getRawApdu()).toEqual(t)})}),describe("Success response",()=>{it("should return a success result",()=>{const t=new s.ApduResponse({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),e=new o.CommitRestoreAppStorageCommand().parseResponse(t);expect((0,s.isSuccessCommandResult)(e)).toBe(!0),expect(e).toEqual({data:void 0,status:"SUCCESS"})})}),describe("Error response",()=>{it.each([{description:"restore init has not been called",statusCode:[81,35],expectedMessage:"Invalid context, restore init must be called first."},{description:"crypto operation failed",statusCode:[84,25],expectedMessage:"Internal error, crypto operation failed."},{description:"backup authenticity verification failed",statusCode:[84,27],expectedMessage:"Failed to verify backup authenticity."},{description:"device is in recovery mode",statusCode:[102,47],expectedMessage:"Invalid device state, recovery mode."},{description:"restored app storage size is invalid",statusCode:[103,52],expectedMessage:"Invalid size of the restored app storage."},{description:"error code is not specific to CommitRestoreAppStorageCommand (global error)",statusCode:[85,21],expectedMessage:"Device is locked."}])("should return error when $description",({statusCode:t,expectedMessage:e})=>{const a=new s.ApduResponse({statusCode:Uint8Array.from(t),data:new Uint8Array([])}),r=new o.CommitRestoreAppStorageCommand().parseResponse(a);expect((0,s.isSuccessCommandResult)(r)).toBe(!1),expect(r.error.message).toBe(e)})})});
+//# sourceMappingURL=CommitRestoreAppStorageCommand.test.js.map

package/lib/cjs/api/command/OsUpdate/Restore/CommitRestoreAppStorageCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/CommitRestoreAppStorageCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { CommitRestoreAppStorageCommand } from \"./CommitRestoreAppStorageCommand\";\n\ndescribe(\"CommitRestoreAppStorageCommand\", () => {\n  describe(\"Name\", () => {\n    it(\"name should be 'CommitRestoreAppStorage'\", () => {\n      // ARRANGE\n      const command = new CommitRestoreAppStorageCommand();\n\n      // ACT\n      const name = command.name;\n\n      // ASSERT\n      expect(name).toBe(\"CommitRestoreAppStorage\");\n    });\n  });\n\n  describe(\"Command\", () => {\n    it(\"should return the correct APDU for committing an app storage restore\", () => {\n      // ARRANGE\n      const expectedApdu = Uint8Array.from([0xe0, 0x6e, 0x00, 0x00, 0x00]);\n\n      // ACT\n      const apdu = new CommitRestoreAppStorageCommand().getApdu();\n\n      // ASSERT\n      expect(apdu.getRawApdu()).toEqual(expectedApdu);\n    });\n  });\n\n  describe(\"Success response\", () => {\n    it(\"should return a success result\", () => {\n      // ARRANGE\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      });\n\n      // ACT\n      const result = new CommitRestoreAppStorageCommand().parseResponse(\n        response,\n      );\n\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual({\n        data: undefined,\n        status: \"SUCCESS\",\n      });\n    });\n  });\n\n  describe(\"Error response\", () => {\n    it.each([\n      {\n        description: \"restore init has not been called\",\n        statusCode: [0x51, 0x23],\n        expectedMessage: \"Invalid context, restore init must be called first.\",\n      },\n      {\n        description: \"crypto operation failed\",\n        statusCode: [0x54, 0x19],\n        expectedMessage: \"Internal error, crypto operation failed.\",\n      },\n      {\n        description: \"backup authenticity verification failed\",\n        statusCode: [0x54, 0x1b],\n        expectedMessage: \"Failed to verify backup authenticity.\",\n      },\n      {\n        description: \"device is in recovery mode\",\n        statusCode: [0x66, 0x2f],\n        expectedMessage: \"Invalid device state, recovery mode.\",\n      },\n      {\n        description: \"restored app storage size is invalid\",\n        statusCode: [0x67, 0x34],\n        expectedMessage: \"Invalid size of the restored app storage.\",\n      },\n      {\n        description:\n          \"error code is not specific to CommitRestoreAppStorageCommand (global error)\",\n        statusCode: [0x55, 0x15],\n        expectedMessage: \"Device is locked.\",\n      },\n    ])(\n      \"should return error when $description\",\n      ({ statusCode, expectedMessage }) => {\n        // ARRANGE\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from(statusCode),\n          data: new Uint8Array([]),\n        });\n\n        // ACT\n        const result = new CommitRestoreAppStorageCommand().parseResponse(\n          response,\n        );\n\n        // ASSERT\n        expect(isSuccessCommandResult(result)).toBe(false);\n        expect((result as unknown as { error: Error }).error.message).toBe(\n          expectedMessage,\n        );\n      },\n    );\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAGO,2CAEPC,EAA+C,4CAE/C,SAAS,iCAAkC,IAAM,CAC/C,SAAS,OAAQ,IAAM,CACrB,GAAG,2CAA4C,IAAM,CAKnD,MAAMC,EAHU,IAAI,iCAA+B,EAG9B,KAGrB,OAAOA,CAAI,EAAE,KAAK,yBAAyB,CAC7C,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,uEAAwE,IAAM,CAE/E,MAAMC,EAAe,WAAW,KAAK,CAAC,IAAM,IAAM,EAAM,EAAM,CAAI,CAAC,EAG7DC,EAAO,IAAI,iCAA+B,EAAE,QAAQ,EAG1D,OAAOA,EAAK,WAAW,CAAC,EAAE,QAAQD,CAAY,CAChD,CAAC,CACH,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,iCAAkC,IAAM,CAEzC,MAAME,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKC,EAAS,IAAI,iCAA+B,EAAE,cAClDD,CACF,EAGA,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQ,CACrB,KAAM,OACN,OAAQ,SACV,CAAC,CACH,CAAC,CACH,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,KAAK,CACN,CACE,YAAa,mCACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,qDACnB,EACA,CACE,YAAa,0BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,0CACnB,EACA,CACE,YAAa,0CACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,uCACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,sCACnB,EACA,CACE,YAAa,uCACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,2CACnB,EACA,CACE,YACE,8EACF,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,mBACnB,CACF,CAAC,EACC,wCACA,CAAC,CAAE,WAAAC,EAAY,gBAAAC,CAAgB,IAAM,CAEnC,MAAMH,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAKE,CAAU,EACtC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKD,EAAS,IAAI,iCAA+B,EAAE,cAClDD,CACF,EAGA,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAK,EACjD,OAAQA,EAAuC,MAAM,OAAO,EAAE,KAC5DE,CACF,CACF,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_CommitRestoreAppStorageCommand", "name", "expectedApdu", "apdu", "response", "result", "statusCode", "expectedMessage"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/InitRestoreAppStorageCommand.js

@@ -0,0 +1,2 @@
+"use strict";var s=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var C=(o,e)=>{for(var t in e)s(o,t,{get:e[t],enumerable:!0})},A=(o,e,t,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of i(e))!g.call(o,n)&&n!==t&&s(o,n,{get:()=>e[n],enumerable:!(a=d(e,n))||a.enumerable});return o};var l=o=>A(s({},"__esModule",{value:!0}),o);var u={};C(u,{INIT_RESTORE_APP_STORAGE_ERRORS:()=>p,InitRestoreAppStorageCommand:()=>c,InitRestoreAppStorageCommandError:()=>m});module.exports=l(u);var r=require("@ledgerhq/device-management-kit");const p={5123:{message:"Application not found."},"662f":{message:"Invalid device state, recovery mode."},5501:{message:"Invalid consent, user rejected."},5502:{message:"Invalid consent, pin is not set."},"670a":{message:"Invalid application name length, two chars minimum."},6733:{message:"Invalid backup length value."}};class m extends r.DeviceExchangeError{constructor(e){super({tag:"InitRestoreAppStorageCommandError",...e})}}class c{constructor(e){this.args=e}name="InitRestoreAppStorage";header={cla:224,ins:108,p1:0,p2:0};getApdu(){const{appName:e,appStorageDataLength:t}=this.args;return new r.ApduBuilder(this.header).add32BitUIntToData(t).addAsciiStringToData(e).build()}parseResponse(e){const t=new r.ApduParser(e);if(!r.CommandUtils.isSuccessResponse(e)){const a=t.encodeToHexaString(e.statusCode);return(0,r.isCommandErrorCode)(a,p)?(0,r.CommandResultFactory)({error:new m({...p[a],errorCode:a})}):(0,r.CommandResultFactory)({error:r.GlobalCommandErrorHandler.handle(e)})}return(0,r.CommandResultFactory)({data:void 0})}}0&&(module.exports={INIT_RESTORE_APP_STORAGE_ERRORS,InitRestoreAppStorageCommand,InitRestoreAppStorageCommandError});
+//# sourceMappingURL=InitRestoreAppStorageCommand.js.map

package/lib/cjs/api/command/OsUpdate/Restore/InitRestoreAppStorageCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/InitRestoreAppStorageCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandErrorArgs,\n  type CommandErrors,\n  type CommandResult,\n  CommandResultFactory,\n  CommandUtils,\n  DeviceExchangeError,\n  GlobalCommandErrorHandler,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type InitRestoreAppStorageCommandArgs = {\n  appName: string;\n  appStorageDataLength: number;\n};\n\nexport type InitRestoreAppStorageCommandErrorCodes =\n  | \"5123\"\n  | \"662f\"\n  | \"5501\"\n  | \"5502\"\n  | \"670a\"\n  | \"6733\";\n\nexport const INIT_RESTORE_APP_STORAGE_ERRORS: CommandErrors<InitRestoreAppStorageCommandErrorCodes> =\n  {\n    \"5123\": { message: \"Application not found.\" },\n    \"662f\": { message: \"Invalid device state, recovery mode.\" },\n    \"5501\": { message: \"Invalid consent, user rejected.\" },\n    \"5502\": { message: \"Invalid consent, pin is not set.\" },\n    \"670a\": { message: \"Invalid application name length, two chars minimum.\" },\n    \"6733\": { message: \"Invalid backup length value.\" },\n  };\n\nexport class InitRestoreAppStorageCommandError extends DeviceExchangeError<InitRestoreAppStorageCommandErrorCodes> {\n  constructor(args: CommandErrorArgs<InitRestoreAppStorageCommandErrorCodes>) {\n    super({ tag: \"InitRestoreAppStorageCommandError\", ...args });\n  }\n}\n\nexport type InitRestoreAppStorageCommandResult = CommandResult<\n  void,\n  InitRestoreAppStorageCommandErrorCodes\n>;\n\nexport class InitRestoreAppStorageCommand\n  implements\n    Command<\n      void,\n      InitRestoreAppStorageCommandArgs,\n      InitRestoreAppStorageCommandErrorCodes\n    >\n{\n  readonly name = \"InitRestoreAppStorage\";\n\n  private readonly header = {\n    cla: 0xe0,\n    ins: 0x6c,\n    p1: 0x00,\n    p2: 0x00,\n  };\n\n  constructor(private readonly args: InitRestoreAppStorageCommandArgs) {}\n\n  getApdu(): Apdu {\n    const { appName, appStorageDataLength } = this.args;\n    return new ApduBuilder(this.header)\n      .add32BitUIntToData(appStorageDataLength)\n      .addAsciiStringToData(appName)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): InitRestoreAppStorageCommandResult {\n    const parser = new ApduParser(apduResponse);\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, INIT_RESTORE_APP_STORAGE_ERRORS)) {\n        return CommandResultFactory({\n          error: new InitRestoreAppStorageCommandError({\n            ...INIT_RESTORE_APP_STORAGE_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    return CommandResultFactory({\n      data: undefined,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,qCAAAE,EAAA,iCAAAC,EAAA,sCAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAcO,2CAeA,MAAMJ,EACX,CACE,KAAQ,CAAE,QAAS,wBAAyB,EAC5C,OAAQ,CAAE,QAAS,sCAAuC,EAC1D,KAAQ,CAAE,QAAS,iCAAkC,EACrD,KAAQ,CAAE,QAAS,kCAAmC,EACtD,OAAQ,CAAE,QAAS,qDAAsD,EACzE,KAAQ,CAAE,QAAS,8BAA+B,CACpD,EAEK,MAAME,UAA0C,qBAA4D,CACjH,YAAYG,EAAgE,CAC1E,MAAM,CAAE,IAAK,oCAAqC,GAAGA,CAAK,CAAC,CAC7D,CACF,CAOO,MAAMJ,CAOb,CAUE,YAA6BI,EAAwC,CAAxC,UAAAA,CAAyC,CAT7D,KAAO,wBAEC,OAAS,CACxB,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EAIA,SAAgB,CACd,KAAM,CAAE,QAAAC,EAAS,qBAAAC,CAAqB,EAAI,KAAK,KAC/C,OAAO,IAAI,cAAY,KAAK,MAAM,EAC/B,mBAAmBA,CAAoB,EACvC,qBAAqBD,CAAO,EAC5B,MAAM,CACX,CAEA,cACEE,EACoC,CACpC,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAC1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAME,EAAYD,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBE,EAAWV,CAA+B,KACxD,wBAAqB,CAC1B,MAAO,IAAIE,EAAkC,CAC3C,GAAGF,EAAgCU,CAAS,EAC5C,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOF,CAAY,CACtD,CAAC,CACH,CAEA,SAAO,wBAAqB,CAC1B,KAAM,MACR,CAAC,CACH,CACF",
+  "names": ["InitRestoreAppStorageCommand_exports", "__export", "INIT_RESTORE_APP_STORAGE_ERRORS", "InitRestoreAppStorageCommand", "InitRestoreAppStorageCommandError", "__toCommonJS", "import_device_management_kit", "args", "appName", "appStorageDataLength", "apduResponse", "parser", "errorCode"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/InitRestoreAppStorageCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var s=require("@ledgerhq/device-management-kit"),a=require("./InitRestoreAppStorageCommand");describe("InitRestoreAppStorageCommand",()=>{describe("Name",()=>{it("name should be 'InitRestoreAppStorage'",()=>{const e=new a.InitRestoreAppStorageCommand({appName:"MyApp",appStorageDataLength:10}).name;expect(e).toBe("InitRestoreAppStorage")})}),describe("Command",()=>{it("should return the correct APDU for initializing an app storage restore",()=>{const t=Uint8Array.from([224,108,0,0,9,0,0,0,10,77,121,65,112,112]),e=new a.InitRestoreAppStorageCommand({appName:"MyApp",appStorageDataLength:10}).getApdu();expect(e.getRawApdu()).toEqual(t)})}),describe("Success response",()=>{it("should return a success result",()=>{const t=new s.ApduResponse({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),e=new a.InitRestoreAppStorageCommand({appName:"MyApp",appStorageDataLength:10}).parseResponse(t);expect((0,s.isSuccessCommandResult)(e)).toBe(!0),expect(e).toEqual({data:void 0,status:"SUCCESS"})})}),describe("Error response",()=>{it.each([{description:"application is not found",statusCode:[81,35],expectedMessage:"Application not found."},{description:"device is in recovery mode",statusCode:[102,47],expectedMessage:"Invalid device state, recovery mode."},{description:"user rejected the consent",statusCode:[85,1],expectedMessage:"Invalid consent, user rejected."},{description:"pin is not set",statusCode:[85,2],expectedMessage:"Invalid consent, pin is not set."},{description:"application name length is invalid",statusCode:[103,10],expectedMessage:"Invalid application name length, two chars minimum."},{description:"backup length value is invalid",statusCode:[103,51],expectedMessage:"Invalid backup length value."},{description:"error code is not specific to InitRestoreAppStorageCommand (global error)",statusCode:[85,21],expectedMessage:"Device is locked."}])("should return error when $description",({statusCode:t,expectedMessage:e})=>{const n=new s.ApduResponse({statusCode:Uint8Array.from(t),data:new Uint8Array([])}),o=new a.InitRestoreAppStorageCommand({appName:"MyApp",appStorageDataLength:10}).parseResponse(n);expect((0,s.isSuccessCommandResult)(o)).toBe(!1),expect(o.error.message).toBe(e)})})});
+//# sourceMappingURL=InitRestoreAppStorageCommand.test.js.map

package/lib/cjs/api/command/OsUpdate/Restore/InitRestoreAppStorageCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/InitRestoreAppStorageCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { InitRestoreAppStorageCommand } from \"./InitRestoreAppStorageCommand\";\n\ndescribe(\"InitRestoreAppStorageCommand\", () => {\n  describe(\"Name\", () => {\n    it(\"name should be 'InitRestoreAppStorage'\", () => {\n      // ARRANGE\n      const command = new InitRestoreAppStorageCommand({\n        appName: \"MyApp\",\n        appStorageDataLength: 10,\n      });\n\n      // ACT\n      const name = command.name;\n\n      // ASSERT\n      expect(name).toBe(\"InitRestoreAppStorage\");\n    });\n  });\n\n  describe(\"Command\", () => {\n    it(\"should return the correct APDU for initializing an app storage restore\", () => {\n      // ARRANGE\n      const expectedApdu = Uint8Array.from([\n        0xe0, 0x6c, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x0a, 0x4d, 0x79, 0x41,\n        0x70, 0x70,\n      ]);\n\n      // ACT\n      const apdu = new InitRestoreAppStorageCommand({\n        appName: \"MyApp\",\n        appStorageDataLength: 10,\n      }).getApdu();\n\n      // ASSERT\n      expect(apdu.getRawApdu()).toEqual(expectedApdu);\n    });\n  });\n\n  describe(\"Success response\", () => {\n    it(\"should return a success result\", () => {\n      // ARRANGE\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      });\n\n      // ACT\n      const result = new InitRestoreAppStorageCommand({\n        appName: \"MyApp\",\n        appStorageDataLength: 10,\n      }).parseResponse(response);\n\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual({\n        data: undefined,\n        status: \"SUCCESS\",\n      });\n    });\n  });\n\n  describe(\"Error response\", () => {\n    it.each([\n      {\n        description: \"application is not found\",\n        statusCode: [0x51, 0x23],\n        expectedMessage: \"Application not found.\",\n      },\n      {\n        description: \"device is in recovery mode\",\n        statusCode: [0x66, 0x2f],\n        expectedMessage: \"Invalid device state, recovery mode.\",\n      },\n      {\n        description: \"user rejected the consent\",\n        statusCode: [0x55, 0x01],\n        expectedMessage: \"Invalid consent, user rejected.\",\n      },\n      {\n        description: \"pin is not set\",\n        statusCode: [0x55, 0x02],\n        expectedMessage: \"Invalid consent, pin is not set.\",\n      },\n      {\n        description: \"application name length is invalid\",\n        statusCode: [0x67, 0x0a],\n        expectedMessage: \"Invalid application name length, two chars minimum.\",\n      },\n      {\n        description: \"backup length value is invalid\",\n        statusCode: [0x67, 0x33],\n        expectedMessage: \"Invalid backup length value.\",\n      },\n      {\n        description:\n          \"error code is not specific to InitRestoreAppStorageCommand (global error)\",\n        statusCode: [0x55, 0x15],\n        expectedMessage: \"Device is locked.\",\n      },\n    ])(\n      \"should return error when $description\",\n      ({ statusCode, expectedMessage }) => {\n        // ARRANGE\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from(statusCode),\n          data: new Uint8Array([]),\n        });\n\n        // ACT\n        const result = new InitRestoreAppStorageCommand({\n          appName: \"MyApp\",\n          appStorageDataLength: 10,\n        }).parseResponse(response);\n\n        // ASSERT\n        expect(isSuccessCommandResult(result)).toBe(false);\n        expect((result as unknown as { error: Error }).error.message).toBe(\n          expectedMessage,\n        );\n      },\n    );\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAGO,2CAEPC,EAA6C,0CAE7C,SAAS,+BAAgC,IAAM,CAC7C,SAAS,OAAQ,IAAM,CACrB,GAAG,yCAA0C,IAAM,CAQjD,MAAMC,EANU,IAAI,+BAA6B,CAC/C,QAAS,QACT,qBAAsB,EACxB,CAAC,EAGoB,KAGrB,OAAOA,CAAI,EAAE,KAAK,uBAAuB,CAC3C,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,yEAA0E,IAAM,CAEjF,MAAMC,EAAe,WAAW,KAAK,CACnC,IAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,GAAM,GAAM,IAAM,GAClE,IAAM,GACR,CAAC,EAGKC,EAAO,IAAI,+BAA6B,CAC5C,QAAS,QACT,qBAAsB,EACxB,CAAC,EAAE,QAAQ,EAGX,OAAOA,EAAK,WAAW,CAAC,EAAE,QAAQD,CAAY,CAChD,CAAC,CACH,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,iCAAkC,IAAM,CAEzC,MAAME,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKC,EAAS,IAAI,+BAA6B,CAC9C,QAAS,QACT,qBAAsB,EACxB,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQ,CACrB,KAAM,OACN,OAAQ,SACV,CAAC,CACH,CAAC,CACH,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,KAAK,CACN,CACE,YAAa,2BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,wBACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,sCACnB,EACA,CACE,YAAa,4BACb,WAAY,CAAC,GAAM,CAAI,EACvB,gBAAiB,iCACnB,EACA,CACE,YAAa,iBACb,WAAY,CAAC,GAAM,CAAI,EACvB,gBAAiB,kCACnB,EACA,CACE,YAAa,qCACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,qDACnB,EACA,CACE,YAAa,iCACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,8BACnB,EACA,CACE,YACE,4EACF,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,mBACnB,CACF,CAAC,EACC,wCACA,CAAC,CAAE,WAAAC,EAAY,gBAAAC,CAAgB,IAAM,CAEnC,MAAMH,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAKE,CAAU,EACtC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKD,EAAS,IAAI,+BAA6B,CAC9C,QAAS,QACT,qBAAsB,EACxB,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAK,EACjD,OAAQA,EAAuC,MAAM,OAAO,EAAE,KAC5DE,CACF,CACF,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_InitRestoreAppStorageCommand", "name", "expectedApdu", "apdu", "response", "result", "statusCode", "expectedMessage"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/RequestMasterConsentCommand.js

@@ -0,0 +1,2 @@
+"use strict";var a=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var i=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var n in e)a(t,n,{get:e[n],enumerable:!0})},g=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of p(e))!i.call(t,o)&&o!==n&&a(t,o,{get:()=>e[o],enumerable:!(s=C(e,o))||s.enumerable});return t};var c=t=>g(a({},"__esModule",{value:!0}),t);var E={};l(E,{REQUEST_MASTER_CONSENT_ERRORS:()=>d,RequestMasterConsentCommand:()=>R,RequestMasterConsentCommandError:()=>u});module.exports=c(E);var r=require("@ledgerhq/device-management-kit");const d={5501:{message:"Consent failed"},5502:{message:"PIN not validated"}},m=(t,e)=>{if(!Number.isInteger(e)||e<0||e>255)throw new r.InvalidArgumentError(`${t} must be an integer between 0 and 255`)};class u extends r.DeviceExchangeError{constructor(e){super({tag:"RequestMasterConsentCommandError",...e})}}class R{name="RequestMasterConsent";args;header={cla:224,ins:111,p1:0,p2:0};constructor(e){m("appNumber",e.appNumber),m("appStorageNumber",e.appStorageNumber),this.args=e}getApdu(){const e={cla:this.header.cla,ins:this.header.ins,p1:this.header.p1,p2:this.header.p2};return new r.ApduBuilder(e).add8BitUIntToData(this.args.languagePackConsentEnabled?0:1).add8BitUIntToData(this.args.lockScreenPictureConsentEnabled?0:1).add8BitUIntToData(this.args.appNumber).add8BitUIntToData(this.args.appStorageNumber).build()}parseResponse(e){const n=new r.ApduParser(e);if(!r.CommandUtils.isSuccessResponse(e)){const s=n.encodeToHexaString(e.statusCode);return(0,r.isCommandErrorCode)(s,d)?(0,r.CommandResultFactory)({error:new u({...d[s],errorCode:s})}):(0,r.CommandResultFactory)({error:r.GlobalCommandErrorHandler.handle(e)})}return(0,r.CommandResultFactory)({data:void 0})}}0&&(module.exports={REQUEST_MASTER_CONSENT_ERRORS,RequestMasterConsentCommand,RequestMasterConsentCommandError});
+//# sourceMappingURL=RequestMasterConsentCommand.js.map

package/lib/cjs/api/command/OsUpdate/Restore/RequestMasterConsentCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/RequestMasterConsentCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandErrorArgs,\n  type CommandErrors,\n  type CommandResult,\n  CommandResultFactory,\n  CommandUtils,\n  DeviceExchangeError,\n  GlobalCommandErrorHandler,\n  InvalidArgumentError,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type RequestMasterConsentCommandArgs = {\n  languagePackConsentEnabled: boolean;\n  lockScreenPictureConsentEnabled: boolean;\n  appNumber: number;\n  appStorageNumber: number;\n};\nexport type RequestMasterConsentCommandErrorCodes = \"5501\" | \"5502\";\n\nexport type RequestMasterConsentCommandResult = CommandResult<\n  void,\n  RequestMasterConsentCommandErrorCodes\n>;\nexport const REQUEST_MASTER_CONSENT_ERRORS: CommandErrors<RequestMasterConsentCommandErrorCodes> =\n  {\n    \"5501\": { message: \"Consent failed\" },\n    \"5502\": { message: \"PIN not validated\" },\n  };\n\nconst assert8BitUInt = (name: string, value: number) => {\n  if (!Number.isInteger(value) || value < 0x00 || value > 0xff) {\n    throw new InvalidArgumentError(\n      `${name} must be an integer between 0 and 255`,\n    );\n  }\n};\n\nexport class RequestMasterConsentCommandError extends DeviceExchangeError<RequestMasterConsentCommandErrorCodes> {\n  constructor(args: CommandErrorArgs<RequestMasterConsentCommandErrorCodes>) {\n    super({ tag: \"RequestMasterConsentCommandError\", ...args });\n  }\n}\n\nexport class RequestMasterConsentCommand\n  implements\n    Command<\n      void,\n      RequestMasterConsentCommandArgs,\n      RequestMasterConsentCommandErrorCodes\n    >\n{\n  readonly name = \"RequestMasterConsent\";\n\n  readonly args: RequestMasterConsentCommandArgs;\n\n  private readonly header = {\n    cla: 0xe0,\n    ins: 0x6f,\n    p1: 0x00,\n    p2: 0x00,\n  };\n\n  constructor(args: RequestMasterConsentCommandArgs) {\n    assert8BitUInt(\"appNumber\", args.appNumber);\n    assert8BitUInt(\"appStorageNumber\", args.appStorageNumber);\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const apduArgs: ApduBuilderArgs = {\n      cla: this.header.cla,\n      ins: this.header.ins,\n      p1: this.header.p1,\n      p2: this.header.p2,\n    };\n    return new ApduBuilder(apduArgs)\n      .add8BitUIntToData(this.args.languagePackConsentEnabled ? 0x00 : 0x01)\n      .add8BitUIntToData(\n        this.args.lockScreenPictureConsentEnabled ? 0x00 : 0x01,\n      )\n      .add8BitUIntToData(this.args.appNumber)\n      .add8BitUIntToData(this.args.appStorageNumber)\n      .build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): RequestMasterConsentCommandResult {\n    const parser = new ApduParser(apduResponse);\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, REQUEST_MASTER_CONSENT_ERRORS)) {\n        return CommandResultFactory({\n          error: new RequestMasterConsentCommandError({\n            ...REQUEST_MASTER_CONSENT_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    return CommandResultFactory({\n      data: undefined,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mCAAAE,EAAA,gCAAAC,EAAA,qCAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAgBO,2CAcA,MAAMJ,EACX,CACE,KAAQ,CAAE,QAAS,gBAAiB,EACpC,KAAQ,CAAE,QAAS,mBAAoB,CACzC,EAEIK,EAAiB,CAACC,EAAcC,IAAkB,CACtD,GAAI,CAAC,OAAO,UAAUA,CAAK,GAAKA,EAAQ,GAAQA,EAAQ,IACtD,MAAM,IAAI,uBACR,GAAGD,CAAI,uCACT,CAEJ,EAEO,MAAMJ,UAAyC,qBAA2D,CAC/G,YAAYM,EAA+D,CACzE,MAAM,CAAE,IAAK,mCAAoC,GAAGA,CAAK,CAAC,CAC5D,CACF,CAEO,MAAMP,CAOb,CACW,KAAO,uBAEP,KAEQ,OAAS,CACxB,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EAEA,YAAYO,EAAuC,CACjDH,EAAe,YAAaG,EAAK,SAAS,EAC1CH,EAAe,mBAAoBG,EAAK,gBAAgB,EACxD,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,MAAMC,EAA4B,CAChC,IAAK,KAAK,OAAO,IACjB,IAAK,KAAK,OAAO,IACjB,GAAI,KAAK,OAAO,GAChB,GAAI,KAAK,OAAO,EAClB,EACA,OAAO,IAAI,cAAYA,CAAQ,EAC5B,kBAAkB,KAAK,KAAK,2BAA6B,EAAO,CAAI,EACpE,kBACC,KAAK,KAAK,gCAAkC,EAAO,CACrD,EACC,kBAAkB,KAAK,KAAK,SAAS,EACrC,kBAAkB,KAAK,KAAK,gBAAgB,EAC5C,MAAM,CACX,CAEA,cAAcC,EAA+D,CAC3E,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAC1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAME,EAAYD,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBE,EAAWZ,CAA6B,KACtD,wBAAqB,CAC1B,MAAO,IAAIE,EAAiC,CAC1C,GAAGF,EAA8BY,CAAS,EAC1C,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOF,CAAY,CACtD,CAAC,CACH,CAEA,SAAO,wBAAqB,CAC1B,KAAM,MACR,CAAC,CACH,CACF",
+  "names": ["RequestMasterConsentCommand_exports", "__export", "REQUEST_MASTER_CONSENT_ERRORS", "RequestMasterConsentCommand", "RequestMasterConsentCommandError", "__toCommonJS", "import_device_management_kit", "assert8BitUInt", "name", "value", "args", "apduArgs", "apduResponse", "parser", "errorCode"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/RequestMasterConsentCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var r=require("@ledgerhq/device-management-kit"),a=require("./RequestMasterConsentCommand");describe("RequestMasterConsentCommand",()=>{describe("Name",()=>{it("name should be 'RequestMasterConsent'",()=>{const e=new a.RequestMasterConsentCommand({languagePackConsentEnabled:!0,lockScreenPictureConsentEnabled:!0,appNumber:1,appStorageNumber:1});expect(e.name).toBe("RequestMasterConsent")})}),describe("Command",()=>{it("should return the correct APDU for requesting master consent",()=>{const e=new a.RequestMasterConsentCommand({languagePackConsentEnabled:!0,lockScreenPictureConsentEnabled:!0,appNumber:1,appStorageNumber:1}),n=Uint8Array.from([224,111,0,0,4,0,0,1,1]),t=e.getApdu();expect(t.getRawApdu()).toEqual(n)}),it.each([{field:"appNumber",args:{appNumber:-1,appStorageNumber:1}},{field:"appNumber",args:{appNumber:256,appStorageNumber:1}},{field:"appNumber",args:{appNumber:1.5,appStorageNumber:1}},{field:"appStorageNumber",args:{appNumber:1,appStorageNumber:-1}},{field:"appStorageNumber",args:{appNumber:1,appStorageNumber:256}},{field:"appStorageNumber",args:{appNumber:1,appStorageNumber:1.5}}])("should throw when $field is not an 8-bit unsigned integer",({field:e,args:n})=>{const t=`${e} must be an integer between 0 and 255`;let o;try{new a.RequestMasterConsentCommand({languagePackConsentEnabled:!0,lockScreenPictureConsentEnabled:!0,...n})}catch(s){o=s}expect(o).toBeInstanceOf(r.InvalidArgumentError),expect(o.originalError.message).toBe(t)})}),describe("Success response",()=>{it("should return the correct response",()=>{const e=new a.RequestMasterConsentCommand({languagePackConsentEnabled:!0,lockScreenPictureConsentEnabled:!0,appNumber:1,appStorageNumber:1}),n={data:void 0,status:"SUCCESS"},t=e.parseResponse(new r.ApduResponse({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])}));expect((0,r.isSuccessCommandResult)(t)).toBe(!0),expect(t).toEqual(n)})}),describe("Error response",()=>{it("should return a RequestMasterConsentCommandError for status 0x5501",()=>{const e=new a.RequestMasterConsentCommand({languagePackConsentEnabled:!0,lockScreenPictureConsentEnabled:!0,appNumber:1,appStorageNumber:1}),n=(0,r.CommandResultFactory)({error:new a.RequestMasterConsentCommandError({message:"Consent failed",errorCode:"5501"})}),t=e.parseResponse(new r.ApduResponse({statusCode:Uint8Array.from([85,1]),data:Uint8Array.from([])}));expect(t).toEqual(n)}),it("should return a RequestMasterConsentCommandError for status 0x5502",()=>{const e=new a.RequestMasterConsentCommand({languagePackConsentEnabled:!0,lockScreenPictureConsentEnabled:!0,appNumber:1,appStorageNumber:1}),n=(0,r.CommandResultFactory)({error:new a.RequestMasterConsentCommandError({message:"PIN not validated",errorCode:"5502"})}),t=e.parseResponse(new r.ApduResponse({statusCode:Uint8Array.from([85,2]),data:Uint8Array.from([])}));expect(t).toEqual(n)})})});
+//# sourceMappingURL=RequestMasterConsentCommand.test.js.map

package/lib/cjs/api/command/OsUpdate/Restore/RequestMasterConsentCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/RequestMasterConsentCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidArgumentError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  RequestMasterConsentCommand,\n  RequestMasterConsentCommandError,\n} from \"./RequestMasterConsentCommand\";\n\ndescribe(\"RequestMasterConsentCommand\", () => {\n  describe(\"Name\", () => {\n    it(\"name should be 'RequestMasterConsent'\", () => {\n      // ACT\n      const command = new RequestMasterConsentCommand({\n        languagePackConsentEnabled: true,\n        lockScreenPictureConsentEnabled: true,\n        appNumber: 1,\n        appStorageNumber: 1,\n      });\n\n      // ASSERT\n      expect(command.name).toBe(\"RequestMasterConsent\");\n    });\n  });\n\n  describe(\"Command\", () => {\n    it(\"should return the correct APDU for requesting master consent\", () => {\n      // ARRANGE\n      const command = new RequestMasterConsentCommand({\n        languagePackConsentEnabled: true,\n        lockScreenPictureConsentEnabled: true,\n        appNumber: 1,\n        appStorageNumber: 1,\n      });\n      const expectedApdu = Uint8Array.from([\n        0xe0, 0x6f, 0x00, 0x00, 0x04, 0x00, 0x00, 0x01, 0x01,\n      ]);\n\n      // ACT\n      const apdu = command.getApdu();\n\n      // ASSERT\n      expect(apdu.getRawApdu()).toEqual(expectedApdu);\n    });\n\n    it.each([\n      {\n        field: \"appNumber\",\n        args: { appNumber: -1, appStorageNumber: 1 },\n      },\n      {\n        field: \"appNumber\",\n        args: { appNumber: 256, appStorageNumber: 1 },\n      },\n      {\n        field: \"appNumber\",\n        args: { appNumber: 1.5, appStorageNumber: 1 },\n      },\n      {\n        field: \"appStorageNumber\",\n        args: { appNumber: 1, appStorageNumber: -1 },\n      },\n      {\n        field: \"appStorageNumber\",\n        args: { appNumber: 1, appStorageNumber: 256 },\n      },\n      {\n        field: \"appStorageNumber\",\n        args: { appNumber: 1, appStorageNumber: 1.5 },\n      },\n    ])(\n      \"should throw when $field is not an 8-bit unsigned integer\",\n      ({ field, args }) => {\n        const expectedErrorMessage = `${field} must be an integer between 0 and 255`;\n\n        // ACT\n        let caughtError: unknown;\n        try {\n          new RequestMasterConsentCommand({\n            languagePackConsentEnabled: true,\n            lockScreenPictureConsentEnabled: true,\n            ...args,\n          });\n        } catch (error) {\n          caughtError = error;\n        }\n\n        // ASSERT\n        expect(caughtError).toBeInstanceOf(InvalidArgumentError);\n        expect(\n          (caughtError as InvalidArgumentError).originalError.message,\n        ).toBe(expectedErrorMessage);\n      },\n    );\n  });\n\n  describe(\"Success response\", () => {\n    it(\"should return the correct response\", () => {\n      // ARRANGE\n      const command = new RequestMasterConsentCommand({\n        languagePackConsentEnabled: true,\n        lockScreenPictureConsentEnabled: true,\n        appNumber: 1,\n        appStorageNumber: 1,\n      });\n      const expectedResult = {\n        data: undefined,\n        status: \"SUCCESS\",\n      };\n\n      // ACT\n      const result = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: Uint8Array.from([]),\n        }),\n      );\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual(expectedResult);\n    });\n  });\n\n  describe(\"Error response\", () => {\n    it(\"should return a RequestMasterConsentCommandError for status 0x5501\", () => {\n      // ARRANGE\n      const command = new RequestMasterConsentCommand({\n        languagePackConsentEnabled: true,\n        lockScreenPictureConsentEnabled: true,\n        appNumber: 1,\n        appStorageNumber: 1,\n      });\n      const expectedResult = CommandResultFactory({\n        error: new RequestMasterConsentCommandError({\n          message: \"Consent failed\",\n          errorCode: \"5501\",\n        }),\n      });\n\n      // ACT\n      const commandResult = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x55, 0x01]),\n          data: Uint8Array.from([]),\n        }),\n      );\n\n      // ASSERT\n      expect(commandResult).toEqual(expectedResult);\n    });\n\n    it(\"should return a RequestMasterConsentCommandError for status 0x5502\", () => {\n      // ARRANGE\n      const command = new RequestMasterConsentCommand({\n        languagePackConsentEnabled: true,\n        lockScreenPictureConsentEnabled: true,\n        appNumber: 1,\n        appStorageNumber: 1,\n      });\n      const expectedResult = CommandResultFactory({\n        error: new RequestMasterConsentCommandError({\n          message: \"PIN not validated\",\n          errorCode: \"5502\",\n        }),\n      });\n\n      // ACT\n      const commandResult = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x55, 0x02]),\n          data: Uint8Array.from([]),\n        }),\n      );\n\n      // ASSERT\n      expect(commandResult).toEqual(expectedResult);\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAKO,2CAEPC,EAGO,yCAEP,SAAS,8BAA+B,IAAM,CAC5C,SAAS,OAAQ,IAAM,CACrB,GAAG,wCAAyC,IAAM,CAEhD,MAAMC,EAAU,IAAI,8BAA4B,CAC9C,2BAA4B,GAC5B,gCAAiC,GACjC,UAAW,EACX,iBAAkB,CACpB,CAAC,EAGD,OAAOA,EAAQ,IAAI,EAAE,KAAK,sBAAsB,CAClD,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,+DAAgE,IAAM,CAEvE,MAAMA,EAAU,IAAI,8BAA4B,CAC9C,2BAA4B,GAC5B,gCAAiC,GACjC,UAAW,EACX,iBAAkB,CACpB,CAAC,EACKC,EAAe,WAAW,KAAK,CACnC,IAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAClD,CAAC,EAGKC,EAAOF,EAAQ,QAAQ,EAG7B,OAAOE,EAAK,WAAW,CAAC,EAAE,QAAQD,CAAY,CAChD,CAAC,EAED,GAAG,KAAK,CACN,CACE,MAAO,YACP,KAAM,CAAE,UAAW,GAAI,iBAAkB,CAAE,CAC7C,EACA,CACE,MAAO,YACP,KAAM,CAAE,UAAW,IAAK,iBAAkB,CAAE,CAC9C,EACA,CACE,MAAO,YACP,KAAM,CAAE,UAAW,IAAK,iBAAkB,CAAE,CAC9C,EACA,CACE,MAAO,mBACP,KAAM,CAAE,UAAW,EAAG,iBAAkB,EAAG,CAC7C,EACA,CACE,MAAO,mBACP,KAAM,CAAE,UAAW,EAAG,iBAAkB,GAAI,CAC9C,EACA,CACE,MAAO,mBACP,KAAM,CAAE,UAAW,EAAG,iBAAkB,GAAI,CAC9C,CACF,CAAC,EACC,4DACA,CAAC,CAAE,MAAAE,EAAO,KAAAC,CAAK,IAAM,CACnB,MAAMC,EAAuB,GAAGF,CAAK,wCAGrC,IAAIG,EACJ,GAAI,CACF,IAAI,8BAA4B,CAC9B,2BAA4B,GAC5B,gCAAiC,GACjC,GAAGF,CACL,CAAC,CACH,OAASG,EAAO,CACdD,EAAcC,CAChB,CAGA,OAAOD,CAAW,EAAE,eAAe,sBAAoB,EACvD,OACGA,EAAqC,cAAc,OACtD,EAAE,KAAKD,CAAoB,CAC7B,CACF,CACF,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,qCAAsC,IAAM,CAE7C,MAAML,EAAU,IAAI,8BAA4B,CAC9C,2BAA4B,GAC5B,gCAAiC,GACjC,UAAW,EACX,iBAAkB,CACpB,CAAC,EACKQ,EAAiB,CACrB,KAAM,OACN,OAAQ,SACV,EAGMC,EAAST,EAAQ,cACrB,IAAI,eAAa,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,CACH,EAEA,UAAO,0BAAuBS,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQD,CAAc,CACvC,CAAC,CACH,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,qEAAsE,IAAM,CAE7E,MAAMR,EAAU,IAAI,8BAA4B,CAC9C,2BAA4B,GAC5B,gCAAiC,GACjC,UAAW,EACX,iBAAkB,CACpB,CAAC,EACKQ,KAAiB,wBAAqB,CAC1C,MAAO,IAAI,mCAAiC,CAC1C,QAAS,iBACT,UAAW,MACb,CAAC,CACH,CAAC,EAGKE,EAAgBV,EAAQ,cAC5B,IAAI,eAAa,CACf,WAAY,WAAW,KAAK,CAAC,GAAM,CAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,CACH,EAGA,OAAOU,CAAa,EAAE,QAAQF,CAAc,CAC9C,CAAC,EAED,GAAG,qEAAsE,IAAM,CAE7E,MAAMR,EAAU,IAAI,8BAA4B,CAC9C,2BAA4B,GAC5B,gCAAiC,GACjC,UAAW,EACX,iBAAkB,CACpB,CAAC,EACKQ,KAAiB,wBAAqB,CAC1C,MAAO,IAAI,mCAAiC,CAC1C,QAAS,oBACT,UAAW,MACb,CAAC,CACH,CAAC,EAGKE,EAAgBV,EAAQ,cAC5B,IAAI,eAAa,CACf,WAAY,WAAW,KAAK,CAAC,GAAM,CAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,CACH,EAGA,OAAOU,CAAa,EAAE,QAAQF,CAAc,CAC9C,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_RequestMasterConsentCommand", "command", "expectedApdu", "apdu", "field", "args", "expectedErrorMessage", "caughtError", "error", "expectedResult", "result", "commandResult"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/RestoreAppStorageCommand.js

@@ -0,0 +1,2 @@
+"use strict";var d=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var i=(o,e)=>{for(var a in e)d(o,a,{get:e[a],enumerable:!0})},l=(o,e,a,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of g(e))!C.call(o,s)&&s!==a&&d(o,s,{get:()=>e[s],enumerable:!(t=p(e,s))||t.enumerable});return o};var A=o=>l(d({},"__esModule",{value:!0}),o);var R={};i(R,{RESTORE_APP_STORAGE_ERRORS:()=>n,RestoreAppStorageCommand:()=>u,RestoreAppStorageCommandError:()=>m});module.exports=A(R);var r=require("@ledgerhq/device-management-kit");const n={5123:{message:"Invalid context, Restore Init must be called first."},5419:{message:"Failed to generate AES key."},"541a":{message:"Failed to decrypt the app storage backup."},"662f":{message:"Invalid device state, recovery mode."},6643:{message:"Invalid restore state, restore already performed."},6734:{message:"Invalid chunk length."},"684a":{message:"Invalid backup, app storage header is not valid."}};class m extends r.DeviceExchangeError{constructor(e){super({tag:"RestoreAppStorageCommandError",...e})}}class u{constructor(e){this.args=e}name="RestoreAppStorage";header={cla:224,ins:109,p1:0,p2:0};getApdu(){const{chunkData:e}=this.args;return new r.ApduBuilder(this.header).addBufferToData(e).build()}parseResponse(e){const a=new r.ApduParser(e);if(!r.CommandUtils.isSuccessResponse(e)){const t=a.encodeToHexaString(e.statusCode);return(0,r.isCommandErrorCode)(t,n)?(0,r.CommandResultFactory)({error:new m({...n[t],errorCode:t})}):(0,r.CommandResultFactory)({error:r.GlobalCommandErrorHandler.handle(e)})}return(0,r.CommandResultFactory)({data:void 0})}}0&&(module.exports={RESTORE_APP_STORAGE_ERRORS,RestoreAppStorageCommand,RestoreAppStorageCommandError});
+//# sourceMappingURL=RestoreAppStorageCommand.js.map

package/lib/cjs/api/command/OsUpdate/Restore/RestoreAppStorageCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/RestoreAppStorageCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandErrorArgs,\n  type CommandErrors,\n  type CommandResult,\n  CommandResultFactory,\n  CommandUtils,\n  DeviceExchangeError,\n  GlobalCommandErrorHandler,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type RestoreAppStorageCommandArgs = {\n  chunkData: Uint8Array;\n};\n\nexport type RestoreAppStorageCommandErrorCodes =\n  | \"5123\"\n  | \"5419\"\n  | \"541a\"\n  | \"662f\"\n  | \"6643\"\n  | \"6734\"\n  | \"684a\";\n\nexport const RESTORE_APP_STORAGE_ERRORS: CommandErrors<RestoreAppStorageCommandErrorCodes> =\n  {\n    \"5123\": { message: \"Invalid context, Restore Init must be called first.\" },\n    \"5419\": { message: \"Failed to generate AES key.\" },\n    \"541a\": { message: \"Failed to decrypt the app storage backup.\" },\n    \"662f\": { message: \"Invalid device state, recovery mode.\" },\n    \"6643\": { message: \"Invalid restore state, restore already performed.\" },\n    \"6734\": { message: \"Invalid chunk length.\" },\n    \"684a\": { message: \"Invalid backup, app storage header is not valid.\" },\n  };\n\nexport class RestoreAppStorageCommandError extends DeviceExchangeError<RestoreAppStorageCommandErrorCodes> {\n  constructor(args: CommandErrorArgs<RestoreAppStorageCommandErrorCodes>) {\n    super({ tag: \"RestoreAppStorageCommandError\", ...args });\n  }\n}\n\nexport type RestoreAppStorageCommandResult = CommandResult<\n  void,\n  RestoreAppStorageCommandErrorCodes\n>;\n\nexport class RestoreAppStorageCommand\n  implements\n    Command<\n      void,\n      RestoreAppStorageCommandArgs,\n      RestoreAppStorageCommandErrorCodes\n    >\n{\n  readonly name = \"RestoreAppStorage\";\n\n  private readonly header = {\n    cla: 0xe0,\n    ins: 0x6d,\n    p1: 0x00,\n    p2: 0x00,\n  };\n\n  constructor(private readonly args: RestoreAppStorageCommandArgs) {}\n\n  getApdu(): Apdu {\n    const { chunkData } = this.args;\n    return new ApduBuilder(this.header).addBufferToData(chunkData).build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): RestoreAppStorageCommandResult {\n    const parser = new ApduParser(apduResponse);\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, RESTORE_APP_STORAGE_ERRORS)) {\n        return CommandResultFactory({\n          error: new RestoreAppStorageCommandError({\n            ...RESTORE_APP_STORAGE_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    return CommandResultFactory({\n      data: undefined,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,gCAAAE,EAAA,6BAAAC,EAAA,kCAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAcO,2CAeA,MAAMJ,EACX,CACE,KAAQ,CAAE,QAAS,qDAAsD,EACzE,KAAQ,CAAE,QAAS,6BAA8B,EACjD,OAAQ,CAAE,QAAS,2CAA4C,EAC/D,OAAQ,CAAE,QAAS,sCAAuC,EAC1D,KAAQ,CAAE,QAAS,mDAAoD,EACvE,KAAQ,CAAE,QAAS,uBAAwB,EAC3C,OAAQ,CAAE,QAAS,kDAAmD,CACxE,EAEK,MAAME,UAAsC,qBAAwD,CACzG,YAAYG,EAA4D,CACtE,MAAM,CAAE,IAAK,gCAAiC,GAAGA,CAAK,CAAC,CACzD,CACF,CAOO,MAAMJ,CAOb,CAUE,YAA6BI,EAAoC,CAApC,UAAAA,CAAqC,CATzD,KAAO,oBAEC,OAAS,CACxB,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EAIA,SAAgB,CACd,KAAM,CAAE,UAAAC,CAAU,EAAI,KAAK,KAC3B,OAAO,IAAI,cAAY,KAAK,MAAM,EAAE,gBAAgBA,CAAS,EAAE,MAAM,CACvE,CAEA,cAAcC,EAA4D,CACxE,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAC1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAME,EAAYD,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBE,EAAWT,CAA0B,KACnD,wBAAqB,CAC1B,MAAO,IAAIE,EAA8B,CACvC,GAAGF,EAA2BS,CAAS,EACvC,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOF,CAAY,CACtD,CAAC,CACH,CAEA,SAAO,wBAAqB,CAC1B,KAAM,MACR,CAAC,CACH,CACF",
+  "names": ["RestoreAppStorageCommand_exports", "__export", "RESTORE_APP_STORAGE_ERRORS", "RestoreAppStorageCommand", "RestoreAppStorageCommandError", "__toCommonJS", "import_device_management_kit", "args", "chunkData", "apduResponse", "parser", "errorCode"]
+}

package/lib/cjs/api/command/OsUpdate/Restore/RestoreAppStorageCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var r=require("@ledgerhq/device-management-kit"),s=require("./RestoreAppStorageCommand");describe("RestoreAppStorageCommand",()=>{describe("Name",()=>{it("name should be 'RestoreAppStorage'",()=>{const e=new s.RestoreAppStorageCommand({chunkData:Uint8Array.from([1,2,3])}).name;expect(e).toBe("RestoreAppStorage")})}),describe("Command",()=>{it("should return the correct APDU for restoring an app storage chunk",()=>{const t=Uint8Array.from([224,109,0,0,3,1,2,3]),e=new s.RestoreAppStorageCommand({chunkData:Uint8Array.from([1,2,3])}).getApdu();expect(e.getRawApdu()).toEqual(t)})}),describe("Success response",()=>{it("should return a success result",()=>{const t=new r.ApduResponse({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),e=new s.RestoreAppStorageCommand({chunkData:Uint8Array.from([1,2,3])}).parseResponse(t);expect((0,r.isSuccessCommandResult)(e)).toBe(!0),expect(e).toEqual({data:void 0,status:"SUCCESS"})})}),describe("Error response",()=>{it.each([{description:"restore init has not been called",statusCode:[81,35],expectedMessage:"Invalid context, Restore Init must be called first."},{description:"AES key generation failed",statusCode:[84,25],expectedMessage:"Failed to generate AES key."},{description:"decryption failed",statusCode:[84,26],expectedMessage:"Failed to decrypt the app storage backup."},{description:"device is in recovery mode",statusCode:[102,47],expectedMessage:"Invalid device state, recovery mode."},{description:"restore has already been performed",statusCode:[102,67],expectedMessage:"Invalid restore state, restore already performed."},{description:"chunk length is invalid",statusCode:[103,52],expectedMessage:"Invalid chunk length."},{description:"app storage header is invalid",statusCode:[104,74],expectedMessage:"Invalid backup, app storage header is not valid."},{description:"error code is not specific to RestoreAppStorageCommand (global error)",statusCode:[85,21],expectedMessage:"Device is locked."}])("should return error when $description",({statusCode:t,expectedMessage:e})=>{const o=new r.ApduResponse({statusCode:Uint8Array.from(t),data:new Uint8Array([])}),a=new s.RestoreAppStorageCommand({chunkData:Uint8Array.from([1,2,3])}).parseResponse(o);expect((0,r.isSuccessCommandResult)(a)).toBe(!1),expect(a.error.message).toBe(e)})})});
+//# sourceMappingURL=RestoreAppStorageCommand.test.js.map

package/lib/cjs/api/command/OsUpdate/Restore/RestoreAppStorageCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/OsUpdate/Restore/RestoreAppStorageCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { RestoreAppStorageCommand } from \"./RestoreAppStorageCommand\";\n\ndescribe(\"RestoreAppStorageCommand\", () => {\n  describe(\"Name\", () => {\n    it(\"name should be 'RestoreAppStorage'\", () => {\n      // ARRANGE\n      const command = new RestoreAppStorageCommand({\n        chunkData: Uint8Array.from([0x01, 0x02, 0x03]),\n      });\n\n      // ACT\n      const name = command.name;\n\n      // ASSERT\n      expect(name).toBe(\"RestoreAppStorage\");\n    });\n  });\n\n  describe(\"Command\", () => {\n    it(\"should return the correct APDU for restoring an app storage chunk\", () => {\n      // ARRANGE\n      const expectedApdu = Uint8Array.from([\n        0xe0, 0x6d, 0x00, 0x00, 0x03, 0x01, 0x02, 0x03,\n      ]);\n\n      // ACT\n      const apdu = new RestoreAppStorageCommand({\n        chunkData: Uint8Array.from([0x01, 0x02, 0x03]),\n      }).getApdu();\n\n      // ASSERT\n      expect(apdu.getRawApdu()).toEqual(expectedApdu);\n    });\n  });\n\n  describe(\"Success response\", () => {\n    it(\"should return a success result\", () => {\n      // ARRANGE\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      });\n\n      // ACT\n      const result = new RestoreAppStorageCommand({\n        chunkData: Uint8Array.from([0x01, 0x02, 0x03]),\n      }).parseResponse(response);\n\n      // ASSERT\n      expect(isSuccessCommandResult(result)).toBe(true);\n      expect(result).toEqual({\n        data: undefined,\n        status: \"SUCCESS\",\n      });\n    });\n  });\n\n  describe(\"Error response\", () => {\n    it.each([\n      {\n        description: \"restore init has not been called\",\n        statusCode: [0x51, 0x23],\n        expectedMessage: \"Invalid context, Restore Init must be called first.\",\n      },\n      {\n        description: \"AES key generation failed\",\n        statusCode: [0x54, 0x19],\n        expectedMessage: \"Failed to generate AES key.\",\n      },\n      {\n        description: \"decryption failed\",\n        statusCode: [0x54, 0x1a],\n        expectedMessage: \"Failed to decrypt the app storage backup.\",\n      },\n      {\n        description: \"device is in recovery mode\",\n        statusCode: [0x66, 0x2f],\n        expectedMessage: \"Invalid device state, recovery mode.\",\n      },\n      {\n        description: \"restore has already been performed\",\n        statusCode: [0x66, 0x43],\n        expectedMessage: \"Invalid restore state, restore already performed.\",\n      },\n      {\n        description: \"chunk length is invalid\",\n        statusCode: [0x67, 0x34],\n        expectedMessage: \"Invalid chunk length.\",\n      },\n      {\n        description: \"app storage header is invalid\",\n        statusCode: [0x68, 0x4a],\n        expectedMessage: \"Invalid backup, app storage header is not valid.\",\n      },\n      {\n        description:\n          \"error code is not specific to RestoreAppStorageCommand (global error)\",\n        statusCode: [0x55, 0x15],\n        expectedMessage: \"Device is locked.\",\n      },\n    ])(\n      \"should return error when $description\",\n      ({ statusCode, expectedMessage }) => {\n        // ARRANGE\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from(statusCode),\n          data: new Uint8Array([]),\n        });\n\n        // ACT\n        const result = new RestoreAppStorageCommand({\n          chunkData: Uint8Array.from([0x01, 0x02, 0x03]),\n        }).parseResponse(response);\n\n        // ASSERT\n        expect(isSuccessCommandResult(result)).toBe(false);\n        expect((result as unknown as { error: Error }).error.message).toBe(\n          expectedMessage,\n        );\n      },\n    );\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAGO,2CAEPC,EAAyC,sCAEzC,SAAS,2BAA4B,IAAM,CACzC,SAAS,OAAQ,IAAM,CACrB,GAAG,qCAAsC,IAAM,CAO7C,MAAMC,EALU,IAAI,2BAAyB,CAC3C,UAAW,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,CAC/C,CAAC,EAGoB,KAGrB,OAAOA,CAAI,EAAE,KAAK,mBAAmB,CACvC,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,oEAAqE,IAAM,CAE5E,MAAMC,EAAe,WAAW,KAAK,CACnC,IAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAC5C,CAAC,EAGKC,EAAO,IAAI,2BAAyB,CACxC,UAAW,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,CAC/C,CAAC,EAAE,QAAQ,EAGX,OAAOA,EAAK,WAAW,CAAC,EAAE,QAAQD,CAAY,CAChD,CAAC,CACH,CAAC,EAED,SAAS,mBAAoB,IAAM,CACjC,GAAG,iCAAkC,IAAM,CAEzC,MAAME,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKC,EAAS,IAAI,2BAAyB,CAC1C,UAAW,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,CAC/C,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAChD,OAAOA,CAAM,EAAE,QAAQ,CACrB,KAAM,OACN,OAAQ,SACV,CAAC,CACH,CAAC,CACH,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,KAAK,CACN,CACE,YAAa,mCACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,qDACnB,EACA,CACE,YAAa,4BACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,6BACnB,EACA,CACE,YAAa,oBACb,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,2CACnB,EACA,CACE,YAAa,6BACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,sCACnB,EACA,CACE,YAAa,qCACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,mDACnB,EACA,CACE,YAAa,0BACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,uBACnB,EACA,CACE,YAAa,gCACb,WAAY,CAAC,IAAM,EAAI,EACvB,gBAAiB,kDACnB,EACA,CACE,YACE,wEACF,WAAY,CAAC,GAAM,EAAI,EACvB,gBAAiB,mBACnB,CACF,CAAC,EACC,wCACA,CAAC,CAAE,WAAAC,EAAY,gBAAAC,CAAgB,IAAM,CAEnC,MAAMH,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAKE,CAAU,EACtC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKD,EAAS,IAAI,2BAAyB,CAC1C,UAAW,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,CAC/C,CAAC,EAAE,cAAcD,CAAQ,EAGzB,UAAO,0BAAuBC,CAAM,CAAC,EAAE,KAAK,EAAK,EACjD,OAAQA,EAAuC,MAAM,OAAO,EAAE,KAC5DE,CACF,CACF,CACF,CACF,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_RestoreAppStorageCommand", "name", "expectedApdu", "apdu", "response", "result", "statusCode", "expectedMessage"]
+}

package/lib/cjs/api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage.js

@@ -1,2 +1,2 @@
-"use strict";var c=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var S=(a,p)=>{for(var r in p)c(a,r,{get:p[r],enumerable:!0})},d=(a,p,r,t)=>{if(p&&typeof p=="object"||typeof p=="function")for(let e of l(p))!k.call(a,e)&&e!==r&&c(a,e,{get:()=>p[e],enumerable:!(t=i(p,e))||t.enumerable});return a};var m=a=>d(c({},"__esModule",{value:!0}),a);var y={};S(y,{backupAppsStorage:()=>f});module.exports=m(y);var o=require("@ledgerhq/device-management-kit"),n=require("purify-ts"),u=require("../../../../device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors");const B="0x",f=(a,p)=>async({input:r})=>{const{installedApps:t}=r,e=p("BackupAppStorageTask"),g=[];for(const A of t){const s=await new o.BackupAppStorageTask({appName:A.name},a,e).run();if(!(0,o.isSuccessCommandResult)(s))return(0,n.Left)(new u.BackupAppsStorageError(s.error.originalError));g.push({appName:A.name,data:s.data.appStorageData===B?void 0:s.data.appStorageData})}return(0,n.Right)(g)};0&&(module.exports={backupAppsStorage});
+"use strict";var n=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var k=Object.getOwnPropertyNames;var S=Object.prototype.hasOwnProperty;var d=(a,p)=>{for(var r in p)n(a,r,{get:p[r],enumerable:!0})},m=(a,p,r,t)=>{if(p&&typeof p=="object"||typeof p=="function")for(let e of k(p))!S.call(a,e)&&e!==r&&n(a,e,{get:()=>p[e],enumerable:!(t=l(p,e))||t.enumerable});return a};var B=a=>m(n({},"__esModule",{value:!0}),a);var H={};d(H,{backupAppsStorage:()=>y});module.exports=B(H);var A=require("@ledgerhq/device-management-kit"),o=require("purify-ts"),u=require("../../../../device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors"),i=require("../../../../task/OsUpdate/Backup/BackupAppStorageTask");const f="0x",y=(a,p)=>async({input:r})=>{const{installedApps:t}=r,e=p("BackupAppStorageTask"),c=[];for(const g of t){const s=await new i.BackupAppStorageTask({appName:g.name},a,e).run();if(!(0,A.isSuccessCommandResult)(s))return(0,o.Left)(new u.BackupAppsStorageError(s.error.originalError));c.push({appName:g.name,data:s.data.appStorageData===f?void 0:s.data.appStorageData})}return(0,o.Right)(c)};0&&(module.exports={backupAppsStorage});
 //# sourceMappingURL=BackupAppsStorage.js.map

package/lib/cjs/api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage.ts"],
-  "sourcesContent": ["import {\n  BackupAppStorageTask,\n  type InstalledApp,\n  type InternalApi,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either, Left, Right } from \"purify-ts\";\n\nimport { BackupAppsStorageError } from \"@api/device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors\";\nimport { type BackupApp } from \"@api/device-action/OsUpdate/Backup/types\";\n\nconst EMPTY_STORAGE = \"0x\";\n\ntype BackupAppsStorageHandlerArgs = {\n  input: { installedApps: InstalledApp[] };\n};\n\ntype BackupAppsStorageHandlerResponse = Promise<\n  Either<BackupAppsStorageError, BackupApp[]>\n>;\n\ntype BackupAppsStorageHandler = (\n  args: BackupAppsStorageHandlerArgs,\n) => BackupAppsStorageHandlerResponse;\n\nexport const backupAppsStorage =\n  (\n    internalApi: InternalApi,\n    loggerFactory: (tag: string) => LoggerPublisherService,\n  ): BackupAppsStorageHandler =>\n  async ({\n    input,\n  }: BackupAppsStorageHandlerArgs): BackupAppsStorageHandlerResponse => {\n    const { installedApps } = input;\n    const logger = loggerFactory(\"BackupAppStorageTask\");\n    const backupApps: BackupApp[] = [];\n    for (const installedApp of installedApps) {\n      const backupAppStorageTaskResponse = await new BackupAppStorageTask(\n        {\n          appName: installedApp.name,\n        },\n        internalApi,\n        logger,\n      ).run();\n\n      if (!isSuccessCommandResult(backupAppStorageTaskResponse)) {\n        return Left(\n          new BackupAppsStorageError(\n            backupAppStorageTaskResponse.error.originalError,\n          ),\n        );\n      }\n\n      backupApps.push({\n        appName: installedApp.name,\n        data:\n          backupAppStorageTaskResponse.data.appStorageData === EMPTY_STORAGE\n            ? undefined\n            : backupAppStorageTaskResponse.data.appStorageData,\n      });\n    }\n\n    return Right(backupApps);\n  };\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAMO,2CACPC,EAAyC,qBAEzCC,EAAuC,6EAGvC,MAAMC,EAAgB,KAcTL,EACX,CACEM,EACAC,IAEF,MAAO,CACL,MAAAC,CACF,IAAsE,CACpE,KAAM,CAAE,cAAAC,CAAc,EAAID,EACpBE,EAASH,EAAc,sBAAsB,EAC7CI,EAA0B,CAAC,EACjC,UAAWC,KAAgBH,EAAe,CACxC,MAAMI,EAA+B,MAAM,IAAI,uBAC7C,CACE,QAASD,EAAa,IACxB,EACAN,EACAI,CACF,EAAE,IAAI,EAEN,GAAI,IAAC,0BAAuBG,CAA4B,EACtD,SAAO,QACL,IAAI,yBACFA,EAA6B,MAAM,aACrC,CACF,EAGFF,EAAW,KAAK,CACd,QAASC,EAAa,KACtB,KACEC,EAA6B,KAAK,iBAAmBR,EACjD,OACAQ,EAA6B,KAAK,cAC1C,CAAC,CACH,CAEA,SAAO,SAAMF,CAAU,CACzB",
-  "names": ["BackupAppsStorage_exports", "__export", "backupAppsStorage", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_CreateBackupDeviceActionErrors", "EMPTY_STORAGE", "internalApi", "loggerFactory", "input", "installedApps", "logger", "backupApps", "installedApp", "backupAppStorageTaskResponse"]
+  "sourcesContent": ["import {\n  type InstalledApp,\n  type InternalApi,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either, Left, Right } from \"purify-ts\";\n\nimport { BackupAppsStorageError } from \"@api/device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors\";\nimport { type BackupApp } from \"@api/device-action/OsUpdate/Backup/types\";\nimport { BackupAppStorageTask } from \"@api/task/OsUpdate/Backup/BackupAppStorageTask\";\n\nconst EMPTY_STORAGE = \"0x\";\n\ntype BackupAppsStorageHandlerArgs = {\n  input: { installedApps: InstalledApp[] };\n};\n\ntype BackupAppsStorageHandlerResponse = Promise<\n  Either<BackupAppsStorageError, BackupApp[]>\n>;\n\ntype BackupAppsStorageHandler = (\n  args: BackupAppsStorageHandlerArgs,\n) => BackupAppsStorageHandlerResponse;\n\nexport const backupAppsStorage =\n  (\n    internalApi: InternalApi,\n    loggerFactory: (tag: string) => LoggerPublisherService,\n  ): BackupAppsStorageHandler =>\n  async ({\n    input,\n  }: BackupAppsStorageHandlerArgs): BackupAppsStorageHandlerResponse => {\n    const { installedApps } = input;\n    const logger = loggerFactory(\"BackupAppStorageTask\");\n    const backupApps: BackupApp[] = [];\n    for (const installedApp of installedApps) {\n      const backupAppStorageTaskResponse = await new BackupAppStorageTask(\n        {\n          appName: installedApp.name,\n        },\n        internalApi,\n        logger,\n      ).run();\n\n      if (!isSuccessCommandResult(backupAppStorageTaskResponse)) {\n        return Left(\n          new BackupAppsStorageError(\n            backupAppStorageTaskResponse.error.originalError,\n          ),\n        );\n      }\n\n      backupApps.push({\n        appName: installedApp.name,\n        data:\n          backupAppStorageTaskResponse.data.appStorageData === EMPTY_STORAGE\n            ? undefined\n            : backupAppStorageTaskResponse.data.appStorageData,\n      });\n    }\n\n    return Right(backupApps);\n  };\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAKO,2CACPC,EAAyC,qBAEzCC,EAAuC,6EAEvCC,EAAqC,0DAErC,MAAMC,EAAgB,KAcTN,EACX,CACEO,EACAC,IAEF,MAAO,CACL,MAAAC,CACF,IAAsE,CACpE,KAAM,CAAE,cAAAC,CAAc,EAAID,EACpBE,EAASH,EAAc,sBAAsB,EAC7CI,EAA0B,CAAC,EACjC,UAAWC,KAAgBH,EAAe,CACxC,MAAMI,EAA+B,MAAM,IAAI,uBAC7C,CACE,QAASD,EAAa,IACxB,EACAN,EACAI,CACF,EAAE,IAAI,EAEN,GAAI,IAAC,0BAAuBG,CAA4B,EACtD,SAAO,QACL,IAAI,yBACFA,EAA6B,MAAM,aACrC,CACF,EAGFF,EAAW,KAAK,CACd,QAASC,EAAa,KACtB,KACEC,EAA6B,KAAK,iBAAmBR,EACjD,OACAQ,EAA6B,KAAK,cAC1C,CAAC,CACH,CAEA,SAAO,SAAMF,CAAU,CACzB",
+  "names": ["BackupAppsStorage_exports", "__export", "backupAppsStorage", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_CreateBackupDeviceActionErrors", "import_BackupAppStorageTask", "EMPTY_STORAGE", "internalApi", "loggerFactory", "input", "installedApps", "logger", "backupApps", "installedApp", "backupAppStorageTaskResponse"]
 }

package/lib/cjs/api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage.test.js

@@ -1,2 +1,2 @@
-"use strict";var a=require("@ledgerhq/device-management-kit"),i=require("../../../../device-action/__test-utils__/makeInternalApi"),d=require("../../../../device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors"),n=require("../../../../device-action/OsUpdate/Backup/Substeps/BackupAppsStorage");vi.mock("@ledgerhq/device-management-kit",async e=>({...await e(),BackupAppStorageTask:vi.fn()}));describe("BackupAppStorage",()=>{const e=(0,i.makeDeviceActionInternalApiMock)(),c=vi.mocked(a.BackupAppStorageTask);beforeEach(()=>{vi.resetAllMocks()}),describe("Success",()=>{it("Should return the list of installed apps and their storage",async()=>{const r=[{name:"app1",flags:0,hash:"hash1",hash_code_data:"hcd1"},{name:"app2",flags:0,hash:"hash2",hash_code_data:"hcd2"}],o=vi.fn().mockResolvedValueOnce((0,a.CommandResultFactory)({data:{appStorageData:"deadbeef"}})).mockResolvedValueOnce((0,a.CommandResultFactory)({data:{appStorageData:"cafebabe"}}));c.mockImplementation(()=>({run:o}));const t=await(0,n.backupAppsStorage)(e,e.loggerFactory)({input:{installedApps:r}});expect(t.isRight()).toBe(!0),expect(t.extract()).toEqual([{appName:"app1",data:"deadbeef"},{appName:"app2",data:"cafebabe"}])}),it("Should set data to undefined when appStorageData is '0x'",async()=>{const r=[{name:"app1",flags:0,hash:"hash1",hash_code_data:"hcd1"}],o=vi.fn().mockResolvedValueOnce((0,a.CommandResultFactory)({data:{appStorageData:"0x"}}));c.mockImplementation(()=>({run:o}));const t=await(0,n.backupAppsStorage)(e,e.loggerFactory)({input:{installedApps:r}});expect(t.isRight()).toBe(!0),expect(t.extract()).toEqual([{appName:"app1",data:void 0}])})}),describe("Error",()=>{it("Should return BackupAppsStorageError",async()=>{const r=[{name:"app1",flags:0,hash:"hash1",hash_code_data:"hcd1"}],o=new a.GlobalCommandError({errorCode:"6e00",...a.GLOBAL_ERRORS["6e00"]}),t=vi.fn().mockResolvedValueOnce((0,a.CommandResultFactory)({error:o}));c.mockImplementation(()=>({run:t}));const p=await(0,n.backupAppsStorage)(e,e.loggerFactory)({input:{installedApps:r}});expect(p.isLeft()).toBe(!0),p.mapLeft(s=>{expect(s).toBeInstanceOf(d.BackupAppsStorageError),expect(s.originalError).toBe(o.originalError)})})})});
+"use strict";var a=require("@ledgerhq/device-management-kit"),i=require("../../../../device-action/__test-utils__/makeInternalApi"),d=require("../../../../device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors"),p=require("../../../../device-action/OsUpdate/Backup/Substeps/BackupAppsStorage"),l=require("../../../../task/OsUpdate/Backup/BackupAppStorageTask");vi.mock("@api/task/OsUpdate/Backup/BackupAppStorageTask");describe("BackupAppStorage",()=>{const t=(0,i.makeDeviceActionInternalApiMock)(),c=vi.mocked(l.BackupAppStorageTask);beforeEach(()=>{vi.resetAllMocks()}),describe("Success",()=>{it("Should return the list of installed apps and their storage",async()=>{const r=[{name:"app1",flags:0,hash:"hash1",hash_code_data:"hcd1"},{name:"app2",flags:0,hash:"hash2",hash_code_data:"hcd2"}],o=vi.fn().mockResolvedValueOnce((0,a.CommandResultFactory)({data:{appStorageData:"deadbeef"}})).mockResolvedValueOnce((0,a.CommandResultFactory)({data:{appStorageData:"cafebabe"}}));c.mockImplementation(()=>({run:o}));const e=await(0,p.backupAppsStorage)(t,t.loggerFactory)({input:{installedApps:r}});expect(e.isRight()).toBe(!0),expect(e.extract()).toEqual([{appName:"app1",data:"deadbeef"},{appName:"app2",data:"cafebabe"}])}),it("Should set data to undefined when appStorageData is '0x'",async()=>{const r=[{name:"app1",flags:0,hash:"hash1",hash_code_data:"hcd1"}],o=vi.fn().mockResolvedValueOnce((0,a.CommandResultFactory)({data:{appStorageData:"0x"}}));c.mockImplementation(()=>({run:o}));const e=await(0,p.backupAppsStorage)(t,t.loggerFactory)({input:{installedApps:r}});expect(e.isRight()).toBe(!0),expect(e.extract()).toEqual([{appName:"app1",data:void 0}])})}),describe("Error",()=>{it("Should return BackupAppsStorageError",async()=>{const r=[{name:"app1",flags:0,hash:"hash1",hash_code_data:"hcd1"}],o=new a.GlobalCommandError({errorCode:"6e00",...a.GLOBAL_ERRORS["6e00"]}),e=vi.fn().mockResolvedValueOnce((0,a.CommandResultFactory)({error:o}));c.mockImplementation(()=>({run:e}));const s=await(0,p.backupAppsStorage)(t,t.loggerFactory)({input:{installedApps:r}});expect(s.isLeft()).toBe(!0),s.mapLeft(n=>{expect(n).toBeInstanceOf(d.BackupAppsStorageError),expect(n.originalError).toBe(o.originalError)})})})});
 //# sourceMappingURL=BackupAppsStorage.test.js.map

package/lib/cjs/api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage.test.ts"],
-  "sourcesContent": ["import {\n  BackupAppStorageTask,\n  CommandResultFactory,\n  GLOBAL_ERRORS,\n  GlobalCommandError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { makeDeviceActionInternalApiMock } from \"@api/device-action/__test-utils__/makeInternalApi\";\nimport { BackupAppsStorageError } from \"@api/device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors\";\nimport { backupAppsStorage } from \"@api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage\";\n\nvi.mock(\"@ledgerhq/device-management-kit\", async (importOriginal) => {\n  const original =\n    await importOriginal<typeof import(\"@ledgerhq/device-management-kit\")>();\n  return {\n    ...original,\n    BackupAppStorageTask: vi.fn(),\n  };\n});\n\ndescribe(\"BackupAppStorage\", () => {\n  const apiMock = makeDeviceActionInternalApiMock();\n  const MockTask = vi.mocked(BackupAppStorageTask);\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n  });\n\n  describe(\"Success\", () => {\n    it(\"Should return the list of installed apps and their storage\", async () => {\n      const installedApps = [\n        { name: \"app1\", flags: 0, hash: \"hash1\", hash_code_data: \"hcd1\" },\n        { name: \"app2\", flags: 0, hash: \"hash2\", hash_code_data: \"hcd2\" },\n      ];\n      const runMock = vi\n        .fn()\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { appStorageData: \"deadbeef\" } }),\n        )\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { appStorageData: \"cafebabe\" } }),\n        );\n      MockTask.mockImplementation(() => ({ run: runMock }) as never);\n\n      const result = await backupAppsStorage(\n        apiMock,\n        apiMock.loggerFactory!,\n      )({ input: { installedApps } });\n\n      expect(result.isRight()).toBe(true);\n      expect(result.extract()).toEqual([\n        { appName: \"app1\", data: \"deadbeef\" },\n        { appName: \"app2\", data: \"cafebabe\" },\n      ]);\n    });\n\n    it(\"Should set data to undefined when appStorageData is '0x'\", async () => {\n      const installedApps = [\n        { name: \"app1\", flags: 0, hash: \"hash1\", hash_code_data: \"hcd1\" },\n      ];\n      const runMock = vi\n        .fn()\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { appStorageData: \"0x\" } }),\n        );\n      MockTask.mockImplementation(() => ({ run: runMock }) as never);\n\n      const result = await backupAppsStorage(\n        apiMock,\n        apiMock.loggerFactory!,\n      )({ input: { installedApps } });\n\n      expect(result.isRight()).toBe(true);\n      expect(result.extract()).toEqual([{ appName: \"app1\", data: undefined }]);\n    });\n  });\n  describe(\"Error\", () => {\n    it(\"Should return BackupAppsStorageError\", async () => {\n      const installedApps = [\n        { name: \"app1\", flags: 0, hash: \"hash1\", hash_code_data: \"hcd1\" },\n      ];\n      const error = new GlobalCommandError({\n        errorCode: \"6e00\",\n        ...GLOBAL_ERRORS[\"6e00\"],\n      });\n      const runMock = vi\n        .fn()\n        .mockResolvedValueOnce(CommandResultFactory({ error }));\n      MockTask.mockImplementation(() => ({ run: runMock }) as never);\n\n      const result = await backupAppsStorage(\n        apiMock,\n        apiMock.loggerFactory!,\n      )({ input: { installedApps } });\n\n      expect(result.isLeft()).toBe(true);\n      result.mapLeft((e) => {\n        expect(e).toBeInstanceOf(BackupAppsStorageError);\n        expect(e.originalError).toBe(error.originalError);\n      });\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAKO,2CAEPC,EAAgD,6DAChDC,EAAuC,6EACvCC,EAAkC,yEAElC,GAAG,KAAK,kCAAmC,MAAOC,IAGzC,CACL,GAFA,MAAMA,EAAiE,EAGvE,qBAAsB,GAAG,GAAG,CAC9B,EACD,EAED,SAAS,mBAAoB,IAAM,CACjC,MAAMC,KAAU,mCAAgC,EAC1CC,EAAW,GAAG,OAAO,sBAAoB,EAE/C,WAAW,IAAM,CACf,GAAG,cAAc,CACnB,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6DAA8D,SAAY,CAC3E,MAAMC,EAAgB,CACpB,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,EAChE,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,CAClE,EACMC,EAAU,GACb,GAAG,EACH,yBACC,wBAAqB,CAAE,KAAM,CAAE,eAAgB,UAAW,CAAE,CAAC,CAC/D,EACC,yBACC,wBAAqB,CAAE,KAAM,CAAE,eAAgB,UAAW,CAAE,CAAC,CAC/D,EACFF,EAAS,mBAAmB,KAAO,CAAE,IAAKE,CAAQ,EAAW,EAE7D,MAAMC,EAAS,QAAM,qBACnBJ,EACAA,EAAQ,aACV,EAAE,CAAE,MAAO,CAAE,cAAAE,CAAc,CAAE,CAAC,EAE9B,OAAOE,EAAO,QAAQ,CAAC,EAAE,KAAK,EAAI,EAClC,OAAOA,EAAO,QAAQ,CAAC,EAAE,QAAQ,CAC/B,CAAE,QAAS,OAAQ,KAAM,UAAW,EACpC,CAAE,QAAS,OAAQ,KAAM,UAAW,CACtC,CAAC,CACH,CAAC,EAED,GAAG,2DAA4D,SAAY,CACzE,MAAMF,EAAgB,CACpB,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,CAClE,EACMC,EAAU,GACb,GAAG,EACH,yBACC,wBAAqB,CAAE,KAAM,CAAE,eAAgB,IAAK,CAAE,CAAC,CACzD,EACFF,EAAS,mBAAmB,KAAO,CAAE,IAAKE,CAAQ,EAAW,EAE7D,MAAMC,EAAS,QAAM,qBACnBJ,EACAA,EAAQ,aACV,EAAE,CAAE,MAAO,CAAE,cAAAE,CAAc,CAAE,CAAC,EAE9B,OAAOE,EAAO,QAAQ,CAAC,EAAE,KAAK,EAAI,EAClC,OAAOA,EAAO,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAE,QAAS,OAAQ,KAAM,MAAU,CAAC,CAAC,CACzE,CAAC,CACH,CAAC,EACD,SAAS,QAAS,IAAM,CACtB,GAAG,uCAAwC,SAAY,CACrD,MAAMF,EAAgB,CACpB,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,CAClE,EACMG,EAAQ,IAAI,qBAAmB,CACnC,UAAW,OACX,GAAG,gBAAc,MAAM,CACzB,CAAC,EACKF,EAAU,GACb,GAAG,EACH,yBAAsB,wBAAqB,CAAE,MAAAE,CAAM,CAAC,CAAC,EACxDJ,EAAS,mBAAmB,KAAO,CAAE,IAAKE,CAAQ,EAAW,EAE7D,MAAMC,EAAS,QAAM,qBACnBJ,EACAA,EAAQ,aACV,EAAE,CAAE,MAAO,CAAE,cAAAE,CAAc,CAAE,CAAC,EAE9B,OAAOE,EAAO,OAAO,CAAC,EAAE,KAAK,EAAI,EACjCA,EAAO,QAASE,GAAM,CACpB,OAAOA,CAAC,EAAE,eAAe,wBAAsB,EAC/C,OAAOA,EAAE,aAAa,EAAE,KAAKD,EAAM,aAAa,CAClD,CAAC,CACH,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["import_device_management_kit", "import_makeInternalApi", "import_CreateBackupDeviceActionErrors", "import_BackupAppsStorage", "importOriginal", "apiMock", "MockTask", "installedApps", "runMock", "result", "error", "e"]
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  GLOBAL_ERRORS,\n  GlobalCommandError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { makeDeviceActionInternalApiMock } from \"@api/device-action/__test-utils__/makeInternalApi\";\nimport { BackupAppsStorageError } from \"@api/device-action/OsUpdate/Backup/CreateBackupDeviceActionErrors\";\nimport { backupAppsStorage } from \"@api/device-action/OsUpdate/Backup/Substeps/BackupAppsStorage\";\nimport { BackupAppStorageTask } from \"@api/task/OsUpdate/Backup/BackupAppStorageTask\";\n\nvi.mock(\"@api/task/OsUpdate/Backup/BackupAppStorageTask\");\n\ndescribe(\"BackupAppStorage\", () => {\n  const apiMock = makeDeviceActionInternalApiMock();\n  const MockTask = vi.mocked(BackupAppStorageTask);\n\n  beforeEach(() => {\n    vi.resetAllMocks();\n  });\n\n  describe(\"Success\", () => {\n    it(\"Should return the list of installed apps and their storage\", async () => {\n      const installedApps = [\n        { name: \"app1\", flags: 0, hash: \"hash1\", hash_code_data: \"hcd1\" },\n        { name: \"app2\", flags: 0, hash: \"hash2\", hash_code_data: \"hcd2\" },\n      ];\n      const runMock = vi\n        .fn()\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { appStorageData: \"deadbeef\" } }),\n        )\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { appStorageData: \"cafebabe\" } }),\n        );\n      MockTask.mockImplementation(() => ({ run: runMock }) as never);\n\n      const result = await backupAppsStorage(\n        apiMock,\n        apiMock.loggerFactory!,\n      )({ input: { installedApps } });\n\n      expect(result.isRight()).toBe(true);\n      expect(result.extract()).toEqual([\n        { appName: \"app1\", data: \"deadbeef\" },\n        { appName: \"app2\", data: \"cafebabe\" },\n      ]);\n    });\n\n    it(\"Should set data to undefined when appStorageData is '0x'\", async () => {\n      const installedApps = [\n        { name: \"app1\", flags: 0, hash: \"hash1\", hash_code_data: \"hcd1\" },\n      ];\n      const runMock = vi\n        .fn()\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { appStorageData: \"0x\" } }),\n        );\n      MockTask.mockImplementation(() => ({ run: runMock }) as never);\n\n      const result = await backupAppsStorage(\n        apiMock,\n        apiMock.loggerFactory!,\n      )({ input: { installedApps } });\n\n      expect(result.isRight()).toBe(true);\n      expect(result.extract()).toEqual([{ appName: \"app1\", data: undefined }]);\n    });\n  });\n  describe(\"Error\", () => {\n    it(\"Should return BackupAppsStorageError\", async () => {\n      const installedApps = [\n        { name: \"app1\", flags: 0, hash: \"hash1\", hash_code_data: \"hcd1\" },\n      ];\n      const error = new GlobalCommandError({\n        errorCode: \"6e00\",\n        ...GLOBAL_ERRORS[\"6e00\"],\n      });\n      const runMock = vi\n        .fn()\n        .mockResolvedValueOnce(CommandResultFactory({ error }));\n      MockTask.mockImplementation(() => ({ run: runMock }) as never);\n\n      const result = await backupAppsStorage(\n        apiMock,\n        apiMock.loggerFactory!,\n      )({ input: { installedApps } });\n\n      expect(result.isLeft()).toBe(true);\n      result.mapLeft((e) => {\n        expect(e).toBeInstanceOf(BackupAppsStorageError);\n        expect(e.originalError).toBe(error.originalError);\n      });\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAIO,2CAEPC,EAAgD,6DAChDC,EAAuC,6EACvCC,EAAkC,yEAClCC,EAAqC,0DAErC,GAAG,KAAK,gDAAgD,EAExD,SAAS,mBAAoB,IAAM,CACjC,MAAMC,KAAU,mCAAgC,EAC1CC,EAAW,GAAG,OAAO,sBAAoB,EAE/C,WAAW,IAAM,CACf,GAAG,cAAc,CACnB,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6DAA8D,SAAY,CAC3E,MAAMC,EAAgB,CACpB,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,EAChE,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,CAClE,EACMC,EAAU,GACb,GAAG,EACH,yBACC,wBAAqB,CAAE,KAAM,CAAE,eAAgB,UAAW,CAAE,CAAC,CAC/D,EACC,yBACC,wBAAqB,CAAE,KAAM,CAAE,eAAgB,UAAW,CAAE,CAAC,CAC/D,EACFF,EAAS,mBAAmB,KAAO,CAAE,IAAKE,CAAQ,EAAW,EAE7D,MAAMC,EAAS,QAAM,qBACnBJ,EACAA,EAAQ,aACV,EAAE,CAAE,MAAO,CAAE,cAAAE,CAAc,CAAE,CAAC,EAE9B,OAAOE,EAAO,QAAQ,CAAC,EAAE,KAAK,EAAI,EAClC,OAAOA,EAAO,QAAQ,CAAC,EAAE,QAAQ,CAC/B,CAAE,QAAS,OAAQ,KAAM,UAAW,EACpC,CAAE,QAAS,OAAQ,KAAM,UAAW,CACtC,CAAC,CACH,CAAC,EAED,GAAG,2DAA4D,SAAY,CACzE,MAAMF,EAAgB,CACpB,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,CAClE,EACMC,EAAU,GACb,GAAG,EACH,yBACC,wBAAqB,CAAE,KAAM,CAAE,eAAgB,IAAK,CAAE,CAAC,CACzD,EACFF,EAAS,mBAAmB,KAAO,CAAE,IAAKE,CAAQ,EAAW,EAE7D,MAAMC,EAAS,QAAM,qBACnBJ,EACAA,EAAQ,aACV,EAAE,CAAE,MAAO,CAAE,cAAAE,CAAc,CAAE,CAAC,EAE9B,OAAOE,EAAO,QAAQ,CAAC,EAAE,KAAK,EAAI,EAClC,OAAOA,EAAO,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAE,QAAS,OAAQ,KAAM,MAAU,CAAC,CAAC,CACzE,CAAC,CACH,CAAC,EACD,SAAS,QAAS,IAAM,CACtB,GAAG,uCAAwC,SAAY,CACrD,MAAMF,EAAgB,CACpB,CAAE,KAAM,OAAQ,MAAO,EAAG,KAAM,QAAS,eAAgB,MAAO,CAClE,EACMG,EAAQ,IAAI,qBAAmB,CACnC,UAAW,OACX,GAAG,gBAAc,MAAM,CACzB,CAAC,EACKF,EAAU,GACb,GAAG,EACH,yBAAsB,wBAAqB,CAAE,MAAAE,CAAM,CAAC,CAAC,EACxDJ,EAAS,mBAAmB,KAAO,CAAE,IAAKE,CAAQ,EAAW,EAE7D,MAAMC,EAAS,QAAM,qBACnBJ,EACAA,EAAQ,aACV,EAAE,CAAE,MAAO,CAAE,cAAAE,CAAc,CAAE,CAAC,EAE9B,OAAOE,EAAO,OAAO,CAAC,EAAE,KAAK,EAAI,EACjCA,EAAO,QAASE,GAAM,CACpB,OAAOA,CAAC,EAAE,eAAe,wBAAsB,EAC/C,OAAOA,EAAE,aAAa,EAAE,KAAKD,EAAM,aAAa,CAClD,CAAC,CACH,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_makeInternalApi", "import_CreateBackupDeviceActionErrors", "import_BackupAppsStorage", "import_BackupAppStorageTask", "apiMock", "MockTask", "installedApps", "runMock", "result", "error", "e"]
 }

package/lib/cjs/api/task/OsUpdate/Backup/BackupAppStorageTask.js

@@ -0,0 +1,2 @@
+"use strict";var g=Object.defineProperty;var S=Object.getOwnPropertyDescriptor;var k=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var A=(o,r)=>{for(var a in r)g(o,a,{get:r[a],enumerable:!0})},C=(o,r,a,p)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of k(r))!l.call(o,t)&&t!==a&&g(o,t,{get:()=>r[t],enumerable:!(p=S(r,t))||p.enumerable});return o};var y=o=>C(g({},"__esModule",{value:!0}),o);var B={};A(B,{BackupAppStorageTask:()=>f});module.exports=y(B);var e=require("@ledgerhq/device-management-kit"),i=require("../../../command/OsUpdate/Backup/BackupAppStorageCommand"),m=require("../../../command/OsUpdate/Backup/GetAppStorageInfoCommand");class f{constructor(r,a,p){this.args=r;this.api=a;this.logger=p}async run(){this.logger.debug("[run] Starting BackupAppStorageTask",{data:{appName:this.args.appName}});const{appName:r}=this.args,a=await this.api.sendCommand(new m.GetAppStorageInfoCommand({appName:r}));if(!(0,e.isSuccessCommandResult)(a))return this.logger.debug("[run] Failed to get app storage info",{data:{error:a.error}}),(0,e.DmkResultFactory)({error:a.error});const{storageSize:p}=a.data;let t=0,n=new Uint8Array(0);for(;t<p;){const s=await this.api.sendCommand(new i.BackupAppStorageCommand);if(!(0,e.isSuccessCommandResult)(s))return this.logger.debug("[run] Failed to backup app storage",{data:{error:s.error}}),(0,e.DmkResultFactory)({error:s.error});const{chunkData:d,chunkSize:c}=s.data;n=Uint8Array.from([...n,...d]),t+=c}const u=(0,e.bufferToHexaString)(n);return this.logger.debug("[run] App storage data backed up successfully",{data:{appStorageData:u}}),(0,e.DmkResultFactory)({data:{appStorageData:u}})}}0&&(module.exports={BackupAppStorageTask});
+//# sourceMappingURL=BackupAppStorageTask.js.map

package/lib/cjs/api/task/OsUpdate/Backup/BackupAppStorageTask.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/task/OsUpdate/Backup/BackupAppStorageTask.ts"],
+  "sourcesContent": ["import {\n  bufferToHexaString,\n  type CommandErrorResult,\n  type DmkResult,\n  DmkResultFactory,\n  type HexaString,\n  type InternalApi,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  BackupAppStorageCommand,\n  type BackupAppStorageCommandErrorCodes,\n} from \"@api/command/OsUpdate/Backup/BackupAppStorageCommand\";\nimport {\n  GetAppStorageInfoCommand,\n  type GetAppStorageInfoCommandErrorCodes,\n} from \"@api/command/OsUpdate/Backup/GetAppStorageInfoCommand\";\n\nexport type BackupAppStorageTaskArgs = {\n  appName: string;\n};\n\nexport type BackupAppStorageTaskResponse = {\n  appStorageData: HexaString;\n};\n\nexport type BackupAppStorageTaskErrorCodes =\n  | GetAppStorageInfoCommandErrorCodes\n  | BackupAppStorageCommandErrorCodes;\n\nexport type BackupAppStorageTaskError =\n  | CommandErrorResult<GetAppStorageInfoCommandErrorCodes>[\"error\"]\n  | CommandErrorResult<BackupAppStorageCommandErrorCodes>[\"error\"];\n\nexport class BackupAppStorageTask {\n  constructor(\n    private readonly args: BackupAppStorageTaskArgs,\n    private readonly api: InternalApi,\n    private readonly logger: LoggerPublisherService,\n  ) {}\n\n  public async run(): Promise<\n    DmkResult<BackupAppStorageTaskResponse, BackupAppStorageTaskError>\n  > {\n    this.logger.debug(\"[run] Starting BackupAppStorageTask\", {\n      data: {\n        appName: this.args.appName,\n      },\n    });\n\n    const { appName } = this.args;\n\n    const getAppStorageInfo = await this.api.sendCommand(\n      new GetAppStorageInfoCommand({\n        appName,\n      }),\n    );\n\n    if (!isSuccessCommandResult(getAppStorageInfo)) {\n      this.logger.debug(\"[run] Failed to get app storage info\", {\n        data: { error: getAppStorageInfo.error },\n      });\n      return DmkResultFactory({\n        error: getAppStorageInfo.error,\n      });\n    }\n\n    const { storageSize } = getAppStorageInfo.data;\n    let offset = 0;\n    let appStorageDataBytes = new Uint8Array(0);\n\n    while (offset < storageSize) {\n      const backupStorage = await this.api.sendCommand(\n        new BackupAppStorageCommand(),\n      );\n      if (!isSuccessCommandResult(backupStorage)) {\n        this.logger.debug(\"[run] Failed to backup app storage\", {\n          data: { error: backupStorage.error },\n        });\n        return DmkResultFactory({\n          error: backupStorage.error,\n        });\n      }\n\n      const { chunkData, chunkSize } = backupStorage.data;\n      appStorageDataBytes = Uint8Array.from([\n        ...appStorageDataBytes,\n        ...chunkData,\n      ]);\n      offset += chunkSize;\n    }\n\n    const appStorageData = bufferToHexaString(appStorageDataBytes);\n    this.logger.debug(\"[run] App storage data backed up successfully\", {\n      data: {\n        appStorageData,\n      },\n    });\n\n    return DmkResultFactory({\n      data: {\n        appStorageData,\n      },\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EASO,2CAEPC,EAGO,gEACPC,EAGO,iEAkBA,MAAMJ,CAAqB,CAChC,YACmBK,EACAC,EACAC,EACjB,CAHiB,UAAAF,EACA,SAAAC,EACA,YAAAC,CAChB,CAEH,MAAa,KAEX,CACA,KAAK,OAAO,MAAM,sCAAuC,CACvD,KAAM,CACJ,QAAS,KAAK,KAAK,OACrB,CACF,CAAC,EAED,KAAM,CAAE,QAAAC,CAAQ,EAAI,KAAK,KAEnBC,EAAoB,MAAM,KAAK,IAAI,YACvC,IAAI,2BAAyB,CAC3B,QAAAD,CACF,CAAC,CACH,EAEA,GAAI,IAAC,0BAAuBC,CAAiB,EAC3C,YAAK,OAAO,MAAM,uCAAwC,CACxD,KAAM,CAAE,MAAOA,EAAkB,KAAM,CACzC,CAAC,KACM,oBAAiB,CACtB,MAAOA,EAAkB,KAC3B,CAAC,EAGH,KAAM,CAAE,YAAAC,CAAY,EAAID,EAAkB,KAC1C,IAAIE,EAAS,EACTC,EAAsB,IAAI,WAAW,CAAC,EAE1C,KAAOD,EAASD,GAAa,CAC3B,MAAMG,EAAgB,MAAM,KAAK,IAAI,YACnC,IAAI,yBACN,EACA,GAAI,IAAC,0BAAuBA,CAAa,EACvC,YAAK,OAAO,MAAM,qCAAsC,CACtD,KAAM,CAAE,MAAOA,EAAc,KAAM,CACrC,CAAC,KACM,oBAAiB,CACtB,MAAOA,EAAc,KACvB,CAAC,EAGH,KAAM,CAAE,UAAAC,EAAW,UAAAC,CAAU,EAAIF,EAAc,KAC/CD,EAAsB,WAAW,KAAK,CACpC,GAAGA,EACH,GAAGE,CACL,CAAC,EACDH,GAAUI,CACZ,CAEA,MAAMC,KAAiB,sBAAmBJ,CAAmB,EAC7D,YAAK,OAAO,MAAM,gDAAiD,CACjE,KAAM,CACJ,eAAAI,CACF,CACF,CAAC,KAEM,oBAAiB,CACtB,KAAM,CACJ,eAAAA,CACF,CACF,CAAC,CACH,CACF",
+  "names": ["BackupAppStorageTask_exports", "__export", "BackupAppStorageTask", "__toCommonJS", "import_device_management_kit", "import_BackupAppStorageCommand", "import_GetAppStorageInfoCommand", "args", "api", "logger", "appName", "getAppStorageInfo", "storageSize", "offset", "appStorageDataBytes", "backupStorage", "chunkData", "chunkSize", "appStorageData"]
+}

package/lib/cjs/api/task/OsUpdate/Backup/BackupAppStorageTask.test.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("@ledgerhq/device-management-kit"),p=require("../../../command/OsUpdate/Backup/BackupAppStorageCommand"),c=require("../../../command/OsUpdate/Backup/GetAppStorageInfoCommand"),n=require("./BackupAppStorageTask");describe("BackupAppStorageTask",()=>{let o,t;const s=vi.fn();beforeEach(()=>{vi.clearAllMocks(),o={sendCommand:s},t={debug:vi.fn()}}),describe("Success",()=>{it("should backup app storage data successfully",async()=>{const r=new n.BackupAppStorageTask({appName:"MyApp"},o,t);s.mockResolvedValueOnce((0,e.CommandResultFactory)({data:{storageSize:15}})).mockResolvedValueOnce((0,e.CommandResultFactory)({data:{chunkData:new Uint8Array([1,35,69,103,137]),chunkSize:5}})).mockResolvedValueOnce((0,e.CommandResultFactory)({data:{chunkData:new Uint8Array([10,11,12,13,14]),chunkSize:5}})).mockResolvedValueOnce((0,e.CommandResultFactory)({data:{chunkData:new Uint8Array([15,16,17,18,19]),chunkSize:5}}));const a=await r.run();expect((0,e.isSuccessDmkResult)(a)).toBe(!0),expect(a.data.appStorageData).toBe("0x01234567890a0b0c0d0e0f10111213")})}),describe("Error",()=>{it("should return error when getting app storage info fails",async()=>{const r=new n.BackupAppStorageTask({appName:"MyApp"},o,t);s.mockResolvedValueOnce((0,e.CommandResultFactory)({error:new c.GetAppStorageInfoCommandError({message:"Application not found.",errorCode:"5123"})}));const a=await r.run();expect(a).toStrictEqual((0,e.DmkResultFactory)({error:new c.GetAppStorageInfoCommandError({message:"Application not found.",errorCode:"5123"})}))}),it("should return error when backing up app storage data fails",async()=>{const r=new n.BackupAppStorageTask({appName:"MyApp"},o,t);s.mockResolvedValueOnce((0,e.CommandResultFactory)({data:{storageSize:100}})).mockResolvedValueOnce((0,e.CommandResultFactory)({error:new p.BackupAppStorageCommandError({message:"Failed to backup app storage data.",errorCode:"541c"})}));const a=await r.run();expect((0,e.isSuccessDmkResult)(a)).toBe(!1),expect(a.error).toBeInstanceOf(p.BackupAppStorageCommandError),expect(a.error.message).toBe("Failed to backup app storage data.")})})});
+//# sourceMappingURL=BackupAppStorageTask.test.js.map

package/lib/cjs/api/task/OsUpdate/Backup/BackupAppStorageTask.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/task/OsUpdate/Backup/BackupAppStorageTask.test.ts"],
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  DmkResultFactory,\n  type InternalApi,\n  isSuccessDmkResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { BackupAppStorageCommandError } from \"@api/command/OsUpdate/Backup/BackupAppStorageCommand\";\nimport { GetAppStorageInfoCommandError } from \"@api/command/OsUpdate/Backup/GetAppStorageInfoCommand\";\n\nimport {\n  BackupAppStorageTask,\n  type BackupAppStorageTaskResponse,\n} from \"./BackupAppStorageTask\";\n\ndescribe(\"BackupAppStorageTask\", () => {\n  let api: InternalApi;\n  let logger: LoggerPublisherService;\n  const sendCommand = vi.fn();\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n    api = {\n      sendCommand,\n    } as unknown as InternalApi;\n    logger = {\n      debug: vi.fn(),\n    } as unknown as LoggerPublisherService;\n  });\n\n  describe(\"Success\", () => {\n    it(\"should backup app storage data successfully\", async () => {\n      // ARRANGE\n      const task = new BackupAppStorageTask(\n        {\n          appName: \"MyApp\",\n        },\n        api,\n        logger,\n      );\n\n      sendCommand\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { storageSize: 15 } }),\n        )\n        .mockResolvedValueOnce(\n          CommandResultFactory({\n            data: {\n              chunkData: new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89]),\n              chunkSize: 5,\n            },\n          }),\n        )\n        .mockResolvedValueOnce(\n          CommandResultFactory({\n            data: {\n              chunkData: new Uint8Array([0x0a, 0x0b, 0x0c, 0x0d, 0x0e]),\n              chunkSize: 5,\n            },\n          }),\n        )\n        .mockResolvedValueOnce(\n          CommandResultFactory({\n            data: {\n              chunkData: new Uint8Array([0x0f, 0x10, 0x11, 0x12, 0x13]),\n              chunkSize: 5,\n            },\n          }),\n        );\n\n      // ACT\n      const result = await task.run();\n\n      // ASSERT\n      expect(isSuccessDmkResult(result)).toBe(true);\n      expect(\n        (result as { data: BackupAppStorageTaskResponse }).data.appStorageData,\n      ).toBe(\"0x01234567890a0b0c0d0e0f10111213\");\n    });\n  });\n\n  describe(\"Error\", () => {\n    it(\"should return error when getting app storage info fails\", async () => {\n      // ARRANGE\n      const task = new BackupAppStorageTask(\n        {\n          appName: \"MyApp\",\n        },\n        api,\n        logger,\n      );\n\n      sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          error: new GetAppStorageInfoCommandError({\n            message: \"Application not found.\",\n            errorCode: \"5123\",\n          }),\n        }),\n      );\n\n      // ACT\n      const result = await task.run();\n\n      // ASSERT\n      expect(result).toStrictEqual(\n        DmkResultFactory({\n          error: new GetAppStorageInfoCommandError({\n            message: \"Application not found.\",\n            errorCode: \"5123\",\n          }),\n        }),\n      );\n    });\n\n    it(\"should return error when backing up app storage data fails\", async () => {\n      // ARRANGE\n      const task = new BackupAppStorageTask(\n        {\n          appName: \"MyApp\",\n        },\n        api,\n        logger,\n      );\n\n      sendCommand\n        .mockResolvedValueOnce(\n          CommandResultFactory({ data: { storageSize: 100 } }),\n        )\n        .mockResolvedValueOnce(\n          CommandResultFactory({\n            error: new BackupAppStorageCommandError({\n              message: \"Failed to backup app storage data.\",\n              errorCode: \"541c\",\n            }),\n          }),\n        );\n\n      // ACT\n      const result = await task.run();\n\n      // ASSERT\n      expect(isSuccessDmkResult(result)).toBe(false);\n      expect(\n        (result as { error: BackupAppStorageCommandError }).error,\n      ).toBeInstanceOf(BackupAppStorageCommandError);\n      expect(\n        (result as { error: BackupAppStorageCommandError }).error.message,\n      ).toBe(\"Failed to backup app storage data.\");\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAMO,2CAEPC,EAA6C,gEAC7CC,EAA8C,iEAE9CC,EAGO,kCAEP,SAAS,uBAAwB,IAAM,CACrC,IAAIC,EACAC,EACJ,MAAMC,EAAc,GAAG,GAAG,EAE1B,WAAW,IAAM,CACf,GAAG,cAAc,EACjBF,EAAM,CACJ,YAAAE,CACF,EACAD,EAAS,CACP,MAAO,GAAG,GAAG,CACf,CACF,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,8CAA+C,SAAY,CAE5D,MAAME,EAAO,IAAI,uBACf,CACE,QAAS,OACX,EACAH,EACAC,CACF,EAEAC,EACG,yBACC,wBAAqB,CAAE,KAAM,CAAE,YAAa,EAAG,CAAE,CAAC,CACpD,EACC,yBACC,wBAAqB,CACnB,KAAM,CACJ,UAAW,IAAI,WAAW,CAAC,EAAM,GAAM,GAAM,IAAM,GAAI,CAAC,EACxD,UAAW,CACb,CACF,CAAC,CACH,EACC,yBACC,wBAAqB,CACnB,KAAM,CACJ,UAAW,IAAI,WAAW,CAAC,GAAM,GAAM,GAAM,GAAM,EAAI,CAAC,EACxD,UAAW,CACb,CACF,CAAC,CACH,EACC,yBACC,wBAAqB,CACnB,KAAM,CACJ,UAAW,IAAI,WAAW,CAAC,GAAM,GAAM,GAAM,GAAM,EAAI,CAAC,EACxD,UAAW,CACb,CACF,CAAC,CACH,EAGF,MAAME,EAAS,MAAMD,EAAK,IAAI,EAG9B,UAAO,sBAAmBC,CAAM,CAAC,EAAE,KAAK,EAAI,EAC5C,OACGA,EAAkD,KAAK,cAC1D,EAAE,KAAK,kCAAkC,CAC3C,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,0DAA2D,SAAY,CAExE,MAAMD,EAAO,IAAI,uBACf,CACE,QAAS,OACX,EACAH,EACAC,CACF,EAEAC,EAAY,yBACV,wBAAqB,CACnB,MAAO,IAAI,gCAA8B,CACvC,QAAS,yBACT,UAAW,MACb,CAAC,CACH,CAAC,CACH,EAGA,MAAME,EAAS,MAAMD,EAAK,IAAI,EAG9B,OAAOC,CAAM,EAAE,iBACb,oBAAiB,CACf,MAAO,IAAI,gCAA8B,CACvC,QAAS,yBACT,UAAW,MACb,CAAC,CACH,CAAC,CACH,CACF,CAAC,EAED,GAAG,6DAA8D,SAAY,CAE3E,MAAMD,EAAO,IAAI,uBACf,CACE,QAAS,OACX,EACAH,EACAC,CACF,EAEAC,EACG,yBACC,wBAAqB,CAAE,KAAM,CAAE,YAAa,GAAI,CAAE,CAAC,CACrD,EACC,yBACC,wBAAqB,CACnB,MAAO,IAAI,+BAA6B,CACtC,QAAS,qCACT,UAAW,MACb,CAAC,CACH,CAAC,CACH,EAGF,MAAME,EAAS,MAAMD,EAAK,IAAI,EAG9B,UAAO,sBAAmBC,CAAM,CAAC,EAAE,KAAK,EAAK,EAC7C,OACGA,EAAmD,KACtD,EAAE,eAAe,8BAA4B,EAC7C,OACGA,EAAmD,MAAM,OAC5D,EAAE,KAAK,oCAAoC,CAC7C,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_BackupAppStorageCommand", "import_GetAppStorageInfoCommand", "import_BackupAppStorageTask", "api", "logger", "sendCommand", "task", "result"]
+}

package/lib/cjs/api/task/OsUpdate/Restore/RestoreAppStorageTask.js

@@ -0,0 +1,2 @@
+"use strict";var p=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var u=(o,r)=>{for(var e in r)p(o,e,{get:r[e],enumerable:!0})},d=(o,r,e,s)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of i(r))!l.call(o,t)&&t!==e&&p(o,t,{get:()=>r[t],enumerable:!(s=n(r,t))||s.enumerable});return o};var m=o=>d(p({},"__esModule",{value:!0}),o);var c={};u(c,{RestoreAppStorageTask:()=>A});module.exports=m(c);var a=require("@ledgerhq/device-management-kit"),g=require("../../../command/OsUpdate/Restore/RestoreAppStorageCommand");class A{constructor(r,e,s){this.args=r;this.api=e;this.logger=s}async run(){const{appStorageData:r}=this.args;this.logger.debug("[run] Starting RestoreAppStorageTask",{data:{appStorageDataLength:r.length}});let e=0;for(;e<r.length;){const s=r.subarray(e,e+a.APDU_MAX_PAYLOAD),t=await this.api.sendCommand(new g.RestoreAppStorageCommand({chunkData:s}));if(!(0,a.isSuccessCommandResult)(t))return this.logger.debug("[run] Failed to restore app storage chunk",{data:{error:t.error}}),(0,a.DmkResultFactory)({error:t.error});e+=s.length}return this.logger.debug("[run] App storage data restored successfully"),(0,a.DmkResultFactory)({data:void 0})}}0&&(module.exports={RestoreAppStorageTask});
+//# sourceMappingURL=RestoreAppStorageTask.js.map

package/lib/cjs/api/task/OsUpdate/Restore/RestoreAppStorageTask.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/task/OsUpdate/Restore/RestoreAppStorageTask.ts"],
+  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  type CommandErrorResult,\n  type DmkResult,\n  DmkResultFactory,\n  type InternalApi,\n  isSuccessCommandResult,\n  type LoggerPublisherService,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  RestoreAppStorageCommand,\n  type RestoreAppStorageCommandErrorCodes,\n} from \"@api/command/OsUpdate/Restore/RestoreAppStorageCommand\";\n\nexport type RestoreAppStorageTaskArgs = {\n  appStorageData: Uint8Array;\n};\n\nexport type RestoreAppStorageTaskError =\n  CommandErrorResult<RestoreAppStorageCommandErrorCodes>[\"error\"];\n\nexport class RestoreAppStorageTask {\n  constructor(\n    private readonly args: RestoreAppStorageTaskArgs,\n    private readonly api: InternalApi,\n    private readonly logger: LoggerPublisherService,\n  ) {}\n\n  public async run(): Promise<DmkResult<void, RestoreAppStorageTaskError>> {\n    const { appStorageData } = this.args;\n\n    this.logger.debug(\"[run] Starting RestoreAppStorageTask\", {\n      data: {\n        appStorageDataLength: appStorageData.length,\n      },\n    });\n\n    let offset = 0;\n\n    while (offset < appStorageData.length) {\n      const chunkData = appStorageData.subarray(\n        offset,\n        offset + APDU_MAX_PAYLOAD,\n      );\n\n      const restoreAppStorage = await this.api.sendCommand(\n        new RestoreAppStorageCommand({ chunkData }),\n      );\n\n      if (!isSuccessCommandResult(restoreAppStorage)) {\n        this.logger.debug(\"[run] Failed to restore app storage chunk\", {\n          data: { error: restoreAppStorage.error },\n        });\n        return DmkResultFactory({\n          error: restoreAppStorage.error,\n        });\n      }\n\n      offset += chunkData.length;\n    }\n\n    this.logger.debug(\"[run] App storage data restored successfully\");\n\n    return DmkResultFactory({\n      data: undefined,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,2BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAQO,2CAEPC,EAGO,kEASA,MAAMH,CAAsB,CACjC,YACmBI,EACAC,EACAC,EACjB,CAHiB,UAAAF,EACA,SAAAC,EACA,YAAAC,CAChB,CAEH,MAAa,KAA4D,CACvE,KAAM,CAAE,eAAAC,CAAe,EAAI,KAAK,KAEhC,KAAK,OAAO,MAAM,uCAAwC,CACxD,KAAM,CACJ,qBAAsBA,EAAe,MACvC,CACF,CAAC,EAED,IAAIC,EAAS,EAEb,KAAOA,EAASD,EAAe,QAAQ,CACrC,MAAME,EAAYF,EAAe,SAC/BC,EACAA,EAAS,kBACX,EAEME,EAAoB,MAAM,KAAK,IAAI,YACvC,IAAI,2BAAyB,CAAE,UAAAD,CAAU,CAAC,CAC5C,EAEA,GAAI,IAAC,0BAAuBC,CAAiB,EAC3C,YAAK,OAAO,MAAM,4CAA6C,CAC7D,KAAM,CAAE,MAAOA,EAAkB,KAAM,CACzC,CAAC,KACM,oBAAiB,CACtB,MAAOA,EAAkB,KAC3B,CAAC,EAGHF,GAAUC,EAAU,MACtB,CAEA,YAAK,OAAO,MAAM,8CAA8C,KAEzD,oBAAiB,CACtB,KAAM,MACR,CAAC,CACH,CACF",
+  "names": ["RestoreAppStorageTask_exports", "__export", "RestoreAppStorageTask", "__toCommonJS", "import_device_management_kit", "import_RestoreAppStorageCommand", "args", "api", "logger", "appStorageData", "offset", "chunkData", "restoreAppStorage"]
+}

package/lib/cjs/api/task/OsUpdate/Restore/RestoreAppStorageTask.test.js

@@ -0,0 +1,2 @@
+"use strict";var i=require("@ledgerhq/device-management-kit"),e=require("@ledgerhq/device-management-kit"),l=require("../../../command/OsUpdate/Restore/RestoreAppStorageCommand"),c=require("./RestoreAppStorageTask");describe("RestoreAppStorageTask",()=>{let r,s;const t=vi.fn();beforeEach(()=>{vi.clearAllMocks(),r={sendCommand:t},s={debug:vi.fn()}}),describe("Success",()=>{it("should send a single chunk when the data fits in one APDU",async()=>{const a=Uint8Array.from([1,2,3]),n=new c.RestoreAppStorageTask({appStorageData:a},r,s);t.mockResolvedValueOnce((0,e.CommandResultFactory)({data:void 0}));const o=await n.run();expect((0,e.isSuccessDmkResult)(o)).toBe(!0),expect(t).toHaveBeenCalledTimes(1),expect(t).toHaveBeenCalledWith(expect.objectContaining({args:{chunkData:a}}))}),it("should split the data into several chunks when it does not fit in a single APDU",async()=>{const a=new Uint8Array(i.APDU_MAX_PAYLOAD+45).map((d,p)=>p%256),n=new c.RestoreAppStorageTask({appStorageData:a},r,s);t.mockResolvedValueOnce((0,e.CommandResultFactory)({data:void 0})).mockResolvedValueOnce((0,e.CommandResultFactory)({data:void 0}));const o=await n.run();expect((0,e.isSuccessDmkResult)(o)).toBe(!0),expect(t).toHaveBeenCalledTimes(2),expect(t).toHaveBeenNthCalledWith(1,expect.objectContaining({args:{chunkData:a.slice(0,i.APDU_MAX_PAYLOAD)}})),expect(t).toHaveBeenNthCalledWith(2,expect.objectContaining({args:{chunkData:a.slice(i.APDU_MAX_PAYLOAD)}}))}),it("should not send any command when the data is empty",async()=>{const n=await new c.RestoreAppStorageTask({appStorageData:new Uint8Array(0)},r,s).run();expect((0,e.isSuccessDmkResult)(n)).toBe(!0),expect(t).not.toHaveBeenCalled()})}),describe("Error",()=>{it("should return error when restoring a chunk fails",async()=>{const a=Uint8Array.from([1,2,3]),n=new c.RestoreAppStorageTask({appStorageData:a},r,s);t.mockResolvedValueOnce((0,e.CommandResultFactory)({error:new l.RestoreAppStorageCommandError({message:"Failed to decrypt the app storage backup.",errorCode:"541a"})}));const o=await n.run();expect(o).toStrictEqual((0,e.DmkResultFactory)({error:new l.RestoreAppStorageCommandError({message:"Failed to decrypt the app storage backup.",errorCode:"541a"})}))}),it("should stop sending chunks as soon as one fails",async()=>{const a=new Uint8Array(i.APDU_MAX_PAYLOAD+10),n=new c.RestoreAppStorageTask({appStorageData:a},r,s);t.mockResolvedValueOnce((0,e.CommandResultFactory)({error:new l.RestoreAppStorageCommandError({message:"Invalid chunk length.",errorCode:"6734"})}));const o=await n.run();expect((0,e.isSuccessDmkResult)(o)).toBe(!1),expect(t).toHaveBeenCalledTimes(1)})})});
+//# sourceMappingURL=RestoreAppStorageTask.test.js.map