@ledgerhq/device-management-kit 0.0.0-develop-20250106155719 → 0.0.0-rn-hid-20250221112139

package/lib/cjs/src/api/apdu/utils/ByteArrayParser.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayParser.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { ByteArrayParser } from \"./ByteArrayParser\";\n\nconst RESPONSE_ONE_BYTE = new Uint8Array([0x01]);\nconst RESPONSE_LV_ZERO = new Uint8Array([0x00]);\nconst RESPONSE_TWO_BYTES = new Uint8Array([0x01, 0x01]);\nconst RESPONSE_TLV_ZERO = new Uint8Array([0xab, 0x00]);\nconst RESPONSE_ALL_BYTES = new Uint8Array([\n  0x01,\n  0x02,\n  0x03,\n  ...Array<number>(253).fill(0xaa),\n]);\n\n/*\nType : 33 00 00 04 -> nanoX\nVersion SE (LV): 2.2.3\nFlag: E600000000\n  PIN OK\n  Factory init Ok\n  Onboarding done\nVersion MCU(LV): 2.30\nVersion BootLoader(LV): 1.16\nHW rev: 0\nLanguage(LV): Fra & Eng\nRecover state (LV): 1\n*/\nconst DEVICE_TYPE = \"33000004\";\nconst DEVICE_FLAGS = \"0xe6000000\";\nconst NUMERIC_FLAGS = 0xe6000000;\nconst VERSION_FW_SE = \"2.2.3\";\nconst VERSION_FW_MCU = \"2.30\";\nconst VERSION_FW_BL = \"1.16\";\nconst HARDWARE_REV = 0;\nconst LANGUAGE_PACK = 1;\nconst RECOVER_STATE = 0;\nconst RESPONSE_GET_VERSION = new Uint8Array([\n  0x33, 0x00, 0x00, 0x04, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x32, 0x2e, 0x33, 0x30, 0x04, 0x31, 0x2e, 0x31, 0x36, 0x01,\n  0x00, 0x01, 0x01, 0x01, 0x00,\n]);\n\n/*\nFormat version: 1\nName: BOLOS\nVersion: 2.2.3\n*/\nconst DASHBOARD_HEX = new Uint8Array([0x42, 0x4f, 0x4c, 0x4f, 0x53]);\nconst DASHBOARD_NAME = \"BOLOS\";\nconst RESPONSE_GET_APP_VERSION = new Uint8Array([\n  0x01, 0x05, 0x42, 0x4f, 0x4c, 0x4f, 0x53, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33,\n]);\n\nlet parser: ByteArrayParser;\nlet response = RESPONSE_ONE_BYTE;\n\ndescribe(\"ByteArrayParser\", () => {\n  const parserExtractNumber = (\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ): bigint | number | undefined => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitInt(bigEndian);\n        case 4:\n          return parser.extract32BitInt(bigEndian);\n        case 8:\n          return parser.extract64BitInt(bigEndian);\n        case 16:\n          return parser.extract128BitInt(bigEndian);\n        case 32:\n          return parser.extract256BitInt(bigEndian);\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitUInt(bigEndian);\n        case 4:\n          return parser.extract32BitUInt(bigEndian);\n        case 8:\n          return parser.extract64BitUInt(bigEndian);\n        case 16:\n          return parser.extract128BitUInt(bigEndian);\n        case 32:\n          return parser.extract256BitUInt(bigEndian);\n      }\n    }\n    return undefined;\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      jest.resetAllMocks();\n    });\n\n    it(\"should create an instance\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser).toBeDefined();\n      expect(parser).toBeInstanceOf(ByteArrayParser);\n    });\n\n    it(\"Extract a single byte\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n    });\n\n    it(\"Extract one byte\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x02);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x03);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      while (length != 0) {\n        expect(parser.extract8BitUInt()).toBe(0xaa);\n        expect(parser.getCurrentIndex()).toBe(index);\n        expect(parser.getUnparsedRemainingLength()).toBe(length);\n        index++;\n        length--;\n      }\n    });\n\n    it.each([\n      [2, false, true, \"ffff\", 0xffff],\n      [2, true, true, \"7fff\", 0x7fff],\n      [2, true, true, \"8000\", -0x8000],\n      [4, false, true, \"ffffffff\", 0xffffffff],\n      [4, true, true, \"7fffffff\", 0x7fffffff],\n      [4, true, true, \"80000000\", -0x80000000],\n      [8, false, true, \"ffffffffffffffff\", 0xffffffffffffffffn],\n      [8, true, true, \"7fffffffffffffff\", 0x7fffffffffffffffn],\n      [8, true, true, \"8000000000000000\", -0x8000000000000000n],\n      [\n        16,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"80000000000000000000000000000000\",\n        -0x80000000000000000000000000000000n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n      ],\n    ])(\n      \"Extract a number to the limit: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it.each([\n      [2, false, true, \"3302\", 0x3302],\n      [2, false, false, \"0233\", 0x3302],\n      [2, true, true, \"1068\", 4200],\n      [2, true, true, \"ef98\", -4200],\n      [2, true, false, \"6810\", 4200],\n      [2, true, false, \"98ef\", -4200],\n      [4, false, true, \"01234567\", 0x01234567],\n      [4, false, false, \"67452301\", 0x01234567],\n      [4, true, true, \"075bcd15\", 123456789],\n      [4, true, true, \"f8a432eb\", -123456789],\n      [4, true, false, \"15cd5b07\", 123456789],\n      [4, true, false, \"eb32a4f8\", -123456789],\n      [8, false, true, \"0032435442584447\", 14147778004927559n],\n      [8, false, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, true, \"0032435442584447\", 14147778004927559n],\n      [8, true, true, \"ffcdbcabbda7bbb9\", -14147778004927559n],\n      [8, true, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, false, \"b9bba7bdabbccdff\", -14147778004927559n],\n      [\n        16,\n        false,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        false,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n    ])(\n      \"Extract the following number: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it(\"Extract 16-bit & 32-bit number\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x0102);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x03aa);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_ALL_BYTES.length;\n\n      expect(parser.extract32BitUInt()).toBe(0x010203aa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBe(0xaaaaaaaa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetAppVersion response\", () => {\n      response = RESPONSE_GET_APP_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_APP_VERSION.length;\n\n      // Parse the response considering the first field to be the format field\n      expect(length).toBe(13);\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      index++;\n      length--;\n      expect(value).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldLVEncoded();\n      expect(array).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(array)).toBe(DASHBOARD_NAME);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      // Reparse the response considering the first field to be the TLV formatted\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_GET_APP_VERSION.length;\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0x01);\n      expect(field?.value).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(field?.value)).toBe(DASHBOARD_NAME);\n      index += 7;\n      length -= 7;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetVersion response\", () => {\n      response = RESPONSE_GET_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_VERSION.length;\n\n      expect(length).toBe(31);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      expect(parser.testMinimalLength(25)).toBe(true);\n\n      let array = parser.extractFieldByLength(4);\n      expect(parser.encodeToHexaString(array)).toBe(DEVICE_TYPE);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      const flags = parser.encodeToHexaString(array, true);\n      expect(flags).toBe(DEVICE_FLAGS);\n      expect(parseInt(flags, 16)).toBe(NUMERIC_FLAGS);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_MCU);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_BL);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(HARDWARE_REV);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(LANGUAGE_PACK);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(RECOVER_STATE);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n  });\n\n  describe(\"errors\", () => {\n    it(\"no response\", () => {\n      response = new Uint8Array();\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = 0;\n\n      expect(parser.testMinimalLength(1)).toBe(false);\n\n      expect(parser.extract8BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"length error\", () => {\n      response = RESPONSE_ONE_BYTE;\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = RESPONSE_ONE_BYTE.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      response = RESPONSE_TWO_BYTES;\n      parser = new ByteArrayParser(response);\n\n      field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(\n        RESPONSE_TWO_BYTES.length,\n      );\n    });\n\n    it(\"Test zero length\", () => {\n      response = RESPONSE_LV_ZERO;\n      parser = new ByteArrayParser(response);\n      const zero = new Uint8Array();\n\n      const index = 0;\n      let length = RESPONSE_LV_ZERO.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      expect(value).toBe(0);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      parser.resetIndex();\n\n      let array = parser.extractFieldByLength(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n\n      response = RESPONSE_TLV_ZERO;\n      parser = new ByteArrayParser(response);\n      length = RESPONSE_TLV_ZERO.length;\n\n      expect(length).toBe(2);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0xab);\n      expect(field?.value).toStrictEqual(zero);\n      expect(parser.encodeToString(field?.value)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(2);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      expect(parser.encodeToHexaString()).toBe(\"\");\n      expect(parser.encodeToString()).toBe(\"\");\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { ByteArrayParser } from \"./ByteArrayParser\";\n\nconst RESPONSE_ONE_BYTE = new Uint8Array([0x01]);\nconst RESPONSE_LV_ZERO = new Uint8Array([0x00]);\nconst RESPONSE_TWO_BYTES = new Uint8Array([0x01, 0x01]);\nconst RESPONSE_TLV_ZERO = new Uint8Array([0xab, 0x00]);\nconst RESPONSE_ALL_BYTES = new Uint8Array([\n  0x01,\n  0x02,\n  0x03,\n  ...Array<number>(253).fill(0xaa),\n]);\n\n/*\nType : 33 00 00 04 -> nanoX\nVersion SE (LV): 2.2.3\nFlag: E600000000\n  PIN OK\n  Factory init Ok\n  Onboarding done\nVersion MCU(LV): 2.30\nVersion BootLoader(LV): 1.16\nHW rev: 0\nLanguage(LV): Fra & Eng\nRecover state (LV): 1\n*/\nconst DEVICE_TYPE = \"33000004\";\nconst DEVICE_FLAGS = \"0xe6000000\";\nconst NUMERIC_FLAGS = 0xe6000000;\nconst VERSION_FW_SE = \"2.2.3\";\nconst VERSION_FW_MCU = \"2.30\";\nconst VERSION_FW_BL = \"1.16\";\nconst HARDWARE_REV = 0;\nconst LANGUAGE_PACK = 1;\nconst RECOVER_STATE = 0;\nconst RESPONSE_GET_VERSION = new Uint8Array([\n  0x33, 0x00, 0x00, 0x04, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x32, 0x2e, 0x33, 0x30, 0x04, 0x31, 0x2e, 0x31, 0x36, 0x01,\n  0x00, 0x01, 0x01, 0x01, 0x00,\n]);\n\n/*\nFormat version: 1\nName: BOLOS\nVersion: 2.2.3\n*/\nconst DASHBOARD_HEX = new Uint8Array([0x42, 0x4f, 0x4c, 0x4f, 0x53]);\nconst DASHBOARD_NAME = \"BOLOS\";\nconst RESPONSE_GET_APP_VERSION = new Uint8Array([\n  0x01, 0x05, 0x42, 0x4f, 0x4c, 0x4f, 0x53, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33,\n]);\n\nlet parser: ByteArrayParser;\nlet response = RESPONSE_ONE_BYTE;\n\ndescribe(\"ByteArrayParser\", () => {\n  const parserExtractNumber = (\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ): bigint | number | undefined => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitInt(bigEndian);\n        case 4:\n          return parser.extract32BitInt(bigEndian);\n        case 8:\n          return parser.extract64BitInt(bigEndian);\n        case 16:\n          return parser.extract128BitInt(bigEndian);\n        case 32:\n          return parser.extract256BitInt(bigEndian);\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          return parser.extract16BitUInt(bigEndian);\n        case 4:\n          return parser.extract32BitUInt(bigEndian);\n        case 8:\n          return parser.extract64BitUInt(bigEndian);\n        case 16:\n          return parser.extract128BitUInt(bigEndian);\n        case 32:\n          return parser.extract256BitUInt(bigEndian);\n      }\n    }\n    return undefined;\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      vi.resetAllMocks();\n    });\n\n    it(\"should create an instance\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser).toBeDefined();\n      expect(parser).toBeInstanceOf(ByteArrayParser);\n    });\n\n    it(\"Extract a single byte\", () => {\n      parser = new ByteArrayParser(response);\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n    });\n\n    it(\"Extract one byte\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x01);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x02);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      expect(parser.extract8BitUInt()).toBe(0x03);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      index++;\n      length--;\n\n      while (length != 0) {\n        expect(parser.extract8BitUInt()).toBe(0xaa);\n        expect(parser.getCurrentIndex()).toBe(index);\n        expect(parser.getUnparsedRemainingLength()).toBe(length);\n        index++;\n        length--;\n      }\n    });\n\n    it.each([\n      [2, false, true, \"ffff\", 0xffff],\n      [2, true, true, \"7fff\", 0x7fff],\n      [2, true, true, \"8000\", -0x8000],\n      [4, false, true, \"ffffffff\", 0xffffffff],\n      [4, true, true, \"7fffffff\", 0x7fffffff],\n      [4, true, true, \"80000000\", -0x80000000],\n      [8, false, true, \"ffffffffffffffff\", 0xffffffffffffffffn],\n      [8, true, true, \"7fffffffffffffff\", 0x7fffffffffffffffn],\n      [8, true, true, \"8000000000000000\", -0x8000000000000000n],\n      [\n        16,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffn,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"80000000000000000000000000000000\",\n        -0x80000000000000000000000000000000n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n      ],\n    ])(\n      \"Extract a number to the limit: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it.each([\n      [2, false, true, \"3302\", 0x3302],\n      [2, false, false, \"0233\", 0x3302],\n      [2, true, true, \"1068\", 4200],\n      [2, true, true, \"ef98\", -4200],\n      [2, true, false, \"6810\", 4200],\n      [2, true, false, \"98ef\", -4200],\n      [4, false, true, \"01234567\", 0x01234567],\n      [4, false, false, \"67452301\", 0x01234567],\n      [4, true, true, \"075bcd15\", 123456789],\n      [4, true, true, \"f8a432eb\", -123456789],\n      [4, true, false, \"15cd5b07\", 123456789],\n      [4, true, false, \"eb32a4f8\", -123456789],\n      [8, false, true, \"0032435442584447\", 14147778004927559n],\n      [8, false, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, true, \"0032435442584447\", 14147778004927559n],\n      [8, true, true, \"ffcdbcabbda7bbb9\", -14147778004927559n],\n      [8, true, false, \"4744584254433200\", 14147778004927559n],\n      [8, true, false, \"b9bba7bdabbccdff\", -14147778004927559n],\n      [\n        16,\n        false,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        false,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"00324354425844470032435442584447\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"47445842544332004744584254433200\",\n        0x00324354425844470032435442584447n,\n      ],\n      [\n        16,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x00324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        false,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        true,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n      [\n        32,\n        true,\n        false,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n      ],\n    ])(\n      \"Extract the following number: size %i, signed %s, bigEndian %s, buffer %s, expected %i\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        parser = new ByteArrayParser(hexaStringToBuffer(input)!);\n        const result = parserExtractNumber(bigEndian, sizeInBits, signed);\n        expect(result).toStrictEqual(output);\n      },\n    );\n\n    it(\"Extract 16-bit & 32-bit number\", () => {\n      response = RESPONSE_ALL_BYTES;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_ALL_BYTES.length;\n\n      expect(length).toBe(256);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x0102);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBe(0x03aa);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_ALL_BYTES.length;\n\n      expect(parser.extract32BitUInt()).toBe(0x010203aa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBe(0xaaaaaaaa);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetAppVersion response\", () => {\n      response = RESPONSE_GET_APP_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_APP_VERSION.length;\n\n      // Parse the response considering the first field to be the format field\n      expect(length).toBe(13);\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      index++;\n      length--;\n      expect(value).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldLVEncoded();\n      expect(array).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(array)).toBe(DASHBOARD_NAME);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      // Reparse the response considering the first field to be the TLV formatted\n      parser.resetIndex();\n      index = 0;\n      length = RESPONSE_GET_APP_VERSION.length;\n\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0x01);\n      expect(field?.value).toStrictEqual(DASHBOARD_HEX);\n      expect(parser.encodeToString(field?.value)).toBe(DASHBOARD_NAME);\n      index += 7;\n      length -= 7;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"Parse a GetVersion response\", () => {\n      response = RESPONSE_GET_VERSION;\n      parser = new ByteArrayParser(response);\n      let index = 0;\n      let length = RESPONSE_GET_VERSION.length;\n\n      expect(length).toBe(31);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n      expect(parser.testMinimalLength(25)).toBe(true);\n\n      let array = parser.extractFieldByLength(4);\n      expect(parser.encodeToHexaString(array)).toBe(DEVICE_TYPE);\n      index += 4;\n      length -= 4;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_SE);\n      index += 6;\n      length -= 6;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      const flags = parser.encodeToHexaString(array, true);\n      expect(flags).toBe(DEVICE_FLAGS);\n      expect(parseInt(flags, 16)).toBe(NUMERIC_FLAGS);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_MCU);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.encodeToString(array)).toBe(VERSION_FW_BL);\n      index += 5;\n      length -= 5;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(HARDWARE_REV);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(LANGUAGE_PACK);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array?.at(0)).toBe(RECOVER_STATE);\n      index += 2;\n      length -= 2;\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n  });\n\n  describe(\"errors\", () => {\n    it(\"no response\", () => {\n      response = new Uint8Array();\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = 0;\n\n      expect(parser.testMinimalLength(1)).toBe(false);\n\n      expect(parser.extract8BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n    });\n\n    it(\"length error\", () => {\n      response = RESPONSE_ONE_BYTE;\n      parser = new ByteArrayParser(response);\n      const index = 0;\n      const length = RESPONSE_ONE_BYTE.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract16BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      expect(parser.extract32BitUInt()).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let array = parser.extractFieldByLength(2);\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(array).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      let field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      response = RESPONSE_TWO_BYTES;\n      parser = new ByteArrayParser(response);\n\n      field = parser.extractFieldTLVEncoded();\n      expect(field).toBeUndefined();\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(\n        RESPONSE_TWO_BYTES.length,\n      );\n    });\n\n    it(\"Test zero length\", () => {\n      response = RESPONSE_LV_ZERO;\n      parser = new ByteArrayParser(response);\n      const zero = new Uint8Array();\n\n      const index = 0;\n      let length = RESPONSE_LV_ZERO.length;\n\n      expect(length).toBe(1);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const value = parser.extract8BitUInt();\n      expect(value).toBe(0);\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      parser.resetIndex();\n\n      let array = parser.extractFieldByLength(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      array = parser.extractFieldLVEncoded();\n      expect(parser.getCurrentIndex()).toBe(1);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n      expect(array).toStrictEqual(zero);\n      expect(parser.encodeToString(array)).toBe(\"\");\n\n      response = RESPONSE_TLV_ZERO;\n      parser = new ByteArrayParser(response);\n      length = RESPONSE_TLV_ZERO.length;\n\n      expect(length).toBe(2);\n      expect(parser.getCurrentIndex()).toBe(index);\n      expect(parser.getUnparsedRemainingLength()).toBe(length);\n\n      const field = parser.extractFieldTLVEncoded();\n      expect(field?.tag).toBe(0xab);\n      expect(field?.value).toStrictEqual(zero);\n      expect(parser.encodeToString(field?.value)).toBe(\"\");\n      expect(parser.getCurrentIndex()).toBe(2);\n      expect(parser.getUnparsedRemainingLength()).toBe(0);\n\n      expect(parser.encodeToHexaString()).toBe(\"\");\n      expect(parser.encodeToString()).toBe(\"\");\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_HexaString", "import_ByteArrayParser", "RESPONSE_ONE_BYTE", "RESPONSE_LV_ZERO", "RESPONSE_TWO_BYTES", "RESPONSE_TLV_ZERO", "RESPONSE_ALL_BYTES", "DEVICE_TYPE", "DEVICE_FLAGS", "NUMERIC_FLAGS", "VERSION_FW_SE", "VERSION_FW_MCU", "VERSION_FW_BL", "HARDWARE_REV", "LANGUAGE_PACK", "RECOVER_STATE", "RESPONSE_GET_VERSION", "DASHBOARD_HEX", "DASHBOARD_NAME", "RESPONSE_GET_APP_VERSION", "parser", "response", "parserExtractNumber", "bigEndian", "sizeInBits", "signed", "index", "length", "input", "output", "result", "value", "array", "field", "flags", "zero"]
 }

package/lib/cjs/src/api/command/model/CommandResult.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/model/CommandResult.ts"],
-  "sourcesContent": ["import {\n  type InvalidBatteryDataError,\n  type InvalidBatteryStatusTypeError,\n  type InvalidResponseFormatError,\n  type InvalidStatusWordError,\n} from \"@api/command/Errors\";\nimport { type GlobalCommandErrorStatusCode } from \"@api/command/utils/GlobalCommandError\";\nimport {\n  type DeviceExchangeError,\n  type UnknownDeviceExchangeError,\n} from \"@api/Error\";\n\nexport enum CommandResultStatus {\n  Error = \"ERROR\",\n  Success = \"SUCCESS\",\n}\ntype CommandSuccessResult<Data> = {\n  status: CommandResultStatus.Success;\n  data: Data;\n};\nexport type CommandErrorResult<SpecificErrorCodes = void> = {\n  error:\n    | DeviceExchangeError<SpecificErrorCodes | GlobalCommandErrorStatusCode>\n    | InvalidBatteryDataError\n    | InvalidBatteryStatusTypeError\n    | InvalidResponseFormatError\n    | InvalidStatusWordError\n    | UnknownDeviceExchangeError;\n  status: CommandResultStatus.Error;\n};\nexport type CommandResult<Data, SpecificErrorCodes = void> =\n  | CommandSuccessResult<Data>\n  | CommandErrorResult<SpecificErrorCodes>;\n\nexport function CommandResultFactory<Data, SpecificErrorCodes = void>({\n  data,\n  error,\n}:\n  | { data: Data; error?: undefined }\n  | {\n      data?: undefined;\n      error:\n        | DeviceExchangeError<SpecificErrorCodes>\n        | InvalidBatteryDataError\n        | InvalidBatteryStatusTypeError\n        | InvalidResponseFormatError\n        | InvalidStatusWordError\n        | UnknownDeviceExchangeError;\n    }): CommandResult<Data, SpecificErrorCodes> {\n  if (error) {\n    return {\n      status: CommandResultStatus.Error,\n      error,\n    };\n  }\n  return {\n    status: CommandResultStatus.Success,\n    data,\n  };\n}\n\nexport function isSuccessCommandResult<Data, StatusCode>(\n  result: CommandResult<Data, StatusCode>,\n): result is CommandSuccessResult<Data> {\n  return result.status === CommandResultStatus.Success;\n}\n"],
+  "sourcesContent": ["import {\n  type InvalidBatteryDataError,\n  type InvalidBatteryStatusTypeError,\n  type InvalidResponseFormatError,\n  type InvalidStatusWordError,\n} from \"@api/command/Errors\";\nimport { type GlobalCommandErrorStatusCode } from \"@api/command/utils/GlobalCommandError\";\nimport {\n  type DeviceExchangeError,\n  type UnknownDeviceExchangeError,\n} from \"@api/Error\";\n\nexport enum CommandResultStatus {\n  Error = \"ERROR\",\n  Success = \"SUCCESS\",\n}\nexport type CommandSuccessResult<Data> = {\n  status: CommandResultStatus.Success;\n  data: Data;\n};\nexport type CommandErrorResult<SpecificErrorCodes = void> = {\n  error:\n    | DeviceExchangeError<SpecificErrorCodes | GlobalCommandErrorStatusCode>\n    | InvalidBatteryDataError\n    | InvalidBatteryStatusTypeError\n    | InvalidResponseFormatError\n    | InvalidStatusWordError\n    | UnknownDeviceExchangeError;\n  status: CommandResultStatus.Error;\n};\nexport type CommandResult<Data, SpecificErrorCodes = void> =\n  | CommandSuccessResult<Data>\n  | CommandErrorResult<SpecificErrorCodes>;\n\nexport function CommandResultFactory<Data, SpecificErrorCodes = void>({\n  data,\n  error,\n}:\n  | { data: Data; error?: undefined }\n  | {\n      data?: undefined;\n      error:\n        | DeviceExchangeError<SpecificErrorCodes>\n        | InvalidBatteryDataError\n        | InvalidBatteryStatusTypeError\n        | InvalidResponseFormatError\n        | InvalidStatusWordError\n        | UnknownDeviceExchangeError;\n    }): CommandResult<Data, SpecificErrorCodes> {\n  if (error) {\n    return {\n      status: CommandResultStatus.Error,\n      error,\n    };\n  }\n  return {\n    status: CommandResultStatus.Success,\n    data,\n  };\n}\n\nexport function isSuccessCommandResult<Data, StatusCode>(\n  result: CommandResult<Data, StatusCode>,\n): result is CommandSuccessResult<Data> {\n  return result.status === CommandResultStatus.Success;\n}\n"],
   "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,EAAA,wBAAAC,EAAA,2BAAAC,IAAA,eAAAC,EAAAL,GAYO,IAAKG,OACVA,EAAA,MAAQ,QACRA,EAAA,QAAU,UAFAA,OAAA,IAsBL,SAASD,EAAsD,CACpE,KAAAI,EACA,MAAAC,CACF,EAWgD,CAC9C,OAAIA,EACK,CACL,OAAQ,QACR,MAAAA,CACF,EAEK,CACL,OAAQ,UACR,KAAAD,CACF,CACF,CAEO,SAASF,EACdI,EACsC,CACtC,OAAOA,EAAO,SAAW,SAC3B",
   "names": ["CommandResult_exports", "__export", "CommandResultFactory", "CommandResultStatus", "isSuccessCommandResult", "__toCommonJS", "data", "error", "result"]
 }

package/lib/cjs/src/api/command/os/LoadCertificateCommand.js

@@ -0,0 +1,2 @@
+"use strict";var i=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var A=(r,e)=>{for(var t in e)i(r,t,{get:e[t],enumerable:!0})},E=(r,e,t,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of l(e))!y.call(r,a)&&a!==t&&i(r,a,{get:()=>e[a],enumerable:!(o=u(e,a))||o.enumerable});return r};var k=r=>E(i({},"__esModule",{value:!0}),r);var h={};A(h,{LoadCertificateCommand:()=>L,LoadCertificateCommandError:()=>C});module.exports=k(h);var d=require("../../apdu/utils/ApduBuilder"),m=require("../../apdu/utils/ApduParser"),s=require("../../command/model/CommandResult"),c=require("../../command/utils/CommandErrors"),f=require("../../command/utils/CommandUtils"),g=require("../../command/utils/GlobalCommandError"),p=require("../../Error");const n={"422f":{message:"Incorrect structure type"},4230:{message:"Incorrect certificate version"},4231:{message:"Incorrect certificate validity"},4232:{message:"Incorrect certificate validity index"},4233:{message:"Unknown signer key ID"},4234:{message:"Unknown signature algorithm"},4235:{message:"Unknown public key ID"},4236:{message:"Unknown public key usage"},4237:{message:"Incorrect elliptic curve ID"},4238:{message:"Incorrect signature algorithm associated to the public key"},4239:{message:"Unknown target device"},"422d":{message:"Unknown certificate tag"},3301:{message:"Failed to hash data"},"422e":{message:"expected_key_usage doesn't match certificate key usage"},5720:{message:"Failed to verify signature"},4118:{message:"trusted_name buffer is too small to contain the trusted name"},ffff:{message:"Cryptography-related error"}};class C extends p.DeviceExchangeError{constructor({message:e,errorCode:t}){super({tag:"ProvidePkiCertificateCommandError",message:e,errorCode:t})}}class L{args;triggersDisconnection=!1;constructor(e){this.args=e}getApdu(){const e={cla:176,ins:6,p1:this.args.keyUsage,p2:0};return new d.ApduBuilder(e).addBufferToData(this.args.certificate).build()}parseResponse(e){if(f.CommandUtils.isSuccessResponse(e))return(0,s.CommandResultFactory)({data:void 0});const o=new m.ApduParser(e).encodeToHexaString(e.statusCode);return(0,c.isCommandErrorCode)(o,n)?(0,s.CommandResultFactory)({error:new C({...n[o],errorCode:o})}):(0,s.CommandResultFactory)({error:g.GlobalCommandErrorHandler.handle(e)})}}0&&(module.exports={LoadCertificateCommand,LoadCertificateCommandError});
+//# sourceMappingURL=LoadCertificateCommand.js.map

package/lib/cjs/src/api/command/os/LoadCertificateCommand.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/LoadCertificateCommand.ts"],
+  "sourcesContent": ["import { type Apdu } from \"@api/apdu/model/Apdu\";\nimport { ApduBuilder, type ApduBuilderArgs } from \"@api/apdu/utils/ApduBuilder\";\nimport { ApduParser } from \"@api/apdu/utils/ApduParser\";\nimport {\n  type CommandResult,\n  CommandResultFactory,\n} from \"@api/command/model/CommandResult\";\nimport {\n  type CommandErrors,\n  isCommandErrorCode,\n} from \"@api/command/utils/CommandErrors\";\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { GlobalCommandErrorHandler } from \"@api/command/utils/GlobalCommandError\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { DeviceExchangeError } from \"@api/Error\";\nimport { type Command, type CommandErrorArgs } from \"@api/types\";\n\nexport type LoadCertificateArgs = {\n  readonly keyUsage: number;\n  readonly certificate: Uint8Array;\n};\n\nexport type LoadCertificateErrorCodes =\n  | \"422f\"\n  | \"4230\"\n  | \"4231\"\n  | \"4232\"\n  | \"4233\"\n  | \"4234\"\n  | \"4235\"\n  | \"4236\"\n  | \"4237\"\n  | \"4238\"\n  | \"4239\"\n  | \"422d\"\n  | \"3301\"\n  | \"422e\"\n  | \"5720\"\n  | \"4118\"\n  | \"ffff\";\n\nconst LOAD_CERTIFICATE_ERRORS: CommandErrors<LoadCertificateErrorCodes> = {\n  \"422f\": { message: \"Incorrect structure type\" },\n  \"4230\": { message: \"Incorrect certificate version\" },\n  \"4231\": { message: \"Incorrect certificate validity\" },\n  \"4232\": { message: \"Incorrect certificate validity index\" },\n  \"4233\": { message: \"Unknown signer key ID\" },\n  \"4234\": { message: \"Unknown signature algorithm\" },\n  \"4235\": { message: \"Unknown public key ID\" },\n  \"4236\": { message: \"Unknown public key usage\" },\n  \"4237\": { message: \"Incorrect elliptic curve ID\" },\n  \"4238\": {\n    message: \"Incorrect signature algorithm associated to the public key\",\n  },\n  \"4239\": { message: \"Unknown target device\" },\n  \"422d\": { message: \"Unknown certificate tag\" },\n  \"3301\": { message: \"Failed to hash data\" },\n  \"422e\": {\n    message: \"expected_key_usage doesn't match certificate key usage\",\n  },\n  \"5720\": { message: \"Failed to verify signature\" },\n  \"4118\": {\n    message: \"trusted_name buffer is too small to contain the trusted name\",\n  },\n  ffff: { message: \"Cryptography-related error\" },\n};\n\nexport class LoadCertificateCommandError extends DeviceExchangeError<LoadCertificateErrorCodes> {\n  constructor({\n    message,\n    errorCode,\n  }: CommandErrorArgs<LoadCertificateErrorCodes>) {\n    super({ tag: \"ProvidePkiCertificateCommandError\", message, errorCode });\n  }\n}\n\nexport type LoadCertificateCommandResult = CommandResult<\n  void,\n  LoadCertificateErrorCodes\n>;\n\n/**\n * The command to load a certificate on the device.\n */\nexport class LoadCertificateCommand\n  implements Command<void, LoadCertificateArgs, LoadCertificateErrorCodes>\n{\n  readonly args: LoadCertificateArgs;\n  readonly triggersDisconnection = false;\n\n  constructor(args: LoadCertificateArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const providePkiApduArgs: ApduBuilderArgs = {\n      cla: 0xb0,\n      ins: 0x06,\n      p1: this.args.keyUsage,\n      p2: 0x00,\n    };\n    return new ApduBuilder(providePkiApduArgs)\n      .addBufferToData(this.args.certificate)\n      .build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): LoadCertificateCommandResult {\n    if (CommandUtils.isSuccessResponse(apduResponse)) {\n      return CommandResultFactory({\n        data: undefined,\n      });\n    }\n    const parser = new ApduParser(apduResponse);\n    const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n    if (isCommandErrorCode(errorCode, LOAD_CERTIFICATE_ERRORS)) {\n      return CommandResultFactory({\n        error: new LoadCertificateCommandError({\n          ...LOAD_CERTIFICATE_ERRORS[errorCode],\n          errorCode,\n        }),\n      });\n    }\n    return CommandResultFactory({\n      error: GlobalCommandErrorHandler.handle(apduResponse),\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,EAAA,gCAAAC,IAAA,eAAAC,EAAAJ,GACA,IAAAK,EAAkD,uCAClDC,EAA2B,sCAC3BC,EAGO,4CACPC,EAGO,4CACPC,EAA6B,2CAC7BC,EAA0C,iDAE1CC,EAAoC,sBA2BpC,MAAMC,EAAoE,CACxE,OAAQ,CAAE,QAAS,0BAA2B,EAC9C,KAAQ,CAAE,QAAS,+BAAgC,EACnD,KAAQ,CAAE,QAAS,gCAAiC,EACpD,KAAQ,CAAE,QAAS,sCAAuC,EAC1D,KAAQ,CAAE,QAAS,uBAAwB,EAC3C,KAAQ,CAAE,QAAS,6BAA8B,EACjD,KAAQ,CAAE,QAAS,uBAAwB,EAC3C,KAAQ,CAAE,QAAS,0BAA2B,EAC9C,KAAQ,CAAE,QAAS,6BAA8B,EACjD,KAAQ,CACN,QAAS,4DACX,EACA,KAAQ,CAAE,QAAS,uBAAwB,EAC3C,OAAQ,CAAE,QAAS,yBAA0B,EAC7C,KAAQ,CAAE,QAAS,qBAAsB,EACzC,OAAQ,CACN,QAAS,wDACX,EACA,KAAQ,CAAE,QAAS,4BAA6B,EAChD,KAAQ,CACN,QAAS,8DACX,EACA,KAAM,CAAE,QAAS,4BAA6B,CAChD,EAEO,MAAMT,UAAoC,qBAA+C,CAC9F,YAAY,CACV,QAAAU,EACA,UAAAC,CACF,EAAgD,CAC9C,MAAM,CAAE,IAAK,oCAAqC,QAAAD,EAAS,UAAAC,CAAU,CAAC,CACxE,CACF,CAUO,MAAMZ,CAEb,CACW,KACA,sBAAwB,GAEjC,YAAYa,EAA2B,CACrC,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,MAAMC,EAAsC,CAC1C,IAAK,IACL,IAAK,EACL,GAAI,KAAK,KAAK,SACd,GAAI,CACN,EACA,OAAO,IAAI,cAAYA,CAAkB,EACtC,gBAAgB,KAAK,KAAK,WAAW,EACrC,MAAM,CACX,CAEA,cAAcC,EAA0D,CACtE,GAAI,eAAa,kBAAkBA,CAAY,EAC7C,SAAO,wBAAqB,CAC1B,KAAM,MACR,CAAC,EAGH,MAAMH,EADS,IAAI,aAAWG,CAAY,EACjB,mBAAmBA,EAAa,UAAU,EACnE,SAAI,sBAAmBH,EAAWF,CAAuB,KAChD,wBAAqB,CAC1B,MAAO,IAAIT,EAA4B,CACrC,GAAGS,EAAwBE,CAAS,EACpC,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOG,CAAY,CACtD,CAAC,CACH,CACF",
+  "names": ["LoadCertificateCommand_exports", "__export", "LoadCertificateCommand", "LoadCertificateCommandError", "__toCommonJS", "import_ApduBuilder", "import_ApduParser", "import_CommandResult", "import_CommandErrors", "import_CommandUtils", "import_GlobalCommandError", "import_Error", "LOAD_CERTIFICATE_ERRORS", "message", "errorCode", "args", "providePkiApduArgs", "apduResponse"]
+}

package/lib/cjs/src/api/command/os/LoadCertificateCommand.test.js

@@ -0,0 +1,2 @@
+"use strict";var s=require("../../command/model/CommandResult"),o=require("../../command/os/LoadCertificateCommand"),n=require("../../command/utils/GlobalCommandError"),c=require("../../utils/HexaString");describe("LoadCertificateCommand",()=>{describe("getApdu",()=>{it("should return the APDU with key equal to 1",()=>{const r={keyUsage:66,certificate:new Uint8Array([1,2,3])},e=new o.LoadCertificateCommand(r).getApdu();expect(e.cla).toBe(176),expect(e.ins).toBe(6),expect(e.p1).toBe(66),expect(e.p2).toBe(0),expect(e.data).toStrictEqual(new Uint8Array([1,2,3]))})}),describe("parseResponse",()=>{let r;beforeEach(()=>{r=new o.LoadCertificateCommand({keyUsage:1,certificate:new Uint8Array})}),it("should return success if the response status code is success",()=>{const t={statusCode:new Uint8Array([144,0]),data:new Uint8Array},e=r.parseResponse(t);expect(e).toStrictEqual((0,s.CommandResultFactory)({data:void 0}))}),describe("errors",()=>{it("should return error command result if the device is locked",()=>{const t={statusCode:new Uint8Array([85,21]),data:new Uint8Array},e=r.parseResponse(t);(0,s.isSuccessCommandResult)(e)?assert.fail("Expected error command result"):expect(e.error).toBeInstanceOf(n.GlobalCommandError)}),it.each(["422f","4230","4231","4232","4233","4234","4235","4236","4237","4238","4239","422d","3301","422e","5720","4118","ffff"])("should return a ProvidePkiCertificateCommandError if the response is a %s specific error code",t=>{const e={statusCode:(0,c.hexaStringToBuffer)(t),data:new Uint8Array},a=r.parseResponse(e);(0,s.isSuccessCommandResult)(a)?assert.fail("Expected error command result"):(expect(a.error).toBeInstanceOf(o.LoadCertificateCommandError),expect(a.error.errorCode).toBe(t))})})})});
+//# sourceMappingURL=LoadCertificateCommand.test.js.map

package/lib/cjs/src/api/command/os/LoadCertificateCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/LoadCertificateCommand.test.ts"],
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@api/command/model/CommandResult\";\nimport {\n  LoadCertificateCommand,\n  LoadCertificateCommandError,\n} from \"@api/command/os/LoadCertificateCommand\";\nimport { GlobalCommandError } from \"@api/command/utils/GlobalCommandError\";\nimport { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\ndescribe(\"LoadCertificateCommand\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should return the APDU with key equal to 1\", () => {\n      // GIVEN\n      const args = {\n        keyUsage: 0x42,\n        certificate: new Uint8Array([0x01, 0x02, 0x03]),\n      };\n      const command = new LoadCertificateCommand(args);\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.cla).toBe(0xb0);\n      expect(apdu.ins).toBe(0x06);\n      expect(apdu.p1).toBe(0x42);\n      expect(apdu.p2).toBe(0x00);\n      expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    let command: LoadCertificateCommand;\n\n    beforeEach(() => {\n      command = new LoadCertificateCommand({\n        keyUsage: 0x01,\n        certificate: new Uint8Array(),\n      });\n    });\n\n    it(\"should return success if the response status code is success\", () => {\n      // GIVEN\n      const response = {\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: new Uint8Array(),\n      };\n\n      // WHEN\n      const result = command.parseResponse(response);\n\n      // THEN\n      expect(result).toStrictEqual(CommandResultFactory({ data: undefined }));\n    });\n\n    describe(\"errors\", () => {\n      it(\"should return error command result if the device is locked\", () => {\n        // GIVEN\n        const response = {\n          statusCode: new Uint8Array([0x55, 0x15]),\n          data: new Uint8Array(),\n        };\n\n        // WHEN\n        const result = command.parseResponse(response);\n\n        // THEN\n        if (isSuccessCommandResult(result)) {\n          assert.fail(\"Expected error command result\");\n        } else {\n          expect(result.error).toBeInstanceOf(GlobalCommandError);\n        }\n      });\n\n      it.each([\n        \"422f\",\n        \"4230\",\n        \"4231\",\n        \"4232\",\n        \"4233\",\n        \"4234\",\n        \"4235\",\n        \"4236\",\n        \"4237\",\n        \"4238\",\n        \"4239\",\n        \"422d\",\n        \"3301\",\n        \"422e\",\n        \"5720\",\n        \"4118\",\n        \"ffff\",\n      ])(\n        \"should return a ProvidePkiCertificateCommandError if the response is a %s specific error code\",\n        (errorCode) => {\n          // GIVEN\n          const response = {\n            statusCode: hexaStringToBuffer(errorCode)!,\n            data: new Uint8Array(),\n          };\n\n          // WHEN\n          const result = command.parseResponse(response);\n\n          // THEN\n          if (isSuccessCommandResult(result)) {\n            assert.fail(\"Expected error command result\");\n          } else {\n            expect(result.error).toBeInstanceOf(LoadCertificateCommandError);\n            // @ts-expect-error intended\n            expect(result.error.errorCode).toBe(errorCode);\n          }\n        },\n      );\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAGO,4CACPC,EAGO,kDACPC,EAAmC,iDACnCC,EAAmC,iCAEnC,SAAS,yBAA0B,IAAM,CACvC,SAAS,UAAW,IAAM,CACxB,GAAG,6CAA8C,IAAM,CAErD,MAAMC,EAAO,CACX,SAAU,GACV,YAAa,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,CAChD,EAIMC,EAHU,IAAI,yBAAuBD,CAAI,EAG1B,QAAQ,EAG7B,OAAOC,EAAK,GAAG,EAAE,KAAK,GAAI,EAC1B,OAAOA,EAAK,GAAG,EAAE,KAAK,CAAI,EAC1B,OAAOA,EAAK,EAAE,EAAE,KAAK,EAAI,EACzB,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,EACzB,OAAOA,EAAK,IAAI,EAAE,cAAc,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,CAAC,CACpE,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAU,IAAI,yBAAuB,CACnC,SAAU,EACV,YAAa,IAAI,UACnB,CAAC,CACH,CAAC,EAED,GAAG,+DAAgE,IAAM,CAEvE,MAAMC,EAAW,CACf,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,EACvC,KAAM,IAAI,UACZ,EAGMC,EAASF,EAAQ,cAAcC,CAAQ,EAG7C,OAAOC,CAAM,EAAE,iBAAc,wBAAqB,CAAE,KAAM,MAAU,CAAC,CAAC,CACxE,CAAC,EAED,SAAS,SAAU,IAAM,CACvB,GAAG,6DAA8D,IAAM,CAErE,MAAMD,EAAW,CACf,WAAY,IAAI,WAAW,CAAC,GAAM,EAAI,CAAC,EACvC,KAAM,IAAI,UACZ,EAGMC,EAASF,EAAQ,cAAcC,CAAQ,KAGzC,0BAAuBC,CAAM,EAC/B,OAAO,KAAK,+BAA+B,EAE3C,OAAOA,EAAO,KAAK,EAAE,eAAe,oBAAkB,CAE1D,CAAC,EAED,GAAG,KAAK,CACN,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,MACF,CAAC,EACC,gGACCC,GAAc,CAEb,MAAMF,EAAW,CACf,cAAY,sBAAmBE,CAAS,EACxC,KAAM,IAAI,UACZ,EAGMD,EAASF,EAAQ,cAAcC,CAAQ,KAGzC,0BAAuBC,CAAM,EAC/B,OAAO,KAAK,+BAA+B,GAE3C,OAAOA,EAAO,KAAK,EAAE,eAAe,6BAA2B,EAE/D,OAAOA,EAAO,MAAM,SAAS,EAAE,KAAKC,CAAS,EAEjD,CACF,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["import_CommandResult", "import_LoadCertificateCommand", "import_GlobalCommandError", "import_HexaString", "args", "apdu", "command", "response", "result", "errorCode"]
+}

package/lib/cjs/src/api/command/use-case/SendCommandUseCase.test.js

@@ -1,2 +1,2 @@
-"use strict";var d=require("purify-ts"),r=require("../../command/model/CommandResult"),u=require("../../../internal/device-session/model/DeviceSession.stub"),p=require("../../../internal/device-session/service/DefaultDeviceSessionService"),S=require("../../../internal/logger-publisher/service/DefaultLoggerPublisherService"),f=require("../../../internal/manager-api/data/AxiosManagerApiDataSource"),l=require("../../../internal/manager-api/service/DefaultManagerApiService"),a=require("./SendCommandUseCase");let s,o,n,c;const m="fakeSessionId";let i;describe("SendCommandUseCase",()=>{beforeEach(()=>{s=new S.DefaultLoggerPublisherService([],"send-command-use-case"),o=new p.DefaultDeviceSessionService(()=>s),c=new f.AxiosManagerApiDataSource({managerApiUrl:"http://fake.url",mockUrl:"http://fake-mock.url"}),n=new l.DefaultManagerApiService(c),i={getApdu:jest.fn(),parseResponse:jest.fn()}}),afterEach(()=>{jest.restoreAllMocks()}),it("should send a command to a connected device",async()=>{const e=(0,u.deviceSessionStubBuilder)({},()=>s,n);o.addDeviceSession(e);const t=new a.SendCommandUseCase(o,()=>s);jest.spyOn(e,"sendCommand").mockResolvedValue({status:r.CommandResultStatus.Success,data:void 0});const v=await t.execute({sessionId:m,command:i});e.close(),expect(v).toStrictEqual({status:r.CommandResultStatus.Success,data:void 0})}),it("should throw an error if the session is not found",async()=>{const e=new a.SendCommandUseCase(o,()=>s);jest.spyOn(o,"getDeviceSessionById").mockReturnValue((0,d.Left)({_tag:"DeviceSessionNotFound"}));const t=e.execute({sessionId:m,command:i});await expect(t).rejects.toMatchObject({_tag:"DeviceSessionNotFound"})})});
+"use strict";var d=require("purify-ts"),i=require("../../command/model/CommandResult"),p=require("../../../internal/device-session/model/DeviceSession.stub"),f=require("../../../internal/device-session/service/DefaultDeviceSessionService"),l=require("../../../internal/logger-publisher/service/DefaultLoggerPublisherService"),v=require("../../../internal/manager-api/data/AxiosManagerApiDataSource"),g=require("../../../internal/manager-api/service/DefaultManagerApiService"),D=require("../../../internal/secure-channel/data/DefaultSecureChannelDataSource"),C=require("../../../internal/secure-channel/service/DefaultSecureChannelService"),a=require("./SendCommandUseCase");let o,t,n,c,m,u;const S="fakeSessionId";let s;describe("SendCommandUseCase",()=>{beforeEach(()=>{o=new l.DefaultLoggerPublisherService([],"send-command-use-case"),t=new f.DefaultDeviceSessionService(()=>o),c=new v.AxiosManagerApiDataSource({}),n=new g.DefaultManagerApiService(c),u=new D.DefaultSecureChannelDataSource({}),m=new C.DefaultSecureChannelService(u),s={getApdu:vi.fn(),parseResponse:vi.fn()}}),afterEach(()=>{vi.restoreAllMocks()}),it("should send a command to a connected device",async()=>{const e=(0,p.deviceSessionStubBuilder)({},()=>o,n,m);t.addDeviceSession(e);const r=new a.SendCommandUseCase(t,()=>o);vi.spyOn(e,"sendCommand").mockResolvedValue({status:i.CommandResultStatus.Success,data:void 0});const h=await r.execute({sessionId:S,command:s});e.close(),expect(h).toStrictEqual({status:i.CommandResultStatus.Success,data:void 0})}),it("should throw an error if the session is not found",async()=>{const e=new a.SendCommandUseCase(t,()=>o);vi.spyOn(t,"getDeviceSessionById").mockReturnValue((0,d.Left)({_tag:"DeviceSessionNotFound"}));const r=e.execute({sessionId:S,command:s});await expect(r).rejects.toMatchObject({_tag:"DeviceSessionNotFound"})})});
 //# sourceMappingURL=SendCommandUseCase.test.js.map

package/lib/cjs/src/api/command/use-case/SendCommandUseCase.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/use-case/SendCommandUseCase.test.ts"],
-  "sourcesContent": ["import { Left } from \"purify-ts\";\n\nimport { type Command } from \"@api/command/Command\";\nimport { CommandResultStatus } from \"@api/command/model/CommandResult\";\nimport { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { deviceSessionStubBuilder } from \"@internal/device-session/model/DeviceSession.stub\";\nimport { DefaultDeviceSessionService } from \"@internal/device-session/service/DefaultDeviceSessionService\";\nimport { type DeviceSessionService } from \"@internal/device-session/service/DeviceSessionService\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/DefaultLoggerPublisherService\";\nimport { AxiosManagerApiDataSource } from \"@internal/manager-api/data/AxiosManagerApiDataSource\";\nimport { type ManagerApiDataSource } from \"@internal/manager-api/data/ManagerApiDataSource\";\nimport { DefaultManagerApiService } from \"@internal/manager-api/service/DefaultManagerApiService\";\nimport { type ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\n\nimport { SendCommandUseCase } from \"./SendCommandUseCase\";\n\nlet logger: LoggerPublisherService;\nlet sessionService: DeviceSessionService;\nlet managerApi: ManagerApiService;\nlet managerApiDataSource: ManagerApiDataSource;\nconst fakeSessionId = \"fakeSessionId\";\nlet command: Command<{ status: string }>;\n\ndescribe(\"SendCommandUseCase\", () => {\n  beforeEach(() => {\n    logger = new DefaultLoggerPublisherService([], \"send-command-use-case\");\n    sessionService = new DefaultDeviceSessionService(() => logger);\n    managerApiDataSource = new AxiosManagerApiDataSource({\n      managerApiUrl: \"http://fake.url\",\n      mockUrl: \"http://fake-mock.url\",\n    });\n    managerApi = new DefaultManagerApiService(managerApiDataSource);\n    command = {\n      getApdu: jest.fn(),\n      parseResponse: jest.fn(),\n    };\n  });\n\n  afterEach(() => {\n    jest.restoreAllMocks();\n  });\n\n  it(\"should send a command to a connected device\", async () => {\n    const deviceSession = deviceSessionStubBuilder(\n      {},\n      () => logger,\n      managerApi,\n    );\n    sessionService.addDeviceSession(deviceSession);\n    const useCase = new SendCommandUseCase(sessionService, () => logger);\n\n    jest.spyOn(deviceSession, \"sendCommand\").mockResolvedValue({\n      status: CommandResultStatus.Success,\n      data: undefined,\n    });\n\n    const response = await useCase.execute<{ status: string }, void, void>({\n      sessionId: fakeSessionId,\n      command,\n    });\n\n    deviceSession.close();\n\n    expect(response).toStrictEqual({\n      status: CommandResultStatus.Success,\n      data: undefined,\n    });\n  });\n\n  it(\"should throw an error if the session is not found\", async () => {\n    const useCase = new SendCommandUseCase(sessionService, () => logger);\n    jest\n      .spyOn(sessionService, \"getDeviceSessionById\")\n      .mockReturnValue(Left({ _tag: \"DeviceSessionNotFound\" }));\n\n    const res = useCase.execute<{ status: string }, void, void>({\n      sessionId: fakeSessionId,\n      command,\n    });\n\n    await expect(res).rejects.toMatchObject({ _tag: \"DeviceSessionNotFound\" });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAAqB,qBAGrBC,EAAoC,4CAEpCC,EAAyC,6DACzCC,EAA4C,wEAE5CC,EAA8C,4EAC9CC,EAA0C,gEAE1CC,EAAyC,kEAGzCC,EAAmC,gCAEnC,IAAIC,EACAC,EACAC,EACAC,EACJ,MAAMC,EAAgB,gBACtB,IAAIC,EAEJ,SAAS,qBAAsB,IAAM,CACnC,WAAW,IAAM,CACfL,EAAS,IAAI,gCAA8B,CAAC,EAAG,uBAAuB,EACtEC,EAAiB,IAAI,8BAA4B,IAAMD,CAAM,EAC7DG,EAAuB,IAAI,4BAA0B,CACnD,cAAe,kBACf,QAAS,sBACX,CAAC,EACDD,EAAa,IAAI,2BAAyBC,CAAoB,EAC9DE,EAAU,CACR,QAAS,KAAK,GAAG,EACjB,cAAe,KAAK,GAAG,CACzB,CACF,CAAC,EAED,UAAU,IAAM,CACd,KAAK,gBAAgB,CACvB,CAAC,EAED,GAAG,8CAA+C,SAAY,CAC5D,MAAMC,KAAgB,4BACpB,CAAC,EACD,IAAMN,EACNE,CACF,EACAD,EAAe,iBAAiBK,CAAa,EAC7C,MAAMC,EAAU,IAAI,qBAAmBN,EAAgB,IAAMD,CAAM,EAEnE,KAAK,MAAMM,EAAe,aAAa,EAAE,kBAAkB,CACzD,OAAQ,sBAAoB,QAC5B,KAAM,MACR,CAAC,EAED,MAAME,EAAW,MAAMD,EAAQ,QAAwC,CACrE,UAAWH,EACX,QAAAC,CACF,CAAC,EAEDC,EAAc,MAAM,EAEpB,OAAOE,CAAQ,EAAE,cAAc,CAC7B,OAAQ,sBAAoB,QAC5B,KAAM,MACR,CAAC,CACH,CAAC,EAED,GAAG,oDAAqD,SAAY,CAClE,MAAMD,EAAU,IAAI,qBAAmBN,EAAgB,IAAMD,CAAM,EACnE,KACG,MAAMC,EAAgB,sBAAsB,EAC5C,mBAAgB,QAAK,CAAE,KAAM,uBAAwB,CAAC,CAAC,EAE1D,MAAMQ,EAAMF,EAAQ,QAAwC,CAC1D,UAAWH,EACX,QAAAC,CACF,CAAC,EAED,MAAM,OAAOI,CAAG,EAAE,QAAQ,cAAc,CAAE,KAAM,uBAAwB,CAAC,CAC3E,CAAC,CACH,CAAC",
-  "names": ["import_purify_ts", "import_CommandResult", "import_DeviceSession", "import_DefaultDeviceSessionService", "import_DefaultLoggerPublisherService", "import_AxiosManagerApiDataSource", "import_DefaultManagerApiService", "import_SendCommandUseCase", "logger", "sessionService", "managerApi", "managerApiDataSource", "fakeSessionId", "command", "deviceSession", "useCase", "response", "res"]
+  "sourcesContent": ["import { Left } from \"purify-ts\";\n\nimport { type Command } from \"@api/command/Command\";\nimport { CommandResultStatus } from \"@api/command/model/CommandResult\";\nimport { type DmkConfig } from \"@api/DmkConfig\";\nimport { type LoggerPublisherService } from \"@api/logger-publisher/service/LoggerPublisherService\";\nimport { deviceSessionStubBuilder } from \"@internal/device-session/model/DeviceSession.stub\";\nimport { DefaultDeviceSessionService } from \"@internal/device-session/service/DefaultDeviceSessionService\";\nimport { type DeviceSessionService } from \"@internal/device-session/service/DeviceSessionService\";\nimport { DefaultLoggerPublisherService } from \"@internal/logger-publisher/service/DefaultLoggerPublisherService\";\nimport { AxiosManagerApiDataSource } from \"@internal/manager-api/data/AxiosManagerApiDataSource\";\nimport { type ManagerApiDataSource } from \"@internal/manager-api/data/ManagerApiDataSource\";\nimport { DefaultManagerApiService } from \"@internal/manager-api/service/DefaultManagerApiService\";\nimport { type ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\nimport { DefaultSecureChannelDataSource } from \"@internal/secure-channel/data/DefaultSecureChannelDataSource\";\nimport { type SecureChannelDataSource } from \"@internal/secure-channel/data/SecureChannelDataSource\";\nimport { DefaultSecureChannelService } from \"@internal/secure-channel/service/DefaultSecureChannelService\";\nimport { type SecureChannelService } from \"@internal/secure-channel/service/SecureChannelService\";\n\nimport { SendCommandUseCase } from \"./SendCommandUseCase\";\n\nlet logger: LoggerPublisherService;\nlet sessionService: DeviceSessionService;\nlet managerApi: ManagerApiService;\nlet managerApiDataSource: ManagerApiDataSource;\nlet secureChannel: SecureChannelService;\nlet secureChannelDataSource: SecureChannelDataSource;\nconst fakeSessionId = \"fakeSessionId\";\nlet command: Command<{ status: string }>;\n\ndescribe(\"SendCommandUseCase\", () => {\n  beforeEach(() => {\n    logger = new DefaultLoggerPublisherService([], \"send-command-use-case\");\n    sessionService = new DefaultDeviceSessionService(() => logger);\n    managerApiDataSource = new AxiosManagerApiDataSource({} as DmkConfig);\n    managerApi = new DefaultManagerApiService(managerApiDataSource);\n    secureChannelDataSource = new DefaultSecureChannelDataSource(\n      {} as DmkConfig,\n    );\n    secureChannel = new DefaultSecureChannelService(secureChannelDataSource);\n    command = {\n      getApdu: vi.fn(),\n      parseResponse: vi.fn(),\n    };\n  });\n\n  afterEach(() => {\n    vi.restoreAllMocks();\n  });\n\n  it(\"should send a command to a connected device\", async () => {\n    const deviceSession = deviceSessionStubBuilder(\n      {},\n      () => logger,\n      managerApi,\n      secureChannel,\n    );\n    sessionService.addDeviceSession(deviceSession);\n    const useCase = new SendCommandUseCase(sessionService, () => logger);\n\n    vi.spyOn(deviceSession, \"sendCommand\").mockResolvedValue({\n      status: CommandResultStatus.Success,\n      data: undefined,\n    });\n\n    const response = await useCase.execute<{ status: string }, void, void>({\n      sessionId: fakeSessionId,\n      command,\n    });\n\n    deviceSession.close();\n\n    expect(response).toStrictEqual({\n      status: CommandResultStatus.Success,\n      data: undefined,\n    });\n  });\n\n  it(\"should throw an error if the session is not found\", async () => {\n    const useCase = new SendCommandUseCase(sessionService, () => logger);\n    vi.spyOn(sessionService, \"getDeviceSessionById\").mockReturnValue(\n      Left({ _tag: \"DeviceSessionNotFound\" }),\n    );\n\n    const res = useCase.execute<{ status: string }, void, void>({\n      sessionId: fakeSessionId,\n      command,\n    });\n\n    await expect(res).rejects.toMatchObject({ _tag: \"DeviceSessionNotFound\" });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAAqB,qBAGrBC,EAAoC,4CAGpCC,EAAyC,6DACzCC,EAA4C,wEAE5CC,EAA8C,4EAC9CC,EAA0C,gEAE1CC,EAAyC,kEAEzCC,EAA+C,wEAE/CC,EAA4C,wEAG5CC,EAAmC,gCAEnC,IAAIC,EACAC,EACAC,EACAC,EACAC,EACAC,EACJ,MAAMC,EAAgB,gBACtB,IAAIC,EAEJ,SAAS,qBAAsB,IAAM,CACnC,WAAW,IAAM,CACfP,EAAS,IAAI,gCAA8B,CAAC,EAAG,uBAAuB,EACtEC,EAAiB,IAAI,8BAA4B,IAAMD,CAAM,EAC7DG,EAAuB,IAAI,4BAA0B,CAAC,CAAc,EACpED,EAAa,IAAI,2BAAyBC,CAAoB,EAC9DE,EAA0B,IAAI,iCAC5B,CAAC,CACH,EACAD,EAAgB,IAAI,8BAA4BC,CAAuB,EACvEE,EAAU,CACR,QAAS,GAAG,GAAG,EACf,cAAe,GAAG,GAAG,CACvB,CACF,CAAC,EAED,UAAU,IAAM,CACd,GAAG,gBAAgB,CACrB,CAAC,EAED,GAAG,8CAA+C,SAAY,CAC5D,MAAMC,KAAgB,4BACpB,CAAC,EACD,IAAMR,EACNE,EACAE,CACF,EACAH,EAAe,iBAAiBO,CAAa,EAC7C,MAAMC,EAAU,IAAI,qBAAmBR,EAAgB,IAAMD,CAAM,EAEnE,GAAG,MAAMQ,EAAe,aAAa,EAAE,kBAAkB,CACvD,OAAQ,sBAAoB,QAC5B,KAAM,MACR,CAAC,EAED,MAAME,EAAW,MAAMD,EAAQ,QAAwC,CACrE,UAAWH,EACX,QAAAC,CACF,CAAC,EAEDC,EAAc,MAAM,EAEpB,OAAOE,CAAQ,EAAE,cAAc,CAC7B,OAAQ,sBAAoB,QAC5B,KAAM,MACR,CAAC,CACH,CAAC,EAED,GAAG,oDAAqD,SAAY,CAClE,MAAMD,EAAU,IAAI,qBAAmBR,EAAgB,IAAMD,CAAM,EACnE,GAAG,MAAMC,EAAgB,sBAAsB,EAAE,mBAC/C,QAAK,CAAE,KAAM,uBAAwB,CAAC,CACxC,EAEA,MAAMU,EAAMF,EAAQ,QAAwC,CAC1D,UAAWH,EACX,QAAAC,CACF,CAAC,EAED,MAAM,OAAOI,CAAG,EAAE,QAAQ,cAAc,CAAE,KAAM,uBAAwB,CAAC,CAC3E,CAAC,CACH,CAAC",
+  "names": ["import_purify_ts", "import_CommandResult", "import_DeviceSession", "import_DefaultDeviceSessionService", "import_DefaultLoggerPublisherService", "import_AxiosManagerApiDataSource", "import_DefaultManagerApiService", "import_DefaultSecureChannelDataSource", "import_DefaultSecureChannelService", "import_SendCommandUseCase", "logger", "sessionService", "managerApi", "managerApiDataSource", "secureChannel", "secureChannelDataSource", "fakeSessionId", "command", "deviceSession", "useCase", "response", "res"]
 }

package/lib/cjs/src/api/command/utils/CommandUtils.js

@@ -1,2 +1,2 @@
-"use strict";var r=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var o=Object.prototype.hasOwnProperty;var c=(s,e)=>{for(var t in e)r(s,t,{get:e[t],enumerable:!0})},l=(s,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of a(e))!o.call(s,i)&&i!==t&&r(s,i,{get:()=>e[i],enumerable:!(n=p(e,i))||n.enumerable});return s};var u=s=>l(r({},"__esModule",{value:!0}),s);var f={};c(f,{CommandUtils:()=>d});module.exports=u(f);class d{static isValidStatusCode(e){return e.length===2}static isSuccessResponse({statusCode:e}){return this.isValidStatusCode(e)?e[0]===144&&e[1]===0:!1}static isLockedDeviceResponse({statusCode:e}){return this.isValidStatusCode(e)?e[0]===85&&e[1]===21:!1}}0&&(module.exports={CommandUtils});
+"use strict";var a=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var c=(t,e)=>{for(var s in e)a(t,s,{get:e[s],enumerable:!0})},x=(t,e,s,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of o(e))!u.call(t,r)&&r!==s&&a(t,r,{get:()=>e[r],enumerable:!(i=p(e,r))||i.enumerable});return t};var A=t=>x(a({},"__esModule",{value:!0}),t);var l={};c(l,{CommandUtils:()=>n});module.exports=A(l);class n{static isValidStatusCode(e){return e.length===2}static isSuccessResponse({statusCode:e}){return n.isValidStatusCode(e)?e[0]===144&&e[1]===0:!1}static isLockedDeviceResponse({statusCode:e}){return n.isValidStatusCode(e)?e[0]===85&&e[1]===21:!1}static isApduThatTriggersDisconnection(e){const s=new Map;return s.set("openApp",new Uint8Array([224,216,0,0])),s.set("closeApp",new Uint8Array([176,167,0,0])),Array.from(s.values()).some(i=>{for(let r=0;r<4;r++)if(i[r]!==e[r])return!1;return!0})}}0&&(module.exports={CommandUtils});
 //# sourceMappingURL=CommandUtils.js.map

package/lib/cjs/src/api/command/utils/CommandUtils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/utils/CommandUtils.ts"],
-  "sourcesContent": ["import { type ApduResponse } from \"@api/device-session/ApduResponse\";\n\nexport class CommandUtils {\n  static isValidStatusCode(statusCode: Uint8Array) {\n    return statusCode.length === 2;\n  }\n\n  static isSuccessResponse({ statusCode }: ApduResponse) {\n    if (!this.isValidStatusCode(statusCode)) {\n      return false;\n    }\n\n    return statusCode[0] === 0x90 && statusCode[1] === 0x00;\n  }\n\n  static isLockedDeviceResponse({ statusCode }: ApduResponse) {\n    if (!this.isValidStatusCode(statusCode)) {\n      return false;\n    }\n\n    return statusCode[0] === 0x55 && statusCode[1] === 0x15;\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAEO,MAAME,CAAa,CACxB,OAAO,kBAAkBE,EAAwB,CAC/C,OAAOA,EAAW,SAAW,CAC/B,CAEA,OAAO,kBAAkB,CAAE,WAAAA,CAAW,EAAiB,CACrD,OAAK,KAAK,kBAAkBA,CAAU,EAI/BA,EAAW,CAAC,IAAM,KAAQA,EAAW,CAAC,IAAM,EAH1C,EAIX,CAEA,OAAO,uBAAuB,CAAE,WAAAA,CAAW,EAAiB,CAC1D,OAAK,KAAK,kBAAkBA,CAAU,EAI/BA,EAAW,CAAC,IAAM,IAAQA,EAAW,CAAC,IAAM,GAH1C,EAIX,CACF",
-  "names": ["CommandUtils_exports", "__export", "CommandUtils", "__toCommonJS", "statusCode"]
+  "sourcesContent": ["import { type ApduResponse } from \"@api/device-session/ApduResponse\";\n\nexport class CommandUtils {\n  static isValidStatusCode(statusCode: Uint8Array) {\n    return statusCode.length === 2;\n  }\n\n  static isSuccessResponse({ statusCode }: ApduResponse) {\n    if (!CommandUtils.isValidStatusCode(statusCode)) {\n      return false;\n    }\n\n    return statusCode[0] === 0x90 && statusCode[1] === 0x00;\n  }\n\n  static isLockedDeviceResponse({ statusCode }: ApduResponse) {\n    if (!CommandUtils.isValidStatusCode(statusCode)) {\n      return false;\n    }\n\n    return statusCode[0] === 0x55 && statusCode[1] === 0x15;\n  }\n\n  static isApduThatTriggersDisconnection(apdu: Uint8Array) {\n    /**\n     * Map of known APDUs that trigger a disconnection.\n     */\n    const apduMap = new Map();\n    apduMap.set(\"openApp\", new Uint8Array([0xe0, 0xd8, 0x00, 0x00]));\n    apduMap.set(\"closeApp\", new Uint8Array([0xb0, 0xa7, 0x00, 0x00]));\n    // TODO: add more APDUs that trigger a disconnection (e.g firmware flashing ?)\n\n    // check if apdu first 4 UintArray is included in apduMap\n    return Array.from(apduMap.values()).some((value: Uint8Array) => {\n      for (let i = 0; i < 4; i++) {\n        if (value[i] !== apdu[i]) {\n          return false;\n        }\n      }\n      return true;\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAEO,MAAME,CAAa,CACxB,OAAO,kBAAkBE,EAAwB,CAC/C,OAAOA,EAAW,SAAW,CAC/B,CAEA,OAAO,kBAAkB,CAAE,WAAAA,CAAW,EAAiB,CACrD,OAAKF,EAAa,kBAAkBE,CAAU,EAIvCA,EAAW,CAAC,IAAM,KAAQA,EAAW,CAAC,IAAM,EAH1C,EAIX,CAEA,OAAO,uBAAuB,CAAE,WAAAA,CAAW,EAAiB,CAC1D,OAAKF,EAAa,kBAAkBE,CAAU,EAIvCA,EAAW,CAAC,IAAM,IAAQA,EAAW,CAAC,IAAM,GAH1C,EAIX,CAEA,OAAO,gCAAgCC,EAAkB,CAIvD,MAAMC,EAAU,IAAI,IACpB,OAAAA,EAAQ,IAAI,UAAW,IAAI,WAAW,CAAC,IAAM,IAAM,EAAM,CAAI,CAAC,CAAC,EAC/DA,EAAQ,IAAI,WAAY,IAAI,WAAW,CAAC,IAAM,IAAM,EAAM,CAAI,CAAC,CAAC,EAIzD,MAAM,KAAKA,EAAQ,OAAO,CAAC,EAAE,KAAMC,GAAsB,CAC9D,QAASC,EAAI,EAAGA,EAAI,EAAGA,IACrB,GAAID,EAAMC,CAAC,IAAMH,EAAKG,CAAC,EACrB,MAAO,GAGX,MAAO,EACT,CAAC,CACH,CACF",
+  "names": ["CommandUtils_exports", "__export", "CommandUtils", "__toCommonJS", "statusCode", "apdu", "apduMap", "value", "i"]
 }

package/lib/cjs/src/api/command/utils/CommandUtils.test.js

@@ -1,2 +1,2 @@
-"use strict";var t=require("../../device-session/ApduResponse"),s=require("./CommandUtils");describe("CommandUtils",()=>{describe("static isSuccessResponse",()=>{it("should return true if the status code is 0x9000",()=>{const e=new t.ApduResponse({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])});expect(s.CommandUtils.isSuccessResponse(e)).toBe(!0)}),it("should return false if the status code is not 0x9000",()=>{const e=new t.ApduResponse({statusCode:Uint8Array.from([110,128]),data:Uint8Array.from([])});expect(s.CommandUtils.isSuccessResponse(e)).toBe(!1)}),it("should return false if the status code is not 2 bytes long",()=>{const e=new t.ApduResponse({statusCode:Uint8Array.from([85]),data:Uint8Array.from([])});expect(s.CommandUtils.isSuccessResponse(e)).toBe(!1)})}),describe("static isValidStatusCode",()=>{it("should return true if the status code is 2 bytes long",()=>{const e=Uint8Array.from([144,0]);expect(s.CommandUtils.isValidStatusCode(e)).toBe(!0)}),it("should return false if the status code is not 2 bytes long",()=>{const e=Uint8Array.from([144]);expect(s.CommandUtils.isValidStatusCode(e)).toBe(!1)})}),describe("static isLockedDeviceResponse",()=>{it("should return true if the status code is 0x5515",()=>{const e=new t.ApduResponse({statusCode:Uint8Array.from([85,21]),data:Uint8Array.from([])});expect(s.CommandUtils.isLockedDeviceResponse(e)).toBe(!0)}),it("should return false if the status code is not 0x5515",()=>{const e=new t.ApduResponse({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])});expect(s.CommandUtils.isLockedDeviceResponse(e)).toBe(!1)}),it("should return false if the status code is not 2 bytes long",()=>{const e=new t.ApduResponse({statusCode:Uint8Array.from([144]),data:Uint8Array.from([])});expect(s.CommandUtils.isLockedDeviceResponse(e)).toBe(!1)})})});
+"use strict";var o=require("../../command/os/CloseAppCommand"),r=require("../../command/os/GetAppAndVersionCommand"),i=require("../../command/os/OpenAppCommand"),s=require("../../device-session/ApduResponse"),t=require("./CommandUtils");describe("CommandUtils",()=>{describe("static isSuccessResponse",()=>{it("should return true if the status code is 0x9000",()=>{const e=new s.ApduResponse({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])});expect(t.CommandUtils.isSuccessResponse(e)).toBe(!0)}),it("should return false if the status code is not 0x9000",()=>{const e=new s.ApduResponse({statusCode:Uint8Array.from([110,128]),data:Uint8Array.from([])});expect(t.CommandUtils.isSuccessResponse(e)).toBe(!1)}),it("should return false if the status code is not 2 bytes long",()=>{const e=new s.ApduResponse({statusCode:Uint8Array.from([85]),data:Uint8Array.from([])});expect(t.CommandUtils.isSuccessResponse(e)).toBe(!1)})}),describe("static isValidStatusCode",()=>{it("should return true if the status code is 2 bytes long",()=>{const e=Uint8Array.from([144,0]);expect(t.CommandUtils.isValidStatusCode(e)).toBe(!0)}),it("should return false if the status code is not 2 bytes long",()=>{const e=Uint8Array.from([144]);expect(t.CommandUtils.isValidStatusCode(e)).toBe(!1)})}),describe("static isLockedDeviceResponse",()=>{it("should return true if the status code is 0x5515",()=>{const e=new s.ApduResponse({statusCode:Uint8Array.from([85,21]),data:Uint8Array.from([])});expect(t.CommandUtils.isLockedDeviceResponse(e)).toBe(!0)}),it("should return false if the status code is not 0x5515",()=>{const e=new s.ApduResponse({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])});expect(t.CommandUtils.isLockedDeviceResponse(e)).toBe(!1)}),it("should return false if the status code is not 2 bytes long",()=>{const e=new s.ApduResponse({statusCode:Uint8Array.from([144]),data:Uint8Array.from([])});expect(t.CommandUtils.isLockedDeviceResponse(e)).toBe(!1)})}),describe("static isApduThatTriggersDisconnection",()=>{it("should return true if the APDU is openApp",()=>{const e=new i.OpenAppCommand({appName:"test"}).getApdu().getRawApdu();expect(t.CommandUtils.isApduThatTriggersDisconnection(e)).toBe(!0)}),it("should return true if the APDU is closeApp",()=>{const e=new o.CloseAppCommand().getApdu().getRawApdu();expect(t.CommandUtils.isApduThatTriggersDisconnection(e)).toBe(!0)}),it("should return false if the APDU is not a known one",()=>{const e=new r.GetAppAndVersionCommand().getApdu().getRawApdu();expect(t.CommandUtils.isApduThatTriggersDisconnection(e)).toBe(!1)})})});
 //# sourceMappingURL=CommandUtils.test.js.map

package/lib/cjs/src/api/command/utils/CommandUtils.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/utils/CommandUtils.test.ts"],
-  "sourcesContent": ["import { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { CommandUtils } from \"./CommandUtils\";\n\ndescribe(\"CommandUtils\", () => {\n  describe(\"static isSuccessResponse\", () => {\n    it(\"should return true if the status code is 0x9000\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isSuccessResponse(response)).toBe(true);\n    });\n\n    it(\"should return false if the status code is not 0x9000\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6e, 0x80]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isSuccessResponse(response)).toBe(false);\n    });\n\n    it(\"should return false if the status code is not 2 bytes long\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x55]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isSuccessResponse(response)).toBe(false);\n    });\n  });\n\n  describe(\"static isValidStatusCode\", () => {\n    it(\"should return true if the status code is 2 bytes long\", () => {\n      const statusCode = Uint8Array.from([0x90, 0x00]);\n\n      expect(CommandUtils.isValidStatusCode(statusCode)).toBe(true);\n    });\n\n    it(\"should return false if the status code is not 2 bytes long\", () => {\n      const statusCode = Uint8Array.from([0x90]);\n\n      expect(CommandUtils.isValidStatusCode(statusCode)).toBe(false);\n    });\n  });\n\n  describe(\"static isLockedDeviceResponse\", () => {\n    it(\"should return true if the status code is 0x5515\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x55, 0x15]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isLockedDeviceResponse(response)).toBe(true);\n    });\n\n    it(\"should return false if the status code is not 0x5515\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isLockedDeviceResponse(response)).toBe(false);\n    });\n\n    it(\"should return false if the status code is not 2 bytes long\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isLockedDeviceResponse(response)).toBe(false);\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAA6B,4CAE7BC,EAA6B,0BAE7B,SAAS,eAAgB,IAAM,CAC7B,SAAS,2BAA4B,IAAM,CACzC,GAAG,kDAAmD,IAAM,CAC1D,MAAMC,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,EAED,OAAO,eAAa,kBAAkBA,CAAQ,CAAC,EAAE,KAAK,EAAI,CAC5D,CAAC,EAED,GAAG,uDAAwD,IAAM,CAC/D,MAAMA,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,GAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,EAED,OAAO,eAAa,kBAAkBA,CAAQ,CAAC,EAAE,KAAK,EAAK,CAC7D,CAAC,EAED,GAAG,6DAA8D,IAAM,CACrE,MAAMA,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,EAAI,CAAC,EAClC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,EAED,OAAO,eAAa,kBAAkBA,CAAQ,CAAC,EAAE,KAAK,EAAK,CAC7D,CAAC,CACH,CAAC,EAED,SAAS,2BAA4B,IAAM,CACzC,GAAG,wDAAyD,IAAM,CAChE,MAAMC,EAAa,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EAE/C,OAAO,eAAa,kBAAkBA,CAAU,CAAC,EAAE,KAAK,EAAI,CAC9D,CAAC,EAED,GAAG,6DAA8D,IAAM,CACrE,MAAMA,EAAa,WAAW,KAAK,CAAC,GAAI,CAAC,EAEzC,OAAO,eAAa,kBAAkBA,CAAU,CAAC,EAAE,KAAK,EAAK,CAC/D,CAAC,CACH,CAAC,EAED,SAAS,gCAAiC,IAAM,CAC9C,GAAG,kDAAmD,IAAM,CAC1D,MAAMD,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,GAAM,EAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,EAED,OAAO,eAAa,uBAAuBA,CAAQ,CAAC,EAAE,KAAK,EAAI,CACjE,CAAC,EAED,GAAG,uDAAwD,IAAM,CAC/D,MAAMA,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,EAED,OAAO,eAAa,uBAAuBA,CAAQ,CAAC,EAAE,KAAK,EAAK,CAClE,CAAC,EAED,GAAG,6DAA8D,IAAM,CACrE,MAAMA,EAAW,IAAI,eAAa,CAChC,WAAY,WAAW,KAAK,CAAC,GAAI,CAAC,EAClC,KAAM,WAAW,KAAK,CAAC,CAAC,CAC1B,CAAC,EAED,OAAO,eAAa,uBAAuBA,CAAQ,CAAC,EAAE,KAAK,EAAK,CAClE,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["import_ApduResponse", "import_CommandUtils", "response", "statusCode"]
+  "sourcesContent": ["import { CloseAppCommand } from \"@api/command/os/CloseAppCommand\";\nimport { GetAppAndVersionCommand } from \"@api/command/os/GetAppAndVersionCommand\";\nimport { OpenAppCommand } from \"@api/command/os/OpenAppCommand\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { CommandUtils } from \"./CommandUtils\";\n\ndescribe(\"CommandUtils\", () => {\n  describe(\"static isSuccessResponse\", () => {\n    it(\"should return true if the status code is 0x9000\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isSuccessResponse(response)).toBe(true);\n    });\n\n    it(\"should return false if the status code is not 0x9000\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6e, 0x80]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isSuccessResponse(response)).toBe(false);\n    });\n\n    it(\"should return false if the status code is not 2 bytes long\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x55]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isSuccessResponse(response)).toBe(false);\n    });\n  });\n\n  describe(\"static isValidStatusCode\", () => {\n    it(\"should return true if the status code is 2 bytes long\", () => {\n      const statusCode = Uint8Array.from([0x90, 0x00]);\n\n      expect(CommandUtils.isValidStatusCode(statusCode)).toBe(true);\n    });\n\n    it(\"should return false if the status code is not 2 bytes long\", () => {\n      const statusCode = Uint8Array.from([0x90]);\n\n      expect(CommandUtils.isValidStatusCode(statusCode)).toBe(false);\n    });\n  });\n\n  describe(\"static isLockedDeviceResponse\", () => {\n    it(\"should return true if the status code is 0x5515\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x55, 0x15]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isLockedDeviceResponse(response)).toBe(true);\n    });\n\n    it(\"should return false if the status code is not 0x5515\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isLockedDeviceResponse(response)).toBe(false);\n    });\n\n    it(\"should return false if the status code is not 2 bytes long\", () => {\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90]),\n        data: Uint8Array.from([]),\n      });\n\n      expect(CommandUtils.isLockedDeviceResponse(response)).toBe(false);\n    });\n  });\n\n  describe(\"static isApduThatTriggersDisconnection\", () => {\n    it(\"should return true if the APDU is openApp\", () => {\n      const apdu = new OpenAppCommand({ appName: \"test\" })\n        .getApdu()\n        .getRawApdu();\n\n      expect(CommandUtils.isApduThatTriggersDisconnection(apdu)).toBe(true);\n    });\n\n    it(\"should return true if the APDU is closeApp\", () => {\n      const apdu = new CloseAppCommand().getApdu().getRawApdu();\n\n      expect(CommandUtils.isApduThatTriggersDisconnection(apdu)).toBe(true);\n    });\n\n    it(\"should return false if the APDU is not a known one\", () => {\n      const apdu = new GetAppAndVersionCommand().getApdu().getRawApdu();\n\n      expect(CommandUtils.isApduThatTriggersDisconnection(apdu)).toBe(false);\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["import_CloseAppCommand", "import_GetAppAndVersionCommand", "import_OpenAppCommand", "import_ApduResponse", "import_CommandUtils", "response", "statusCode", "apdu"]
 }

package/lib/cjs/src/api/device-action/DeviceAction.js

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var m=(t,e,i,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of s(e))!p.call(t,r)&&r!==i&&a(t,r,{get:()=>e[r],enumerable:!(o=n(e,r))||o.enumerable});return t};var c=t=>m(a({},"__esModule",{value:!0}),t);var d={};module.exports=c(d);
+"use strict";var n=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var m=(t,e,i,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of s(e))!p.call(t,r)&&r!==i&&n(t,r,{get:()=>e[r],enumerable:!(o=a(e,r))||o.enumerable});return t};var c=t=>m(n({},"__esModule",{value:!0}),t);var d={};module.exports=c(d);
 //# sourceMappingURL=DeviceAction.js.map

package/lib/cjs/src/api/device-action/DeviceAction.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/api/device-action/DeviceAction.ts"],
-  "sourcesContent": ["import { type Observable } from \"rxjs\";\n\nimport { type Command } from \"@api/command/Command\";\nimport { type CommandResult } from \"@api/command/model/CommandResult\";\nimport { type DeviceSessionState } from \"@api/device-session/DeviceSessionState\";\nimport { type DmkError } from \"@api/Error\";\nimport { type ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\n\nimport { type DeviceActionState } from \"./model/DeviceActionState\";\n\nexport type InternalApi = {\n  readonly sendCommand: <Response, Args, ErrorStatusCodes>(\n    command: Command<Response, Args, ErrorStatusCodes>,\n  ) => Promise<CommandResult<Response, ErrorStatusCodes>>;\n  readonly getDeviceSessionState: () => DeviceSessionState;\n  readonly getDeviceSessionStateObservable: () => Observable<DeviceSessionState>;\n  readonly setDeviceSessionState: (\n    state: DeviceSessionState,\n  ) => DeviceSessionState;\n  getMetadataForAppHashes: ManagerApiService[\"getAppsByHash\"];\n};\n\nexport type DeviceActionIntermediateValue = {\n  readonly requiredUserInteraction: string;\n};\n\nexport type ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> = {\n  readonly observable: Observable<\n    DeviceActionState<Output, Error, IntermediateValue>\n  >;\n  cancel(): void;\n};\n\nexport interface DeviceAction<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n> {\n  readonly input: Input;\n\n  _execute(\n    params: InternalApi,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue>;\n}\n"],
+  "sourcesContent": ["import { type Either } from \"purify-ts\";\nimport { type Observable } from \"rxjs\";\n\nimport { type Command } from \"@api/command/Command\";\nimport { type CommandResult } from \"@api/command/model/CommandResult\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { type DeviceSessionState } from \"@api/device-session/DeviceSessionState\";\nimport { type DmkError } from \"@api/Error\";\nimport { type ManagerApiService } from \"@internal/manager-api/service/ManagerApiService\";\nimport { type SecureChannelService } from \"@internal/secure-channel/service/SecureChannelService\";\n\nimport { type DeviceActionState } from \"./model/DeviceActionState\";\n\nexport type InternalApi = {\n  readonly sendApdu: (\n    apdu: Uint8Array,\n  ) => Promise<Either<DmkError, ApduResponse>>;\n  readonly sendCommand: <Response, Args, ErrorStatusCodes>(\n    command: Command<Response, Args, ErrorStatusCodes>,\n  ) => Promise<CommandResult<Response, ErrorStatusCodes>>;\n  readonly getDeviceSessionState: () => DeviceSessionState;\n  readonly getDeviceSessionStateObservable: () => Observable<DeviceSessionState>;\n  readonly setDeviceSessionState: (\n    state: DeviceSessionState,\n  ) => DeviceSessionState;\n  readonly getManagerApiService: () => ManagerApiService;\n  readonly getSecureChannelService: () => SecureChannelService;\n};\n\nexport type DeviceActionIntermediateValue = {\n  readonly requiredUserInteraction: string;\n};\n\nexport type ExecuteDeviceActionReturnType<Output, Error, IntermediateValue> = {\n  readonly observable: Observable<\n    DeviceActionState<Output, Error, IntermediateValue>\n  >;\n  cancel(): void;\n};\n\nexport interface DeviceAction<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n> {\n  readonly input: Input;\n\n  _execute(\n    params: InternalApi,\n  ): ExecuteDeviceActionReturnType<Output, Error, IntermediateValue>;\n}\n"],
   "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
   "names": ["DeviceAction_exports", "__toCommonJS"]
 }

package/lib/cjs/src/api/device-action/__test-utils__/makeInternalApi.js

@@ -1,2 +1,2 @@
-"use strict";var o=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var r=(t,e)=>{for(var n in e)o(t,n,{get:e[n],enumerable:!0})},S=(t,e,n,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of i(e))!p.call(t,s)&&s!==n&&o(t,s,{get:()=>e[s],enumerable:!(a=c(e,s))||a.enumerable});return t};var v=t=>S(o({},"__esModule",{value:!0}),t);var j={};r(j,{makeDeviceActionInternalApiMock:()=>D});module.exports=v(j);const M=jest.fn(),k=jest.fn(),d=jest.fn(),f=jest.fn(),m=jest.fn();function D(){return{sendCommand:M,getDeviceSessionState:k,getDeviceSessionStateObservable:d,setDeviceSessionState:f,getMetadataForAppHashes:m}}0&&(module.exports={makeDeviceActionInternalApiMock});
+"use strict";var c=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var r=Object.prototype.hasOwnProperty;var v=(n,e)=>{for(var i in e)c(n,i,{get:e[i],enumerable:!0})},S=(n,e,i,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of a(e))!r.call(n,t)&&t!==i&&c(n,t,{get:()=>e[t],enumerable:!(o=s(e,t))||o.enumerable});return n};var p=n=>S(c({},"__esModule",{value:!0}),n);var D={};v(D,{makeDeviceActionInternalApiMock:()=>l});module.exports=p(D);const M=vi.fn(),k=vi.fn(),d=vi.fn(),f=vi.fn(),m=vi.fn(),g=vi.fn(),A=vi.fn();function l(){return{sendApdu:M,sendCommand:k,getDeviceSessionState:d,getDeviceSessionStateObservable:f,setDeviceSessionState:m,getManagerApiService:g,getSecureChannelService:A}}0&&(module.exports={makeDeviceActionInternalApiMock});
 //# sourceMappingURL=makeInternalApi.js.map

package/lib/cjs/src/api/device-action/__test-utils__/makeInternalApi.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/device-action/__test-utils__/makeInternalApi.ts"],
-  "sourcesContent": ["import { type InternalApi } from \"@api/device-action/DeviceAction\";\n\nconst sendCommandMock = jest.fn();\nconst apiGetDeviceSessionStateMock = jest.fn();\nconst apiGetDeviceSessionStateObservableMock = jest.fn();\nconst setDeviceSessionStateMock = jest.fn();\nconst getMetadataForAppHashesMock = jest.fn();\n\nexport function makeDeviceActionInternalApiMock(): jest.Mocked<InternalApi> {\n  return {\n    sendCommand: sendCommandMock,\n    getDeviceSessionState: apiGetDeviceSessionStateMock,\n    getDeviceSessionStateObservable: apiGetDeviceSessionStateObservableMock,\n    setDeviceSessionState: setDeviceSessionStateMock,\n    getMetadataForAppHashes: getMetadataForAppHashesMock,\n  };\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,qCAAAE,IAAA,eAAAC,EAAAH,GAEA,MAAMI,EAAkB,KAAK,GAAG,EAC1BC,EAA+B,KAAK,GAAG,EACvCC,EAAyC,KAAK,GAAG,EACjDC,EAA4B,KAAK,GAAG,EACpCC,EAA8B,KAAK,GAAG,EAErC,SAASN,GAA4D,CAC1E,MAAO,CACL,YAAaE,EACb,sBAAuBC,EACvB,gCAAiCC,EACjC,sBAAuBC,EACvB,wBAAyBC,CAC3B,CACF",
-  "names": ["makeInternalApi_exports", "__export", "makeDeviceActionInternalApiMock", "__toCommonJS", "sendCommandMock", "apiGetDeviceSessionStateMock", "apiGetDeviceSessionStateObservableMock", "setDeviceSessionStateMock", "getMetadataForAppHashesMock"]
+  "sourcesContent": ["import { type Mocked } from \"vitest\";\n\nimport { type InternalApi } from \"@api/device-action/DeviceAction\";\n\nconst sendApduMock = vi.fn();\nconst sendCommandMock = vi.fn();\nconst apiGetDeviceSessionStateMock = vi.fn();\nconst apiGetDeviceSessionStateObservableMock = vi.fn();\nconst setDeviceSessionStateMock = vi.fn();\nconst getManagerApiServiceMock = vi.fn();\nconst getSecureChannelServiceMock = vi.fn();\n\nexport function makeDeviceActionInternalApiMock(): Mocked<InternalApi> {\n  return {\n    sendApdu: sendApduMock,\n    sendCommand: sendCommandMock,\n    getDeviceSessionState: apiGetDeviceSessionStateMock,\n    getDeviceSessionStateObservable: apiGetDeviceSessionStateObservableMock,\n    setDeviceSessionState: setDeviceSessionStateMock,\n    getManagerApiService: getManagerApiServiceMock,\n    getSecureChannelService: getSecureChannelServiceMock,\n  };\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,qCAAAE,IAAA,eAAAC,EAAAH,GAIA,MAAMI,EAAe,GAAG,GAAG,EACrBC,EAAkB,GAAG,GAAG,EACxBC,EAA+B,GAAG,GAAG,EACrCC,EAAyC,GAAG,GAAG,EAC/CC,EAA4B,GAAG,GAAG,EAClCC,EAA2B,GAAG,GAAG,EACjCC,EAA8B,GAAG,GAAG,EAEnC,SAASR,GAAuD,CACrE,MAAO,CACL,SAAUE,EACV,YAAaC,EACb,sBAAuBC,EACvB,gCAAiCC,EACjC,sBAAuBC,EACvB,qBAAsBC,EACtB,wBAAyBC,CAC3B,CACF",
+  "names": ["makeInternalApi_exports", "__export", "makeDeviceActionInternalApiMock", "__toCommonJS", "sendApduMock", "sendCommandMock", "apiGetDeviceSessionStateMock", "apiGetDeviceSessionStateObservableMock", "setDeviceSessionStateMock", "getManagerApiServiceMock", "getSecureChannelServiceMock"]
 }

package/lib/cjs/src/api/device-action/__test-utils__/setupTestMachine.js

@@ -1,2 +1,2 @@
-"use strict";var p=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var k=(t,e)=>{for(var o in e)p(t,o,{get:e[o],enumerable:!0})},y=(t,e,o,c)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of l(e))!A.call(t,i)&&i!==o&&p(t,i,{get:()=>e[i],enumerable:!(c=f(e,i))||c.enumerable});return t};var D=t=>y(p({},"__esModule",{value:!0}),t);var v={};k(v,{setupGetDeviceStatusMock:()=>h,setupGoToDashboardMock:()=>I,setupListAppsMock:()=>M});module.exports=D(v);var r=require("purify-ts"),n=require("xstate"),a=require("../../device-action/model/UserInteractionRequired"),s=require("../../device-action/os/Errors"),m=require("../../device-action/os/GetDeviceStatus/GetDeviceStatusDeviceAction"),d=require("../../device-action/os/GoToDashboard/GoToDashboardDeviceAction"),u=require("../../device-action/os/ListApps/ListAppsDeviceAction");const M=(t,e=!1)=>{u.ListAppsDeviceAction.mockImplementation(()=>({makeStateMachine:jest.fn().mockImplementation(()=>(0,n.createMachine)({id:"MockListAppsDeviceAction",initial:"ready",states:{ready:{after:{0:"done"},entry:(0,n.assign)({intermediateValue:()=>({requiredUserInteraction:a.UserInteractionRequired.AllowListApps})})},done:{type:"final"}},output:()=>e?(0,r.Left)(new s.UnknownDAError("ListApps failed")):(0,r.Right)(t)}))}))},I=(t=!1)=>{d.GoToDashboardDeviceAction.mockImplementation(()=>({makeStateMachine:jest.fn().mockImplementation(()=>(0,n.createMachine)({id:"MockGoToDashboardDeviceAction",initial:"ready",states:{ready:{after:{0:"done"},entry:(0,n.assign)({intermediateValue:()=>({requiredUserInteraction:a.UserInteractionRequired.None})})},done:{type:"final"}},output:()=>t?(0,r.Left)(new s.UnknownDAError("GoToDashboard failed")):(0,r.Right)(void 0)}))}))},h=(t=[{currentApp:"BOLOS",currentAppVersion:"1.0.0"}])=>{const e=jest.fn();for(const o of t)e.mockImplementationOnce(()=>"currentApp"in o?(0,r.Right)(o):(0,r.Left)(o));m.GetDeviceStatusDeviceAction.mockImplementation(()=>({makeStateMachine:jest.fn().mockImplementation(()=>(0,n.createMachine)({id:"MockGetDeviceStatusDeviceAction",initial:"ready",states:{ready:{after:{0:"done"},entry:(0,n.assign)({intermediateValue:()=>({requiredUserInteraction:a.UserInteractionRequired.None})})},done:{type:"final"}},output:e}))}))};0&&(module.exports={setupGetDeviceStatusMock,setupGoToDashboardMock,setupListAppsMock});
+"use strict";var p=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var A=(t,e)=>{for(var o in e)p(t,o,{get:e[o],enumerable:!0})},y=(t,e,o,m)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of l(e))!k.call(t,i)&&i!==o&&p(t,i,{get:()=>e[i],enumerable:!(m=f(e,i))||m.enumerable});return t};var D=t=>y(p({},"__esModule",{value:!0}),t);var h={};A(h,{setupGetDeviceStatusMock:()=>I,setupGoToDashboardMock:()=>v,setupListAppsMock:()=>M});module.exports=D(h);var r=require("purify-ts"),n=require("xstate"),a=require("../../device-action/model/UserInteractionRequired"),c=require("../../device-action/os/Errors"),s=require("../../device-action/os/GetDeviceStatus/GetDeviceStatusDeviceAction"),d=require("../../device-action/os/GoToDashboard/GoToDashboardDeviceAction"),u=require("../../device-action/os/ListApps/ListAppsDeviceAction");const M=(t,e=!1)=>{u.ListAppsDeviceAction.mockImplementation(()=>({makeStateMachine:vi.fn().mockImplementation(()=>(0,n.createMachine)({id:"MockListAppsDeviceAction",initial:"ready",states:{ready:{after:{0:"done"},entry:(0,n.assign)({intermediateValue:()=>({requiredUserInteraction:a.UserInteractionRequired.AllowListApps})})},done:{type:"final"}},output:()=>e?(0,r.Left)(new c.UnknownDAError("ListApps failed")):(0,r.Right)(t)}))}))},v=(t=!1)=>{d.GoToDashboardDeviceAction.mockImplementation(()=>({makeStateMachine:vi.fn().mockImplementation(()=>(0,n.createMachine)({id:"MockGoToDashboardDeviceAction",initial:"ready",states:{ready:{after:{0:"done"},entry:(0,n.assign)({intermediateValue:()=>({requiredUserInteraction:a.UserInteractionRequired.None})})},done:{type:"final"}},output:()=>t?(0,r.Left)(new c.UnknownDAError("GoToDashboard failed")):(0,r.Right)(void 0)}))}))},I=(t=[{currentApp:"BOLOS",currentAppVersion:"1.0.0"}])=>{const e=vi.fn();for(const o of t)e.mockImplementationOnce(()=>"currentApp"in o?(0,r.Right)(o):(0,r.Left)(o));s.GetDeviceStatusDeviceAction.mockImplementation(()=>({makeStateMachine:vi.fn().mockImplementation(()=>(0,n.createMachine)({id:"MockGetDeviceStatusDeviceAction",initial:"ready",states:{ready:{after:{0:"done"},entry:(0,n.assign)({intermediateValue:()=>({requiredUserInteraction:a.UserInteractionRequired.None})})},done:{type:"final"}},output:e}))}))};0&&(module.exports={setupGetDeviceStatusMock,setupGoToDashboardMock,setupListAppsMock});
 //# sourceMappingURL=setupTestMachine.js.map

package/lib/cjs/src/api/device-action/__test-utils__/setupTestMachine.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/device-action/__test-utils__/setupTestMachine.ts"],
-  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\nimport { assign, createMachine } from \"xstate\";\n\nimport { UserInteractionRequired } from \"@api/device-action/model/UserInteractionRequired\";\nimport { UnknownDAError } from \"@api/device-action/os/Errors\";\nimport { GetDeviceStatusDeviceAction } from \"@api/device-action/os/GetDeviceStatus/GetDeviceStatusDeviceAction\";\nimport { GoToDashboardDeviceAction } from \"@api/device-action/os/GoToDashboard/GoToDashboardDeviceAction\";\nimport { ListAppsDeviceAction } from \"@api/device-action/os/ListApps/ListAppsDeviceAction\";\nimport { type DmkError } from \"@api/Error\";\n\nimport { type BTC_APP } from \"./data\";\n\ntype App = typeof BTC_APP;\n\nexport const setupListAppsMock = (apps: App[], error = false) => {\n  (ListAppsDeviceAction as jest.Mock).mockImplementation(() => ({\n    makeStateMachine: jest.fn().mockImplementation(() =>\n      createMachine({\n        id: \"MockListAppsDeviceAction\",\n        initial: \"ready\",\n        states: {\n          ready: {\n            after: {\n              0: \"done\",\n            },\n            entry: assign({\n              intermediateValue: () => ({\n                requiredUserInteraction: UserInteractionRequired.AllowListApps,\n              }),\n            }),\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: () => {\n          return error\n            ? Left(new UnknownDAError(\"ListApps failed\"))\n            : Right(apps);\n        },\n      }),\n    ),\n  }));\n};\n\nexport const setupGoToDashboardMock = (error: boolean = false) => {\n  (GoToDashboardDeviceAction as jest.Mock).mockImplementation(() => ({\n    makeStateMachine: jest.fn().mockImplementation(() =>\n      createMachine({\n        id: \"MockGoToDashboardDeviceAction\",\n        initial: \"ready\",\n        states: {\n          ready: {\n            after: {\n              0: \"done\",\n            },\n            entry: assign({\n              intermediateValue: () => ({\n                requiredUserInteraction: UserInteractionRequired.None,\n              }),\n            }),\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: () => {\n          return error\n            ? Left(new UnknownDAError(\"GoToDashboard failed\"))\n            : Right(undefined);\n        },\n      }),\n    ),\n  }));\n};\n\nexport const setupGetDeviceStatusMock = (\n  outputs: ReadonlyArray<\n    { currentApp: string; currentAppVersion: string } | DmkError\n  > = [\n    {\n      currentApp: \"BOLOS\",\n      currentAppVersion: \"1.0.0\",\n    },\n  ],\n) => {\n  const outputFn = jest.fn();\n\n  for (const output of outputs) {\n    outputFn.mockImplementationOnce(() =>\n      \"currentApp\" in output ? Right(output) : Left(output),\n    );\n  }\n  (GetDeviceStatusDeviceAction as jest.Mock).mockImplementation(() => ({\n    makeStateMachine: jest.fn().mockImplementation(() =>\n      createMachine({\n        id: \"MockGetDeviceStatusDeviceAction\",\n        initial: \"ready\",\n        states: {\n          ready: {\n            after: {\n              0: \"done\",\n            },\n            entry: assign({\n              intermediateValue: () => ({\n                requiredUserInteraction: UserInteractionRequired.None,\n              }),\n            }),\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: outputFn,\n      }),\n    ),\n  }));\n};\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,EAAA,2BAAAC,EAAA,sBAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAA4B,qBAC5BC,EAAsC,kBAEtCC,EAAwC,4DACxCC,EAA+B,wCAC/BC,EAA4C,6EAC5CC,EAA0C,yEAC1CC,EAAqC,+DAO9B,MAAMR,EAAoB,CAACS,EAAaC,EAAQ,KAAU,CAC9D,uBAAmC,mBAAmB,KAAO,CAC5D,iBAAkB,KAAK,GAAG,EAAE,mBAAmB,OAC7C,iBAAc,CACZ,GAAI,2BACJ,QAAS,QACT,OAAQ,CACN,MAAO,CACL,MAAO,CACL,EAAG,MACL,EACA,SAAO,UAAO,CACZ,kBAAmB,KAAO,CACxB,wBAAyB,0BAAwB,aACnD,EACF,CAAC,CACH,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQ,IACCA,KACH,QAAK,IAAI,iBAAe,iBAAiB,CAAC,KAC1C,SAAMD,CAAI,CAElB,CAAC,CACH,CACF,EAAE,CACJ,EAEaV,EAAyB,CAACW,EAAiB,KAAU,CAC/D,4BAAwC,mBAAmB,KAAO,CACjE,iBAAkB,KAAK,GAAG,EAAE,mBAAmB,OAC7C,iBAAc,CACZ,GAAI,gCACJ,QAAS,QACT,OAAQ,CACN,MAAO,CACL,MAAO,CACL,EAAG,MACL,EACA,SAAO,UAAO,CACZ,kBAAmB,KAAO,CACxB,wBAAyB,0BAAwB,IACnD,EACF,CAAC,CACH,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQ,IACCA,KACH,QAAK,IAAI,iBAAe,sBAAsB,CAAC,KAC/C,SAAM,MAAS,CAEvB,CAAC,CACH,CACF,EAAE,CACJ,EAEaZ,EAA2B,CACtCa,EAEI,CACF,CACE,WAAY,QACZ,kBAAmB,OACrB,CACF,IACG,CACH,MAAMC,EAAW,KAAK,GAAG,EAEzB,UAAWC,KAAUF,EACnBC,EAAS,uBAAuB,IAC9B,eAAgBC,KAAS,SAAMA,CAAM,KAAI,QAAKA,CAAM,CACtD,EAED,8BAA0C,mBAAmB,KAAO,CACnE,iBAAkB,KAAK,GAAG,EAAE,mBAAmB,OAC7C,iBAAc,CACZ,GAAI,kCACJ,QAAS,QACT,OAAQ,CACN,MAAO,CACL,MAAO,CACL,EAAG,MACL,EACA,SAAO,UAAO,CACZ,kBAAmB,KAAO,CACxB,wBAAyB,0BAAwB,IACnD,EACF,CAAC,CACH,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQD,CACV,CAAC,CACH,CACF,EAAE,CACJ",
+  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\nimport { type Mock } from \"vitest\";\nimport { assign, createMachine } from \"xstate\";\n\nimport { UserInteractionRequired } from \"@api/device-action/model/UserInteractionRequired\";\nimport { UnknownDAError } from \"@api/device-action/os/Errors\";\nimport { GetDeviceStatusDeviceAction } from \"@api/device-action/os/GetDeviceStatus/GetDeviceStatusDeviceAction\";\nimport { GoToDashboardDeviceAction } from \"@api/device-action/os/GoToDashboard/GoToDashboardDeviceAction\";\nimport { ListAppsDeviceAction } from \"@api/device-action/os/ListApps/ListAppsDeviceAction\";\nimport { type DmkError } from \"@api/Error\";\n\nimport { type BTC_APP } from \"./data\";\n\ntype App = typeof BTC_APP;\n\nexport const setupListAppsMock = (apps: App[], error = false) => {\n  (ListAppsDeviceAction as Mock).mockImplementation(() => ({\n    makeStateMachine: vi.fn().mockImplementation(() =>\n      createMachine({\n        id: \"MockListAppsDeviceAction\",\n        initial: \"ready\",\n        states: {\n          ready: {\n            after: {\n              0: \"done\",\n            },\n            entry: assign({\n              intermediateValue: () => ({\n                requiredUserInteraction: UserInteractionRequired.AllowListApps,\n              }),\n            }),\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: () => {\n          return error\n            ? Left(new UnknownDAError(\"ListApps failed\"))\n            : Right(apps);\n        },\n      }),\n    ),\n  }));\n};\n\nexport const setupGoToDashboardMock = (error: boolean = false) => {\n  (GoToDashboardDeviceAction as Mock).mockImplementation(() => ({\n    makeStateMachine: vi.fn().mockImplementation(() =>\n      createMachine({\n        id: \"MockGoToDashboardDeviceAction\",\n        initial: \"ready\",\n        states: {\n          ready: {\n            after: {\n              0: \"done\",\n            },\n            entry: assign({\n              intermediateValue: () => ({\n                requiredUserInteraction: UserInteractionRequired.None,\n              }),\n            }),\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: () => {\n          return error\n            ? Left(new UnknownDAError(\"GoToDashboard failed\"))\n            : Right(undefined);\n        },\n      }),\n    ),\n  }));\n};\n\nexport const setupGetDeviceStatusMock = (\n  outputs: ReadonlyArray<\n    { currentApp: string; currentAppVersion: string } | DmkError\n  > = [\n    {\n      currentApp: \"BOLOS\",\n      currentAppVersion: \"1.0.0\",\n    },\n  ],\n) => {\n  const outputFn = vi.fn();\n\n  for (const output of outputs) {\n    outputFn.mockImplementationOnce(() =>\n      \"currentApp\" in output ? Right(output) : Left(output),\n    );\n  }\n  (GetDeviceStatusDeviceAction as Mock).mockImplementation(() => ({\n    makeStateMachine: vi.fn().mockImplementation(() =>\n      createMachine({\n        id: \"MockGetDeviceStatusDeviceAction\",\n        initial: \"ready\",\n        states: {\n          ready: {\n            after: {\n              0: \"done\",\n            },\n            entry: assign({\n              intermediateValue: () => ({\n                requiredUserInteraction: UserInteractionRequired.None,\n              }),\n            }),\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: outputFn,\n      }),\n    ),\n  }));\n};\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,EAAA,2BAAAC,EAAA,sBAAAC,IAAA,eAAAC,EAAAL,GAAA,IAAAM,EAA4B,qBAE5BC,EAAsC,kBAEtCC,EAAwC,4DACxCC,EAA+B,wCAC/BC,EAA4C,6EAC5CC,EAA0C,yEAC1CC,EAAqC,+DAO9B,MAAMR,EAAoB,CAACS,EAAaC,EAAQ,KAAU,CAC9D,uBAA8B,mBAAmB,KAAO,CACvD,iBAAkB,GAAG,GAAG,EAAE,mBAAmB,OAC3C,iBAAc,CACZ,GAAI,2BACJ,QAAS,QACT,OAAQ,CACN,MAAO,CACL,MAAO,CACL,EAAG,MACL,EACA,SAAO,UAAO,CACZ,kBAAmB,KAAO,CACxB,wBAAyB,0BAAwB,aACnD,EACF,CAAC,CACH,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQ,IACCA,KACH,QAAK,IAAI,iBAAe,iBAAiB,CAAC,KAC1C,SAAMD,CAAI,CAElB,CAAC,CACH,CACF,EAAE,CACJ,EAEaV,EAAyB,CAACW,EAAiB,KAAU,CAC/D,4BAAmC,mBAAmB,KAAO,CAC5D,iBAAkB,GAAG,GAAG,EAAE,mBAAmB,OAC3C,iBAAc,CACZ,GAAI,gCACJ,QAAS,QACT,OAAQ,CACN,MAAO,CACL,MAAO,CACL,EAAG,MACL,EACA,SAAO,UAAO,CACZ,kBAAmB,KAAO,CACxB,wBAAyB,0BAAwB,IACnD,EACF,CAAC,CACH,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQ,IACCA,KACH,QAAK,IAAI,iBAAe,sBAAsB,CAAC,KAC/C,SAAM,MAAS,CAEvB,CAAC,CACH,CACF,EAAE,CACJ,EAEaZ,EAA2B,CACtCa,EAEI,CACF,CACE,WAAY,QACZ,kBAAmB,OACrB,CACF,IACG,CACH,MAAMC,EAAW,GAAG,GAAG,EAEvB,UAAWC,KAAUF,EACnBC,EAAS,uBAAuB,IAC9B,eAAgBC,KAAS,SAAMA,CAAM,KAAI,QAAKA,CAAM,CACtD,EAED,8BAAqC,mBAAmB,KAAO,CAC9D,iBAAkB,GAAG,GAAG,EAAE,mBAAmB,OAC3C,iBAAc,CACZ,GAAI,kCACJ,QAAS,QACT,OAAQ,CACN,MAAO,CACL,MAAO,CACL,EAAG,MACL,EACA,SAAO,UAAO,CACZ,kBAAmB,KAAO,CACxB,wBAAyB,0BAAwB,IACnD,EACF,CAAC,CACH,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQD,CACV,CAAC,CACH,CACF,EAAE,CACJ",
   "names": ["setupTestMachine_exports", "__export", "setupGetDeviceStatusMock", "setupGoToDashboardMock", "setupListAppsMock", "__toCommonJS", "import_purify_ts", "import_xstate", "import_UserInteractionRequired", "import_Errors", "import_GetDeviceStatusDeviceAction", "import_GoToDashboardDeviceAction", "import_ListAppsDeviceAction", "apps", "error", "outputs", "outputFn", "output"]
 }

package/lib/cjs/src/api/device-action/__test-utils__/testDeviceActionStates.js

@@ -1,2 +1,2 @@
-"use strict";var o=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var s=(t,e)=>{for(var i in e)o(t,i,{get:e[i],enumerable:!0})},A=(t,e,i,c)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of m(e))!l.call(t,r)&&r!==i&&o(t,r,{get:()=>e[r],enumerable:!(c=p(e,r))||c.enumerable});return t};var D=t=>A(o({},"__esModule",{value:!0}),t);var I={};s(I,{testDeviceActionStates:()=>v});module.exports=D(I);function v(t,e,i,c){const r=[],{observable:a,cancel:u}=t._execute(i);return a.subscribe({next:n=>{r.push(n)},error:n=>{c(n)},complete:()=>{try{expect(r).toEqual(e),c()}catch(n){c(n)}}}),{observable:a,cancel:u}}0&&(module.exports={testDeviceActionStates});
+"use strict";var c=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var v=(t,e)=>{for(var o in e)c(t,o,{get:e[o],enumerable:!0})},A=(t,e,o,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of s(e))!l.call(t,r)&&r!==o&&c(t,r,{get:()=>e[r],enumerable:!(n=m(e,r))||n.enumerable});return t};var d=t=>A(c({},"__esModule",{value:!0}),t);var I={};v(I,{testDeviceActionStates:()=>D});module.exports=d(I);function D(t,e,o,{onDone:n,onError:r}){const a=[],{observable:u,cancel:p}=t._execute(o);return u.subscribe({next:i=>{a.push(i)},error:i=>{r(i)},complete:()=>{try{expect(a).toEqual(e),n()}catch(i){r(i)}}}),{observable:u,cancel:p}}0&&(module.exports={testDeviceActionStates});
 //# sourceMappingURL=testDeviceActionStates.js.map

package/lib/cjs/src/api/device-action/__test-utils__/testDeviceActionStates.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/device-action/__test-utils__/testDeviceActionStates.ts"],
-  "sourcesContent": ["import {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type InternalApi,\n} from \"@api/device-action/DeviceAction\";\nimport { type DeviceActionState } from \"@api/device-action/model/DeviceActionState\";\nimport { type DmkError } from \"@api/Error\";\n\n/**\n * Test that the states emitted by a device action match the expected states.\n * @param deviceAction The device action to test.\n * @param expectedStates The expected states.\n * @param internalApi\n * @param done The Jest done callback.\n */\nexport function testDeviceActionStates<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n>(\n  deviceAction: DeviceAction<Output, Input, Error, IntermediateValue>,\n  expectedStates: Array<DeviceActionState<Output, Error, IntermediateValue>>,\n  internalApi: InternalApi,\n  done: jest.DoneCallback,\n) {\n  const observedStates: Array<\n    DeviceActionState<Output, Error, IntermediateValue>\n  > = [];\n\n  const { observable, cancel } = deviceAction._execute(internalApi);\n  observable.subscribe({\n    next: (state) => {\n      observedStates.push(state);\n    },\n    error: (error) => {\n      done(error);\n    },\n    complete: () => {\n      try {\n        expect(observedStates).toEqual(expectedStates);\n        done();\n      } catch (e) {\n        done(e);\n      }\n    },\n  });\n  return { observable, cancel };\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,IAAA,eAAAC,EAAAH,GAeO,SAASE,EAMdE,EACAC,EACAC,EACAC,EACA,CACA,MAAMC,EAEF,CAAC,EAEC,CAAE,WAAAC,EAAY,OAAAC,CAAO,EAAIN,EAAa,SAASE,CAAW,EAChE,OAAAG,EAAW,UAAU,CACnB,KAAOE,GAAU,CACfH,EAAe,KAAKG,CAAK,CAC3B,EACA,MAAQC,GAAU,CAChBL,EAAKK,CAAK,CACZ,EACA,SAAU,IAAM,CACd,GAAI,CACF,OAAOJ,CAAc,EAAE,QAAQH,CAAc,EAC7CE,EAAK,CACP,OAASM,EAAG,CACVN,EAAKM,CAAC,CACR,CACF,CACF,CAAC,EACM,CAAE,WAAAJ,EAAY,OAAAC,CAAO,CAC9B",
-  "names": ["testDeviceActionStates_exports", "__export", "testDeviceActionStates", "__toCommonJS", "deviceAction", "expectedStates", "internalApi", "done", "observedStates", "observable", "cancel", "state", "error", "e"]
+  "sourcesContent": ["import {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type InternalApi,\n} from \"@api/device-action/DeviceAction\";\nimport { type DeviceActionState } from \"@api/device-action/model/DeviceActionState\";\nimport { type DmkError } from \"@api/Error\";\n\n/**\n * Test that the states emitted by a device action match the expected states.\n * @param deviceAction The device action to test.\n * @param expectedStates The expected states.\n * @param internalApi\n * @param callbacks { onDone, onError } The callbacks to call when the test is done or an error occurs.\n */\nexport function testDeviceActionStates<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n>(\n  deviceAction: DeviceAction<Output, Input, Error, IntermediateValue>,\n  expectedStates: Array<DeviceActionState<Output, Error, IntermediateValue>>,\n  internalApi: InternalApi,\n  {\n    onDone,\n    onError,\n  }: {\n    onDone: () => void;\n    onError: (error: Error) => void;\n  },\n) {\n  const observedStates: Array<\n    DeviceActionState<Output, Error, IntermediateValue>\n  > = [];\n\n  const { observable, cancel } = deviceAction._execute(internalApi);\n\n  observable.subscribe({\n    next: (state) => {\n      observedStates.push(state);\n    },\n    error: (error) => {\n      onError(error);\n    },\n    complete: () => {\n      try {\n        expect(observedStates).toEqual(expectedStates);\n        onDone();\n      } catch (e) {\n        onError(e as Error);\n      }\n    },\n  });\n\n  return { observable, cancel };\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,IAAA,eAAAC,EAAAH,GAeO,SAASE,EAMdE,EACAC,EACAC,EACA,CACE,OAAAC,EACA,QAAAC,CACF,EAIA,CACA,MAAMC,EAEF,CAAC,EAEC,CAAE,WAAAC,EAAY,OAAAC,CAAO,EAAIP,EAAa,SAASE,CAAW,EAEhE,OAAAI,EAAW,UAAU,CACnB,KAAOE,GAAU,CACfH,EAAe,KAAKG,CAAK,CAC3B,EACA,MAAQC,GAAU,CAChBL,EAAQK,CAAK,CACf,EACA,SAAU,IAAM,CACd,GAAI,CACF,OAAOJ,CAAc,EAAE,QAAQJ,CAAc,EAC7CE,EAAO,CACT,OAASO,EAAG,CACVN,EAAQM,CAAU,CACpB,CACF,CACF,CAAC,EAEM,CAAE,WAAAJ,EAAY,OAAAC,CAAO,CAC9B",
+  "names": ["testDeviceActionStates_exports", "__export", "testDeviceActionStates", "__toCommonJS", "deviceAction", "expectedStates", "internalApi", "onDone", "onError", "observedStates", "observable", "cancel", "state", "error", "e"]
 }

package/lib/cjs/src/api/device-action/os/CallTaskInAppDeviceAction/CallTaskInAppDeviceAction.js

@@ -0,0 +1,2 @@
+"use strict";var o=Object.defineProperty;var A=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var I=(r,t)=>{for(var s in t)o(r,s,{get:t[s],enumerable:!0})},C=(r,t,s,e)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of T(t))!m.call(r,n)&&n!==s&&o(r,n,{get:()=>t[n],enumerable:!(e=A(t,n))||e.enumerable});return r};var d=r=>C(o({},"__esModule",{value:!0}),r);var S={};I(S,{CallTaskInAppDeviceAction:()=>D});module.exports=d(S);var p=require("purify-ts"),a=require("xstate"),l=require("../../../command/model/CommandResult"),i=require("../../../device-action/model/UserInteractionRequired"),c=require("../../../device-action/os/Errors"),u=require("../../../device-action/os/OpenAppDeviceAction/OpenAppDeviceAction"),k=require("../../../device-action/xstate-utils/XStateDeviceAction");class D extends k.XStateDeviceAction{makeStateMachine(t){const{callTask:s}=this.extractDependencies(t);return(0,a.setup)({types:{input:{},context:{},output:{}},actors:{callTask:(0,a.fromPromise)(s),openAppStateMachine:new u.OpenAppDeviceAction({input:{appName:this.input.appName,compatibleAppNames:this.input.compatibleAppNames}}).makeStateMachine(t)},guards:{noInternalError:({context:e})=>e._internalState.error===null},actions:{assignErrorFromEvent:(0,a.assign)({_internalState:e=>({...e.context._internalState,error:e.event.error})})}}).createMachine({id:"CallTaskInAppDeviceAction",initial:"OpenAppDeviceAction",context:({input:e})=>({input:e,intermediateValue:{requiredUserInteraction:i.UserInteractionRequired.None},_internalState:{taskResponse:null,error:null}}),states:{OpenAppDeviceAction:{invoke:{id:"openAppStateMachine",input:{appName:this.input.appName,compatibleAppNames:this.input.compatibleAppNames},src:"openAppStateMachine",onSnapshot:{actions:(0,a.assign)({intermediateValue:e=>e.event.snapshot.context.intermediateValue})},onDone:{actions:(0,a.assign)({_internalState:e=>e.event.output.caseOf({Right:()=>e.context._internalState,Left:n=>({...e.context._internalState,error:n})})}),target:"CheckOpenAppDeviceActionResult"}}},CheckOpenAppDeviceActionResult:{always:[{target:"CallTask",guard:"noInternalError"},"Error"]},CallTask:{entry:(0,a.assign)({intermediateValue:{requiredUserInteraction:this.input.requiredUserInteraction}}),exit:(0,a.assign)({intermediateValue:{requiredUserInteraction:i.UserInteractionRequired.None}}),invoke:{id:"callTask",src:"callTask",input:e=>e.context.input.task,onDone:{target:"CallTaskResultCheck",actions:[(0,a.assign)({_internalState:({event:e,context:n})=>(0,l.isSuccessCommandResult)(e.output)?{...n._internalState,taskResponse:e.output.data}:{...n._internalState,error:e.output.error}})]},onError:{target:"Error",actions:"assignErrorFromEvent"}}},CallTaskResultCheck:{always:[{target:"Success",guard:"noInternalError"},"Error"]},Success:{type:"final"},Error:{type:"final"}},output:({context:e})=>e._internalState.taskResponse?(0,p.Right)(e._internalState.taskResponse):(0,p.Left)(e._internalState.error||new c.UnknownDAError("No error in final state"))})}extractDependencies(t){return{callTask:s=>s.input(t)}}}0&&(module.exports={CallTaskInAppDeviceAction});
+//# sourceMappingURL=CallTaskInAppDeviceAction.js.map

package/lib/cjs/src/api/device-action/os/CallTaskInAppDeviceAction/CallTaskInAppDeviceAction.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../src/api/device-action/os/CallTaskInAppDeviceAction/CallTaskInAppDeviceAction.ts"],
+  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\nimport { assign, fromPromise, setup } from \"xstate\";\n\nimport {\n  type CommandResult,\n  isSuccessCommandResult,\n} from \"@api/command/model/CommandResult\";\nimport { type InternalApi } from \"@api/device-action/DeviceAction\";\nimport { UserInteractionRequired } from \"@api/device-action/model/UserInteractionRequired\";\nimport { UnknownDAError } from \"@api/device-action/os/Errors\";\nimport { OpenAppDeviceAction } from \"@api/device-action/os/OpenAppDeviceAction/OpenAppDeviceAction\";\nimport { type StateMachineTypes } from \"@api/device-action/xstate-utils/StateMachineTypes\";\nimport {\n  type DeviceActionStateMachine,\n  XStateDeviceAction,\n} from \"@api/device-action/xstate-utils/XStateDeviceAction\";\n\nimport {\n  type CallTaskInAppDAError,\n  type CallTaskInAppDAInput,\n  type CallTaskInAppDAIntermediateValue,\n  type CallTaskInAppDAInternalState,\n  type CallTaskInAppDAOutput,\n} from \"./CallTaskInAppDeviceActionTypes\";\n\n/**\n * Tries to open an app on the device, and if it is successful, calls a task\n * in the app.\n * The output will be the result of the task.\n *\n * ```ts\n * input: {\n *  appName: string;\n *  task: (internalApi: InternalApi) => Promise<CommandResult<TaskResponse, TaskErrorCodes>>;\n *  requiredUserInteraction: UserInteraction;\n * }\n * ```\n *\n * Example of usage:\n *\n * ```ts\n * const deviceAction = new CallTaskInAppDeviceAction({\n *  input: {\n *   appName: \"MyApp\",\n *   task: async (internalApi: InternalApi) => internalApi.sendCommand(new MyAppSpecificCommand()),\n *   requiredUserInteraction: UserInteractionRequired.None,\n *  },\n * });\n * dmk.executeDeviceAction({ sessionId: \"mySessionId\", deviceAction });\n * ```\n */\nexport class CallTaskInAppDeviceAction<\n  TaskResponse,\n  TaskErrorCodes,\n  UserInteraction extends UserInteractionRequired,\n> extends XStateDeviceAction<\n  CallTaskInAppDAOutput<TaskResponse>,\n  CallTaskInAppDAInput<TaskResponse, TaskErrorCodes, UserInteraction>,\n  CallTaskInAppDAError<TaskErrorCodes>,\n  CallTaskInAppDAIntermediateValue<UserInteraction>,\n  CallTaskInAppDAInternalState<TaskResponse, TaskErrorCodes>\n> {\n  makeStateMachine(\n    internalAPI: InternalApi,\n  ): DeviceActionStateMachine<\n    CallTaskInAppDAOutput<TaskResponse>,\n    CallTaskInAppDAInput<TaskResponse, TaskErrorCodes, UserInteraction>,\n    CallTaskInAppDAError<TaskErrorCodes>,\n    CallTaskInAppDAIntermediateValue<UserInteraction>,\n    CallTaskInAppDAInternalState<TaskResponse, TaskErrorCodes>\n  > {\n    type types = StateMachineTypes<\n      CallTaskInAppDAOutput<TaskResponse>,\n      CallTaskInAppDAInput<TaskResponse, TaskErrorCodes, UserInteraction>,\n      CallTaskInAppDAError<TaskErrorCodes>,\n      CallTaskInAppDAIntermediateValue<UserInteraction>,\n      CallTaskInAppDAInternalState<TaskResponse, TaskErrorCodes>\n    >;\n\n    const { callTask } = this.extractDependencies(internalAPI);\n\n    return setup({\n      types: {\n        input: {} as types[\"input\"],\n        context: {} as types[\"context\"],\n        output: {} as types[\"output\"],\n      },\n      actors: {\n        callTask: fromPromise(callTask),\n        openAppStateMachine: new OpenAppDeviceAction({\n          input: {\n            appName: this.input.appName,\n            compatibleAppNames: this.input.compatibleAppNames,\n          },\n        }).makeStateMachine(internalAPI),\n      },\n      guards: {\n        noInternalError: ({ context }) => context._internalState.error === null,\n      },\n      actions: {\n        assignErrorFromEvent: assign({\n          _internalState: (_) => ({\n            ..._.context._internalState,\n            error: _.event[\"error\"], // NOTE: it should never happen, the error is not typed anymore here\n          }),\n        }),\n      },\n    }).createMachine({\n      id: \"CallTaskInAppDeviceAction\",\n      initial: \"OpenAppDeviceAction\",\n      context: ({ input }) => {\n        return {\n          input: input,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          _internalState: {\n            taskResponse: null,\n            error: null,\n          },\n        };\n      },\n      states: {\n        OpenAppDeviceAction: {\n          invoke: {\n            id: \"openAppStateMachine\",\n            input: {\n              appName: this.input.appName,\n              compatibleAppNames: this.input.compatibleAppNames,\n            },\n            src: \"openAppStateMachine\",\n            onSnapshot: {\n              actions: assign({\n                intermediateValue: (_) =>\n                  _.event.snapshot.context.intermediateValue,\n              }),\n            },\n            onDone: {\n              actions: assign({\n                _internalState: (_) => {\n                  return _.event.output.caseOf<\n                    CallTaskInAppDAInternalState<TaskResponse, TaskErrorCodes>\n                  >({\n                    Right: () => _.context._internalState,\n                    Left: (error) => ({\n                      ..._.context._internalState,\n                      error,\n                    }),\n                  });\n                },\n              }),\n              target: \"CheckOpenAppDeviceActionResult\",\n            },\n          },\n        },\n        CheckOpenAppDeviceActionResult: {\n          always: [\n            {\n              target: \"CallTask\",\n              guard: \"noInternalError\",\n            },\n            \"Error\",\n          ],\n        },\n        CallTask: {\n          entry: assign({\n            intermediateValue: {\n              requiredUserInteraction: this.input.requiredUserInteraction,\n            },\n          }),\n          exit: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          invoke: {\n            id: \"callTask\",\n            src: \"callTask\",\n            input: (_: { context: types[\"context\"] }) => _.context.input.task,\n            onDone: {\n              target: \"CallTaskResultCheck\",\n              actions: [\n                assign({\n                  _internalState: ({ event, context }) => {\n                    if (isSuccessCommandResult(event.output)) {\n                      return {\n                        ...context._internalState,\n                        taskResponse: event.output.data,\n                      };\n                    }\n                    return {\n                      ...context._internalState,\n                      error: event.output.error,\n                    };\n                  },\n                }),\n              ],\n            },\n            onError: {\n              target: \"Error\",\n              actions: \"assignErrorFromEvent\",\n            },\n          },\n        },\n        CallTaskResultCheck: {\n          always: [\n            {\n              target: \"Success\",\n              guard: \"noInternalError\",\n            },\n            \"Error\",\n          ],\n        },\n        Success: {\n          type: \"final\",\n        },\n        Error: {\n          type: \"final\",\n        },\n      },\n      output: ({ context }) =>\n        context._internalState.taskResponse\n          ? Right(context._internalState.taskResponse)\n          : Left(\n              context._internalState.error ||\n                new UnknownDAError(\"No error in final state\"),\n            ),\n    });\n  }\n\n  extractDependencies(internalApi: InternalApi) {\n    return {\n      callTask: (_: {\n        input: (\n          internalApi: InternalApi,\n        ) => Promise<CommandResult<TaskResponse, TaskErrorCodes>>;\n      }): Promise<CommandResult<TaskResponse, TaskErrorCodes>> =>\n        _.input(internalApi),\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["CallTaskInAppDeviceAction_exports", "__export", "CallTaskInAppDeviceAction", "__toCommonJS", "import_purify_ts", "import_xstate", "import_CommandResult", "import_UserInteractionRequired", "import_Errors", "import_OpenAppDeviceAction", "import_XStateDeviceAction", "internalAPI", "callTask", "context", "_", "input", "error", "event", "internalApi"]
+}