npm - @ledgerhq/device-management-kit - Versions diffs - 0.0.0-signer-eth-plugin-fix-20250331141239 → 0.0.0-transactionInspector-resolutionObj-20250916095320 - Mend

@ledgerhq/device-management-kit 0.0.0-signer-eth-plugin-fix-20250331141239 → 0.0.0-transactionInspector-resolutionObj-20250916095320

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (779) hide show

package/lib/cjs/src/api/apdu/utils/ByteArrayBuilder.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayBuilder.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\nimport { DataOverflowError, HexaStringEncodeError } from \"./AppBuilderError\";\nimport { ByteArrayBuilder } from \"./ByteArrayBuilder\";\n\nconst COMMAND_NO_BODY = new Uint8Array([]);\n\nconst COMMAND_BODY_SINGLE = new Uint8Array([0x01]);\n\nconst COMMAND_BODY_HEXA1 = new Uint8Array([0x80, 0x81, 0x82, 0x83, 0x84]);\n\nconst COMMAND_BODY_HEXA2 = new Uint8Array([0x85, 0x86, 0x87, 0x88]);\n\nconst COMMAND_BODY_LV_HEXA = new Uint8Array([0x03, 0xa1, 0xa2, 0xa3]);\n\nconst COMMAND_BODY_LV_ASCII = new Uint8Array([\n  0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n]);\n\nconst COMMAND_BODY_LV_ARRAY = new Uint8Array([0x02, 0xf0, 0xf1]);\n\nconst COMMAND_BODY_COMBINED = new Uint8Array([\n  0x01, 0x33, 0x02, 0x01, 0x23, 0x45, 0x67, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,\n  0x86, 0x87, 0x88, 0x03, 0xa1, 0xa2, 0xa3, 0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n  0x02, 0xf0, 0xf1,\n]);\n\nconst COMMAND_BODY_MAX = new Uint8Array([...Array<number>(255).fill(0xaa)]);\n\nconst COMMAND_BODY_NEARLY = new Uint8Array([...Array<number>(254).fill(0xaa)]);\n\nlet builder: ByteArrayBuilder;\n\ndescribe(\"ByteArrayBuilder\", () => {\n  const builderAddNumber = (\n    num: number | bigint,\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ) => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitIntToData(num, bigEndian);\n          break;\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitUIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitUIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitUIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitUIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitUIntToData(num, bigEndian);\n          break;\n      }\n    }\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should create an instance\", () => {\n      expect(builder).toBeDefined();\n      expect(builder).toBeInstanceOf(ByteArrayBuilder);\n    });\n  });\n\n  describe(\"simple\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with an empty body\", () => {\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n    });\n\n    it(\"should serialize with an single byte body\", () => {\n      builder = new ByteArrayBuilder(1);\n      builder.add8BitUIntToData(0x01);\n      expect(builder.build()).toEqual(COMMAND_BODY_SINGLE);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it.each([\n      [2, false, true, 0x3302, \"3302\"],\n      [2, false, false, 0x3302n, \"0233\"],\n      [2, true, true, 4200n, \"1068\"],\n      [2, true, true, -4200n, \"ef98\"],\n      [2, true, false, 4200, \"6810\"],\n      [2, true, false, -4200, \"98ef\"],\n      [4, false, true, 0x01234567n, \"01234567\"],\n      [4, false, false, 0x01234567n, \"67452301\"],\n      [4, true, true, 123456789, \"075bcd15\"],\n      [4, true, true, -123456789, \"f8a432eb\"],\n      [4, true, false, 123456789, \"15cd5b07\"],\n      [4, true, false, -123456789, \"eb32a4f8\"],\n      [8, false, true, 14147778004927559n, \"0032435442584447\"],\n      [8, false, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, true, 14147778004927559n, \"0032435442584447\"],\n      [8, true, true, -14147778004927559n, \"ffcdbcabbda7bbb9\"],\n      [8, true, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, false, -14147778004927559n, \"b9bba7bdabbccdff\"],\n      [\n        16,\n        false,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        false,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x00324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        16,\n        true,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        false,\n        -0x00324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        false,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        32,\n        true,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        false,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n    ])(\n      \"serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n\n        // Retry with a buffer too small\n        builder = new ByteArrayBuilder(sizeInBits - 1);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it.each([\n      [2, false, true, 0xffffn, \"ffff\"],\n      [2, true, true, 0x7fffn, \"7fff\"],\n      [2, true, true, -0x8000n, \"8000\"],\n      [4, false, true, 0xffffffffn, \"ffffffff\"],\n      [4, true, true, 0x7fffffffn, \"7fffffff\"],\n      [4, true, true, -0x80000000n, \"80000000\"],\n      [8, false, true, 0xffffffffffffffffn, \"ffffffffffffffff\"],\n      [8, true, true, 0x7fffffffffffffffn, \"7fffffffffffffff\"],\n      [8, true, true, -0x8000000000000000n, \"8000000000000000\"],\n      [\n        16,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x80000000000000000000000000000000n,\n        \"80000000000000000000000000000000\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n      ],\n    ])(\n      \"serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n      },\n    );\n\n    it(\"Serialize from float to bigint\", () => {\n      builder = new ByteArrayBuilder(4);\n      builder.add32BitIntToData(123456789.3, false);\n      expect(builder.getErrors().length).toEqual(1);\n      expect(builder.build()).toEqual(Uint8Array.from([]));\n    });\n\n    it(\"should serialize with an 5 byte body from an hexastring\", () => {\n      builder.addHexaStringToData(\"0x8081828384\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA1);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body from an hexastring without '0x'\", () => {\n      builder.addHexaStringToData(\"85868788\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA2);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an hexastring\", () => {\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_HEXA);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an ascci string\", () => {\n      builder.encodeInLVFromAscii(\"maman\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ASCII);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an complete body of 0xAA\", () => {\n      const myarray = new Uint8Array(255).fill(0xaa, 0, 255);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getErrors()).toEqual([]);\n    });\n  });\n\n  describe(\"mixed\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with all previous field\", () => {\n      let available = APDU_MAX_PAYLOAD;\n      builder.add8BitUIntToData(0x01);\n      available--;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add16BitUIntToData(0x3302);\n      available -= 2;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add32BitUIntToData(0x01234567);\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"0x8081828384\");\n      available -= 5;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"85868788\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromAscii(\"maman\");\n      available -= 6;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      available -= 3;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_COMBINED);\n    });\n  });\n\n  describe(\"error\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it.each([\n      [2, false, true, 0x10000n],\n      [2, true, true, 0x8000n],\n      [2, true, true, -0x8001n],\n      [4, false, true, 0x100000000n],\n      [4, true, true, 0x80000000n],\n      [4, true, true, -0x80000001n],\n      [8, false, true, 0x10000000000000000n],\n      [8, true, true, 0x8000000000000000n],\n      [8, true, true, -0x8000000000000001n],\n    ])(\n      \"serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i\",\n      (sizeInBits, signed, bigEndian, input) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it(\"error due to a string not well coded\", () => {\n      builder\n        .addHexaStringToData(\":08081828384\")\n        .addHexaStringToData(\"80818n8384\")\n        .addHexaStringToData(\"808182838z\");\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(\":08081828384\"),\n        new HexaStringEncodeError(\"80818n8384\"),\n        new HexaStringEncodeError(\"808182838z\"),\n      ]);\n    });\n\n    it(\"error due direct overflow\", () => {\n      const myarray = new Uint8Array(256).fill(0xaa, 0, 256);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(myarray.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-byte array\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder.addBufferToData(mybuffer);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char ascii\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mystring = \"a\";\n\n      builder.addAsciiStringToData(mystring);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(new TextEncoder().encode(mystring).toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char hexastring\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const firstString = \"0xB4\";\n      const secondString = \"e1\";\n\n      builder\n        .addHexaStringToData(firstString)\n        .addHexaStringToData(secondString);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError((0xb4).toString()),\n        new DataOverflowError((0xe1).toString()),\n      ]);\n    });\n\n    it(\"error due to empty values\", () => {\n      const mystring = \"\";\n\n      builder.addHexaStringToData(mystring).encodeInLVFromHexa(mystring);\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(mystring),\n        new HexaStringEncodeError(mystring),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char LV\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD - 1).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD - 1,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n\n      const firstString = \"n\";\n      const secondString = \"e1\";\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder\n        .encodeInLVFromAscii(firstString)\n        .encodeInLVFromHexa(secondString)\n        .encodeInLVFromBuffer(mybuffer);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(firstString),\n        new DataOverflowError(secondString),\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAAmC,iCAEnCC,EAAiC,yBACjCC,EAAyD,6BACzDC,EAAiC,8BAEjC,MAAMC,EAAkB,IAAI,WAAW,CAAC,CAAC,EAEnCC,EAAsB,IAAI,WAAW,CAAC,CAAI,CAAC,EAE3CC,EAAqB,IAAI,WAAW,CAAC,IAAM,IAAM,IAAM,IAAM,GAAI,CAAC,EAElEC,EAAqB,IAAI,WAAW,CAAC,IAAM,IAAM,IAAM,GAAI,CAAC,EAE5DC,EAAuB,IAAI,WAAW,CAAC,EAAM,IAAM,IAAM,GAAI,CAAC,EAE9DC,EAAwB,IAAI,WAAW,CAC3C,EAAM,IAAM,GAAM,IAAM,GAAM,GAChC,CAAC,EAEKC,EAAwB,IAAI,WAAW,CAAC,EAAM,IAAM,GAAI,CAAC,EAEzDC,EAAwB,IAAI,WAAW,CAC3C,EAAM,GAAM,EAAM,EAAM,GAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IACxE,IAAM,IAAM,IAAM,EAAM,IAAM,IAAM,IAAM,EAAM,IAAM,GAAM,IAAM,GAAM,IACxE,EAAM,IAAM,GACd,CAAC,EAEKC,EAAmB,IAAI,WAAW,CAAC,GAAG,MAAc,GAAG,EAAE,KAAK,GAAI,CAAC,CAAC,EAEpEC,EAAsB,IAAI,WAAW,CAAC,GAAG,MAAc,GAAG,EAAE,KAAK,GAAI,CAAC,CAAC,EAE7E,IAAIC,EAEJ,SAAS,mBAAoB,IAAM,CACjC,MAAMC,EAAmB,CACvBC,EACAC,EACAC,EACAC,IACG,CACH,GAAIA,EACF,OAAQD,EAAY,CAClB,IAAK,GACHJ,EAAQ,kBAAkBE,EAAKC,CAAS,EACxC,MACF,IAAK,GACHH,EAAQ,kBAAkBE,EAAKC,CAAS,EACxC,MACF,IAAK,GACHH,EAAQ,kBAAkBE,EAAKC,CAAS,EACxC,MACF,IAAK,IACHH,EAAQ,mBAAmBE,EAAKC,CAAS,EACzC,MACF,IAAK,IACHH,EAAQ,mBAAmBE,EAAKC,CAAS,EACzC,KACJ,KAEA,QAAQC,EAAY,CAClB,IAAK,GACHJ,EAAQ,mBAAmBE,EAAKC,CAAS,EACzC,MACF,IAAK,GACHH,EAAQ,mBAAmBE,EAAKC,CAAS,EACzC,MACF,IAAK,GACHH,EAAQ,mBAAmBE,EAAKC,CAAS,EACzC,MACF,IAAK,IACHH,EAAQ,oBAAoBE,EAAKC,CAAS,EAC1C,MACF,IAAK,IACHH,EAAQ,oBAAoBE,EAAKC,CAAS,EAC1C,KACJ,CAEJ,EAEA,SAAS,QAAS,IAAM,CACtB,WAAW,IAAM,CACfH,EAAU,IAAI,mBAAiB,kBAAgB,CACjD,CAAC,EAED,GAAG,4BAA6B,IAAM,CACpC,OAAOA,CAAO,EAAE,YAAY,EAC5B,OAAOA,CAAO,EAAE,eAAe,kBAAgB,CACjD,CAAC,CACH,CAAC,EAED,SAAS,SAAU,IAAM,CACvB,WAAW,IAAM,CACfA,EAAU,IAAI,mBAAiB,kBAAgB,CACjD,CAAC,EAED,GAAG,sCAAuC,IAAM,CAC9C,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQV,CAAe,CACjD,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpDU,EAAU,IAAI,mBAAiB,CAAC,EAChCA,EAAQ,kBAAkB,CAAI,EAC9B,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQT,CAAmB,EACnD,OAAOS,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,KAAK,CACN,CAAC,EAAG,GAAO,GAAM,MAAQ,MAAM,EAC/B,CAAC,EAAG,GAAO,GAAO,QAAS,MAAM,EACjC,CAAC,EAAG,GAAM,GAAM,MAAO,MAAM,EAC7B,CAAC,EAAG,GAAM,GAAM,CAAC,MAAO,MAAM,EAC9B,CAAC,EAAG,GAAM,GAAO,KAAM,MAAM,EAC7B,CAAC,EAAG,GAAM,GAAO,MAAO,MAAM,EAC9B,CAAC,EAAG,GAAO,GAAM,YAAa,UAAU,EACxC,CAAC,EAAG,GAAO,GAAO,YAAa,UAAU,EACzC,CAAC,EAAG,GAAM,GAAM,UAAW,UAAU,EACrC,CAAC,EAAG,GAAM,GAAM,WAAY,UAAU,EACtC,CAAC,EAAG,GAAM,GAAO,UAAW,UAAU,EACtC,CAAC,EAAG,GAAM,GAAO,WAAY,UAAU,EACvC,CAAC,EAAG,GAAO,GAAM,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAO,GAAO,mBAAoB,kBAAkB,EACxD,CAAC,EAAG,GAAM,GAAM,mBAAoB,kBAAkB,EACtD,CAAC,EAAG,GAAM,GAAM,CAAC,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAO,mBAAoB,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAO,CAAC,mBAAoB,kBAAkB,EACxD,CACE,GACA,GACA,GACA,oCACA,kCACF,EACA,CACE,GACA,GACA,GACA,oCACA,kCACF,EACA,CACE,GACA,GACA,GACA,oCACA,kCACF,EACA,CACE,GACA,GACA,GACA,CAAC,oCACD,kCACF,EACA,CACE,GACA,GACA,GACA,oCACA,kCACF,EACA,CACE,GACA,GACA,GACA,CAAC,oCACD,kCACF,EACA,CACE,GACA,GACA,GACA,oEACA,kEACF,EACA,CACE,GACA,GACA,GACA,oEACA,kEACF,EACA,CACE,GACA,GACA,GACA,oEACA,kEACF,EACA,CACE,GACA,GACA,GACA,CAAC,oEACD,kEACF,EACA,CACE,GACA,GACA,GACA,oEACA,kEACF,EACA,CACE,GACA,GACA,GACA,CAAC,oEACD,kEACF,CACF,CAAC,EACC,0FACA,CAACI,EAAYC,EAAQF,EAAWG,EAAOC,IAAW,CAChDP,EAAU,IAAI,mBAAiBI,CAAU,EACzCH,EAAiBK,EAAOH,EAAWC,EAAYC,CAAM,EACrD,OAAOL,EAAQ,MAAM,CAAC,EAAE,WAAQ,sBAAmBO,CAAM,CAAC,EAC1D,OAAOP,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,EAGtCA,EAAU,IAAI,mBAAiBI,EAAa,CAAC,EAC7CH,EAAiBK,EAAOH,EAAWC,EAAYC,CAAM,EACrD,OAAOL,EAAQ,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC5C,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQ,WAAW,KAAK,CAAC,CAAC,CAAC,CACrD,CACF,EAEA,GAAG,KAAK,CACN,CAAC,EAAG,GAAO,GAAM,QAAS,MAAM,EAChC,CAAC,EAAG,GAAM,GAAM,QAAS,MAAM,EAC/B,CAAC,EAAG,GAAM,GAAM,CAAC,QAAS,MAAM,EAChC,CAAC,EAAG,GAAO,GAAM,YAAa,UAAU,EACxC,CAAC,EAAG,GAAM,GAAM,YAAa,UAAU,EACvC,CAAC,EAAG,GAAM,GAAM,CAAC,YAAa,UAAU,EACxC,CAAC,EAAG,GAAO,GAAM,oBAAqB,kBAAkB,EACxD,CAAC,EAAG,GAAM,GAAM,oBAAqB,kBAAkB,EACvD,CAAC,EAAG,GAAM,GAAM,CAAC,oBAAqB,kBAAkB,EACxD,CACE,GACA,GACA,GACA,oCACA,kCACF,EACA,CACE,GACA,GACA,GACA,oCACA,kCACF,EACA,CACE,GACA,GACA,GACA,CAAC,oCACD,kCACF,EACA,CACE,GACA,GACA,GACA,oEACA,kEACF,EACA,CACE,GACA,GACA,GACA,oEACA,kEACF,EACA,CACE,GACA,GACA,GACA,CAAC,oEACD,kEACF,CACF,CAAC,EACC,6FACA,CAACI,EAAYC,EAAQF,EAAWG,EAAOC,IAAW,CAChDP,EAAU,IAAI,mBAAiBI,CAAU,EACzCH,EAAiBK,EAAOH,EAAWC,EAAYC,CAAM,EACrD,OAAOL,EAAQ,MAAM,CAAC,EAAE,WAAQ,sBAAmBO,CAAM,CAAC,EAC1D,OAAOP,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CACF,EAEA,GAAG,iCAAkC,IAAM,CACzCA,EAAU,IAAI,mBAAiB,CAAC,EAChCA,EAAQ,kBAAkB,cAAa,EAAK,EAC5C,OAAOA,EAAQ,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC5C,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQ,WAAW,KAAK,CAAC,CAAC,CAAC,CACrD,CAAC,EAED,GAAG,0DAA2D,IAAM,CAClEA,EAAQ,oBAAoB,cAAc,EAC1C,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQR,CAAkB,EAClD,OAAOQ,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,uEAAwE,IAAM,CAC/EA,EAAQ,oBAAoB,UAAU,EACtC,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQP,CAAkB,EAClD,OAAOO,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,qEAAsE,IAAM,CAC7EA,EAAQ,mBAAmB,UAAU,EACrC,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQN,CAAoB,EACpD,OAAOM,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,uEAAwE,IAAM,CAC/EA,EAAQ,oBAAoB,OAAO,EACnC,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQL,CAAqB,EACrD,OAAOK,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,gEAAiE,IAAM,CACxE,MAAMQ,EAAU,IAAI,WAAW,CAAC,IAAM,GAAI,CAAC,EAC3CR,EAAQ,qBAAqBQ,CAAO,EACpC,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQJ,CAAqB,EACrD,OAAOI,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,gEAAiE,IAAM,CACxE,MAAMQ,EAAU,IAAI,WAAW,CAAC,IAAM,GAAI,CAAC,EAC3CR,EAAQ,qBAAqBQ,CAAO,EACpC,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQJ,CAAqB,EACrD,OAAOI,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,EAED,GAAG,iDAAkD,IAAM,CACzD,MAAMQ,EAAU,IAAI,WAAW,GAAG,EAAE,KAAK,IAAM,EAAG,GAAG,EACrDR,EAAQ,gBAAgBQ,CAAO,EAC/B,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC,CACxC,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,WAAW,IAAM,CACfA,EAAU,IAAI,mBAAiB,kBAAgB,CACjD,CAAC,EAED,GAAG,2CAA4C,IAAM,CACnD,IAAIS,EAAY,mBAChBT,EAAQ,kBAAkB,CAAI,EAC9BS,IACA,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1DT,EAAQ,mBAAmB,KAAM,EACjCS,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1DT,EAAQ,mBAAmB,QAAU,EACrCS,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1DT,EAAQ,oBAAoB,cAAc,EAC1CS,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1DT,EAAQ,oBAAoB,UAAU,EACtCS,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1DT,EAAQ,mBAAmB,UAAU,EACrCS,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1DT,EAAQ,oBAAoB,OAAO,EACnCS,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1D,MAAMD,EAAU,IAAI,WAAW,CAAC,IAAM,GAAI,CAAC,EAC3CR,EAAQ,qBAAqBQ,CAAO,EACpCC,GAAa,EACb,OAAOT,EAAQ,0BAA0B,CAAC,EAAE,KAAKS,CAAS,EAE1D,OAAOT,EAAQ,MAAM,CAAC,EAAE,QAAQH,CAAqB,CACvD,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,WAAW,IAAM,CACfG,EAAU,IAAI,mBAAiB,kBAAgB,CACjD,CAAC,EAED,GAAG,KAAK,CACN,CAAC,EAAG,GAAO,GAAM,QAAQ,EACzB,CAAC,EAAG,GAAM,GAAM,OAAO,EACvB,CAAC,EAAG,GAAM,GAAM,CAAC,OAAO,EACxB,CAAC,EAAG,GAAO,GAAM,YAAY,EAC7B,CAAC,EAAG,GAAM,GAAM,WAAW,EAC3B,CAAC,EAAG,GAAM,GAAM,CAAC,WAAW,EAC5B,CAAC,EAAG,GAAO,GAAM,oBAAoB,EACrC,CAAC,EAAG,GAAM,GAAM,mBAAmB,EACnC,CAAC,EAAG,GAAM,GAAM,CAAC,mBAAmB,CACtC,CAAC,EACC,8EACA,CAACI,EAAYC,EAAQF,EAAWG,IAAU,CACxCN,EAAU,IAAI,mBAAiBI,CAAU,EACzCH,EAAiBK,EAAOH,EAAWC,EAAYC,CAAM,EACrD,OAAOL,EAAQ,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC5C,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQ,WAAW,KAAK,CAAC,CAAC,CAAC,CACrD,CACF,EAEA,GAAG,uCAAwC,IAAM,CAC/CA,EACG,oBAAoB,cAAc,EAClC,oBAAoB,YAAY,EAChC,oBAAoB,YAAY,EAEnC,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQV,CAAe,EAC/C,OAAOU,EAAQ,0BAA0B,CAAC,EAAE,KAAK,kBAAgB,EACjE,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,wBAAsB,cAAc,EACxC,IAAI,wBAAsB,YAAY,EACtC,IAAI,wBAAsB,YAAY,CACxC,CAAC,CACH,CAAC,EAED,GAAG,4BAA6B,IAAM,CACpC,MAAMQ,EAAU,IAAI,WAAW,GAAG,EAAE,KAAK,IAAM,EAAG,GAAG,EACrDR,EAAQ,gBAAgBQ,CAAO,EAC/B,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQV,CAAe,EAC/C,OAAOU,EAAQ,0BAA0B,CAAC,EAAE,KAAK,kBAAgB,EACjE,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,oBAAkBQ,EAAQ,SAAS,CAAC,CAC1C,CAAC,CACH,CAAC,EAED,GAAG,qDAAsD,IAAM,CAC7D,MAAMA,EAAU,IAAI,WAAW,kBAAgB,EAAE,KAC/C,IACA,EACA,kBACF,EACAR,EAAQ,gBAAgBQ,CAAO,EAC/B,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAElD,MAAMU,EAAW,IAAI,WAAW,CAAC,EACjCA,EAAS,IAAI,CAAC,GAAI,EAAG,CAAC,EAEtBV,EAAQ,gBAAgBU,CAAQ,EAChC,OAAOV,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAClD,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,oBAAkBU,EAAS,SAAS,CAAC,CAC3C,CAAC,CACH,CAAC,EAED,GAAG,qDAAsD,IAAM,CAC7D,MAAMF,EAAU,IAAI,WAAW,kBAAgB,EAAE,KAC/C,IACA,EACA,kBACF,EACAR,EAAQ,gBAAgBQ,CAAO,EAC/B,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAElD,MAAMW,EAAW,IAEjBX,EAAQ,qBAAqBW,CAAQ,EACrC,OAAOX,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAClD,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,oBAAkB,IAAI,YAAY,EAAE,OAAOW,CAAQ,EAAE,SAAS,CAAC,CACrE,CAAC,CACH,CAAC,EAED,GAAG,0DAA2D,IAAM,CAClE,MAAMH,EAAU,IAAI,WAAW,kBAAgB,EAAE,KAC/C,IACA,EACA,kBACF,EACAR,EAAQ,gBAAgBQ,CAAO,EAC/B,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAKlDA,EACG,oBAJiB,MAIc,EAC/B,oBAJkB,IAIc,EAEnC,OAAOA,EAAQ,MAAM,CAAC,EAAE,QAAQF,CAAgB,EAChD,OAAOE,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAClD,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,oBAAmB,KAAgB,EACvC,IAAI,oBAAmB,KAAgB,CACzC,CAAC,CACH,CAAC,EAED,GAAG,4BAA6B,IAAM,CACpC,MAAMW,EAAW,GAEjBX,EAAQ,oBAAoBW,CAAQ,EAAE,mBAAmBA,CAAQ,EAEjE,OAAOX,EAAQ,MAAM,CAAC,EAAE,QAAQV,CAAe,EAC/C,OAAOU,EAAQ,0BAA0B,CAAC,EAAE,KAAK,kBAAgB,EACjE,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,wBAAsBW,CAAQ,EAClC,IAAI,wBAAsBA,CAAQ,CACpC,CAAC,CACH,CAAC,EAED,GAAG,kDAAmD,IAAM,CAC1D,MAAMH,EAAU,IAAI,WAAW,mBAAmB,CAAC,EAAE,KACnD,IACA,EACA,mBAAmB,CACrB,EACAR,EAAQ,gBAAgBQ,CAAO,EAC/B,OAAOR,EAAQ,MAAM,CAAC,EAAE,QAAQD,CAAmB,EACnD,OAAOC,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAElD,MAAMY,EAAc,IACdC,EAAe,KACfH,EAAW,IAAI,WAAW,CAAC,EACjCA,EAAS,IAAI,CAAC,GAAI,EAAG,CAAC,EAEtBV,EACG,oBAAoBY,CAAW,EAC/B,mBAAmBC,CAAY,EAC/B,qBAAqBH,CAAQ,EAEhC,OAAOV,EAAQ,MAAM,CAAC,EAAE,QAAQD,CAAmB,EACnD,OAAOC,EAAQ,0BAA0B,CAAC,EAAE,KAAK,CAAC,EAClD,OAAOA,EAAQ,UAAU,CAAC,EAAE,QAAQ,CAClC,IAAI,oBAAkBY,CAAW,EACjC,IAAI,oBAAkBC,CAAY,EAClC,IAAI,oBAAkBH,EAAS,SAAS,CAAC,CAC3C,CAAC,CACH,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\nimport { DataOverflowError, HexaStringEncodeError } from \"./AppBuilderError\";\nimport { ByteArrayBuilder } from \"./ByteArrayBuilder\";\n\nconst COMMAND_NO_BODY = new Uint8Array([]);\n\nconst COMMAND_BODY_SINGLE = new Uint8Array([0x01]);\n\nconst COMMAND_BODY_HEXA1 = new Uint8Array([0x80, 0x81, 0x82, 0x83, 0x84]);\n\nconst COMMAND_BODY_HEXA2 = new Uint8Array([0x85, 0x86, 0x87, 0x88]);\n\nconst COMMAND_BODY_LV_HEXA = new Uint8Array([0x03, 0xa1, 0xa2, 0xa3]);\n\nconst COMMAND_BODY_LV_ASCII = new Uint8Array([\n  0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n]);\n\nconst COMMAND_BODY_LV_ARRAY = new Uint8Array([0x02, 0xf0, 0xf1]);\n\nconst COMMAND_BODY_COMBINED = new Uint8Array([\n  0x01, 0x33, 0x02, 0x01, 0x23, 0x45, 0x67, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,\n  0x86, 0x87, 0x88, 0x03, 0xa1, 0xa2, 0xa3, 0x05, 0x6d, 0x61, 0x6d, 0x61, 0x6e,\n  0x02, 0xf0, 0xf1,\n]);\n\nconst COMMAND_BODY_MAX = new Uint8Array([...Array<number>(255).fill(0xaa)]);\n\nconst COMMAND_BODY_NEARLY = new Uint8Array([...Array<number>(254).fill(0xaa)]);\n\nlet builder: ByteArrayBuilder;\n\ndescribe(\"ByteArrayBuilder\", () => {\n  const builderAddNumber = (\n    num: number | bigint,\n    bigEndian: boolean,\n    sizeInBits: number,\n    signed: boolean,\n  ) => {\n    if (signed) {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitIntToData(num, bigEndian);\n          break;\n      }\n    } else {\n      switch (sizeInBits) {\n        case 2:\n          builder.add16BitUIntToData(num, bigEndian);\n          break;\n        case 4:\n          builder.add32BitUIntToData(num, bigEndian);\n          break;\n        case 8:\n          builder.add64BitUIntToData(num, bigEndian);\n          break;\n        case 16:\n          builder.add128BitUIntToData(num, bigEndian);\n          break;\n        case 32:\n          builder.add256BitUIntToData(num, bigEndian);\n          break;\n      }\n    }\n  };\n\n  describe(\"clean\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should create an instance\", () => {\n      expect(builder).toBeDefined();\n      expect(builder).toBeInstanceOf(ByteArrayBuilder);\n    });\n  });\n\n  describe(\"simple\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with an empty body\", () => {\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n    });\n\n    it(\"should serialize with an single byte body\", () => {\n      builder = new ByteArrayBuilder(1);\n      builder.add8BitUIntToData(0x01);\n      expect(builder.build()).toEqual(COMMAND_BODY_SINGLE);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it.each([\n      [2, false, true, 0x3302, \"3302\"],\n      [2, false, false, 0x3302n, \"0233\"],\n      [2, true, true, 4200n, \"1068\"],\n      [2, true, true, -4200n, \"ef98\"],\n      [2, true, false, 4200, \"6810\"],\n      [2, true, false, -4200, \"98ef\"],\n      [4, false, true, 0x01234567n, \"01234567\"],\n      [4, false, false, 0x01234567n, \"67452301\"],\n      [4, true, true, 123456789, \"075bcd15\"],\n      [4, true, true, -123456789, \"f8a432eb\"],\n      [4, true, false, 123456789, \"15cd5b07\"],\n      [4, true, false, -123456789, \"eb32a4f8\"],\n      [8, false, true, 14147778004927559n, \"0032435442584447\"],\n      [8, false, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, true, 14147778004927559n, \"0032435442584447\"],\n      [8, true, true, -14147778004927559n, \"ffcdbcabbda7bbb9\"],\n      [8, true, false, 14147778004927559n, \"4744584254433200\"],\n      [8, true, false, -14147778004927559n, \"b9bba7bdabbccdff\"],\n      [\n        16,\n        false,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        false,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x00324354425844470032435442584447n,\n        \"00324354425844470032435442584447\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x00324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        16,\n        true,\n        false,\n        0x00324354425844470032435442584447n,\n        \"47445842544332004744584254433200\",\n      ],\n      [\n        16,\n        true,\n        false,\n        -0x00324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        false,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"0032435442584447003243544258444700324354425844470032435442584447\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9\",\n      ],\n      [\n        32,\n        true,\n        false,\n        0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"4744584254433200474458425443320047445842544332004744584254433200\",\n      ],\n      [\n        32,\n        true,\n        false,\n        -0x0032435442584447003243544258444700324354425844470032435442584447n,\n        \"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff\",\n      ],\n    ])(\n      \"serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n\n        // Retry with a buffer too small\n        builder = new ByteArrayBuilder(sizeInBits - 1);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it.each([\n      [2, false, true, 0xffffn, \"ffff\"],\n      [2, true, true, 0x7fffn, \"7fff\"],\n      [2, true, true, -0x8000n, \"8000\"],\n      [4, false, true, 0xffffffffn, \"ffffffff\"],\n      [4, true, true, 0x7fffffffn, \"7fffffff\"],\n      [4, true, true, -0x80000000n, \"80000000\"],\n      [8, false, true, 0xffffffffffffffffn, \"ffffffffffffffff\"],\n      [8, true, true, 0x7fffffffffffffffn, \"7fffffffffffffff\"],\n      [8, true, true, -0x8000000000000000n, \"8000000000000000\"],\n      [\n        16,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffff\",\n      ],\n      [\n        16,\n        true,\n        true,\n        -0x80000000000000000000000000000000n,\n        \"80000000000000000000000000000000\",\n      ],\n      [\n        32,\n        false,\n        true,\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,\n        \"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\",\n      ],\n      [\n        32,\n        true,\n        true,\n        -0x8000000000000000000000000000000000000000000000000000000000000000n,\n        \"8000000000000000000000000000000000000000000000000000000000000000\",\n      ],\n    ])(\n      \"serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s\",\n      (sizeInBits, signed, bigEndian, input, output) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.build()).toEqual(hexaStringToBuffer(output));\n        expect(builder.getErrors()).toEqual([]);\n      },\n    );\n\n    it(\"Serialize from float to bigint\", () => {\n      builder = new ByteArrayBuilder(4);\n      builder.add32BitIntToData(123456789.3, false);\n      expect(builder.getErrors().length).toEqual(1);\n      expect(builder.build()).toEqual(Uint8Array.from([]));\n    });\n\n    it(\"should serialize with an 5 byte body from an hexastring\", () => {\n      builder.addHexaStringToData(\"0x8081828384\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA1);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body from an hexastring without '0x'\", () => {\n      builder.addHexaStringToData(\"85868788\");\n      expect(builder.build()).toEqual(COMMAND_BODY_HEXA2);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an hexastring\", () => {\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_HEXA);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from an ascci string\", () => {\n      builder.encodeInLVFromAscii(\"maman\");\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ASCII);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an 4 byte body LV encoded from a buffer\", () => {\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_LV_ARRAY);\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an ascii string\", () => {\n      builder.encodeInTLVFromAscii(0x05, \"coucou\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x06, 0x63, 0x6f, 0x75, 0x63, 0x6f, 0x75]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an hexastring\", () => {\n      builder.encodeInTLVFromHexa(0x05, \"0xA1A2A3\");\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x05, 0x03, 0xa1, 0xa2, 0xa3]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from a buffer\", () => {\n      builder.encodeInTLVFromBuffer(\n        0x06,\n        Uint8Array.from([0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0xa1, 0xa2, 0xa3, 0xa4]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint8\", () => {\n      builder.encodeInTLVFromUInt8(0x06, 0x56);\n      expect(builder.build()).toEqual(Uint8Array.from([0x06, 0x01, 0x56]));\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint16\", () => {\n      builder.encodeInTLVFromUInt16(0x06, 0x3456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x02, 0x34, 0x56]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint32\", () => {\n      builder.encodeInTLVFromUInt32(0x06, 0x90123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([0x06, 0x04, 0x90, 0x12, 0x34, 0x56]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an TLV encoded from an uint64\", () => {\n      builder.encodeInTLVFromUInt64(0x06, 0x567890123456);\n      expect(builder.build()).toEqual(\n        Uint8Array.from([\n          0x06, 0x08, 0x00, 0x00, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56,\n        ]),\n      );\n      expect(builder.getErrors()).toEqual([]);\n    });\n\n    it(\"should serialize with an complete body of 0xAA\", () => {\n      const myarray = new Uint8Array(255).fill(0xaa, 0, 255);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getErrors()).toEqual([]);\n    });\n  });\n\n  describe(\"mixed\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it(\"should serialize with all previous field\", () => {\n      let available = APDU_MAX_PAYLOAD;\n      builder.add8BitUIntToData(0x01);\n      available--;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add16BitUIntToData(0x3302);\n      available -= 2;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.add32BitUIntToData(0x01234567);\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"0x8081828384\");\n      available -= 5;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.addHexaStringToData(\"85868788\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromHexa(\"0xA1A2A3\");\n      available -= 4;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      builder.encodeInLVFromAscii(\"maman\");\n      available -= 6;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      const myarray = new Uint8Array([0xf0, 0xf1]);\n      builder.encodeInLVFromBuffer(myarray);\n      available -= 3;\n      expect(builder.getAvailablePayloadLength()).toBe(available);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_COMBINED);\n    });\n  });\n\n  describe(\"error\", () => {\n    beforeEach(() => {\n      builder = new ByteArrayBuilder(APDU_MAX_PAYLOAD);\n    });\n\n    it.each([\n      [2, false, true, 0x10000n],\n      [2, true, true, 0x8000n],\n      [2, true, true, -0x8001n],\n      [4, false, true, 0x100000000n],\n      [4, true, true, 0x80000000n],\n      [4, true, true, -0x80000001n],\n      [8, false, true, 0x10000000000000000n],\n      [8, true, true, 0x8000000000000000n],\n      [8, true, true, -0x8000000000000001n],\n    ])(\n      \"serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i\",\n      (sizeInBits, signed, bigEndian, input) => {\n        builder = new ByteArrayBuilder(sizeInBits);\n        builderAddNumber(input, bigEndian, sizeInBits, signed);\n        expect(builder.getErrors().length).toEqual(1);\n        expect(builder.build()).toEqual(Uint8Array.from([]));\n      },\n    );\n\n    it(\"error due to a string not well coded\", () => {\n      builder\n        .addHexaStringToData(\":08081828384\")\n        .addHexaStringToData(\"80818n8384\")\n        .addHexaStringToData(\"808182838z\");\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(\":08081828384\"),\n        new HexaStringEncodeError(\"80818n8384\"),\n        new HexaStringEncodeError(\"808182838z\"),\n      ]);\n    });\n\n    it(\"error due direct overflow\", () => {\n      const myarray = new Uint8Array(256).fill(0xaa, 0, 256);\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(myarray.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-byte array\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder.addBufferToData(mybuffer);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char ascii\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const mystring = \"a\";\n\n      builder.addAsciiStringToData(mystring);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(new TextEncoder().encode(mystring).toString()),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char hexastring\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n\n      const firstString = \"0xB4\";\n      const secondString = \"e1\";\n\n      builder\n        .addHexaStringToData(firstString)\n        .addHexaStringToData(secondString);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_MAX);\n      expect(builder.getAvailablePayloadLength()).toBe(0);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError((0xb4).toString()),\n        new DataOverflowError((0xe1).toString()),\n      ]);\n    });\n\n    it(\"error due to empty values\", () => {\n      const mystring = \"\";\n\n      builder.addHexaStringToData(mystring).encodeInLVFromHexa(mystring);\n\n      expect(builder.build()).toEqual(COMMAND_NO_BODY);\n      expect(builder.getAvailablePayloadLength()).toBe(APDU_MAX_PAYLOAD);\n      expect(builder.getErrors()).toEqual([\n        new HexaStringEncodeError(mystring),\n        new HexaStringEncodeError(mystring),\n      ]);\n    });\n\n    it(\"error due to subsequent overflow with 1-char LV\", () => {\n      const myarray = new Uint8Array(APDU_MAX_PAYLOAD - 1).fill(\n        0xaa,\n        0,\n        APDU_MAX_PAYLOAD - 1,\n      );\n      builder.addBufferToData(myarray);\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n\n      const firstString = \"n\";\n      const secondString = \"e1\";\n      const mybuffer = new Uint8Array(1);\n      mybuffer.set([0xff], 0);\n\n      builder\n        .encodeInLVFromAscii(firstString)\n        .encodeInLVFromHexa(secondString)\n        .encodeInLVFromBuffer(mybuffer);\n\n      expect(builder.build()).toEqual(COMMAND_BODY_NEARLY);\n      expect(builder.getAvailablePayloadLength()).toBe(1);\n      expect(builder.getErrors()).toEqual([\n        new DataOverflowError(firstString),\n        new DataOverflowError(secondString),\n        new DataOverflowError(mybuffer.toString()),\n      ]);\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_HexaString", "import_ApduBuilder", "import_AppBuilderError", "import_ByteArrayBuilder", "COMMAND_NO_BODY", "COMMAND_BODY_SINGLE", "COMMAND_BODY_HEXA1", "COMMAND_BODY_HEXA2", "COMMAND_BODY_LV_HEXA", "COMMAND_BODY_LV_ASCII", "COMMAND_BODY_LV_ARRAY", "COMMAND_BODY_COMBINED", "COMMAND_BODY_MAX", "COMMAND_BODY_NEARLY", "builder", "builderAddNumber", "num", "bigEndian", "sizeInBits", "signed", "input", "output", "myarray", "available", "mybuffer", "mystring", "firstString", "secondString"]
 }

package/lib/cjs/src/api/apdu/utils/ByteArrayParser.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var x=(u,e)=>{for(var t in e)a(u,t,{get:e[t],enumerable:!0})},l=(u,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of o(e))!b.call(u,n)&&n!==t&&a(u,n,{get:()=>e[n],enumerable:!(r=s(e,n))||r.enumerable});return u};var c=u=>l(a({},"__esModule",{value:!0}),u);var g={};x(g,{ByteArrayParser:()=>h});module.exports=c(g);var f=require("../../utils/HexaString");class h{constructor(e){this.buffer=e}index=0;testMinimalLength(e){return e<=this.buffer.length-this.index}extract8BitUInt(){if(!this.outOfRange(1))return this.buffer[this.index++]}extract16BitUInt(e=!0){const t=this.extractNumber(16n,!1,e);return t===void 0?void 0:Number(t)}extract16BitInt(e=!0){const t=this.extractNumber(16n,!0,e);return t===void 0?void 0:Number(t)}extract32BitUInt(e=!0){const t=this.extractNumber(32n,!1,e);return t===void 0?void 0:Number(t)}extract32BitInt(e=!0){const t=this.extractNumber(32n,!0,e);return t===void 0?void 0:Number(t)}extract64BitUInt(e=!0){return this.extractNumber(64n,!1,e)}extract64BitInt(e=!0){return this.extractNumber(64n,!0,e)}extract128BitUInt(e=!0){return this.extractNumber(128n,!1,e)}extract128BitInt(e=!0){return this.extractNumber(128n,!0,e)}extract256BitUInt(e=!0){return this.extractNumber(256n,!1,e)}extract256BitInt(e=!0){return this.extractNumber(256n,!0,e)}extractFieldByLength(e){if(this.outOfRange(e))return;if(e===0)return new Uint8Array;const t=this.buffer.slice(this.index,this.index+e);return this.index+=e,t}extractFieldLVEncoded(){const e=this.extract8BitUInt();if(e===void 0)return;if(e===0)return new Uint8Array;const t=this.extractFieldByLength(e);return t===void 0&&this.index--,t}extractFieldTLVEncoded(){if(this.outOfRange(2))return;const e=this.extract8BitUInt(),t=this.extractFieldLVEncoded();if(e===void 0||t===void 0){this.index--;return}return{tag:e,value:t}}encodeToHexaString(e,t=!1){if(e===void 0||e.length===0)return"";const r=(0,f.bufferToHexaString)(e);return t?r:r.slice(2)}encodeToString(e){let t="",r=0;if(!e)return t;for(;r<=e.length;){const n=e[r];n&&(t+=String.fromCharCode(n)),r++}return t}getCurrentIndex(){return this.index}resetIndex(){this.index=0}getUnparsedRemainingLength(){return this.buffer.length-this.index}outOfRange(e){return this.index+e>this.buffer.length}extractNumber(e,t,r){const n=Number(e)/8;if(this.outOfRange(n))return;let d=0n;if(r)for(let i=0;i<n;i++)d=d<<8n|BigInt(this.buffer[i+this.index]);else for(let i=n-1;i>=0;i--)d=d<<8n|BigInt(this.buffer[i+this.index]);if(t){const i=1n<<e-1n;d&i&&(d-=i<<1n)}return this.index+=n,d}}0&&(module.exports={ByteArrayParser});
+"use strict";var a=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var x=(u,e)=>{for(var t in e)a(u,t,{get:e[t],enumerable:!0})},l=(u,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of o(e))!b.call(u,n)&&n!==t&&a(u,n,{get:()=>e[n],enumerable:!(r=s(e,n))||r.enumerable});return u};var c=u=>l(a({},"__esModule",{value:!0}),u);var g={};x(g,{ByteArrayParser:()=>h});module.exports=c(g);var f=require("../../utils/HexaString");class h{constructor(e){this.buffer=e}index=0;testMinimalLength(e){return e<=this.buffer.length-this.index}extract8BitUInt(){if(!this.outOfRange(1))return this.buffer[this.index++]}extract16BitUInt(e=!0){const t=this.extractNumber(16n,!1,e);return t===void 0?void 0:Number(t)}extract16BitInt(e=!0){const t=this.extractNumber(16n,!0,e);return t===void 0?void 0:Number(t)}extract32BitUInt(e=!0){const t=this.extractNumber(32n,!1,e);return t===void 0?void 0:Number(t)}extract32BitInt(e=!0){const t=this.extractNumber(32n,!0,e);return t===void 0?void 0:Number(t)}extract64BitUInt(e=!0){return this.extractNumber(64n,!1,e)}extract64BitInt(e=!0){return this.extractNumber(64n,!0,e)}extract128BitUInt(e=!0){return this.extractNumber(128n,!1,e)}extract128BitInt(e=!0){return this.extractNumber(128n,!0,e)}extract256BitUInt(e=!0){return this.extractNumber(256n,!1,e)}extract256BitInt(e=!0){return this.extractNumber(256n,!0,e)}extractFieldByLength(e){if(this.outOfRange(e))return;if(e===0)return new Uint8Array;const t=this.buffer.slice(this.index,this.index+e);return this.index+=e,t}extractFieldLVEncoded(){const e=this.extract8BitUInt();if(e===void 0)return;if(e===0)return new Uint8Array;const t=this.extractFieldByLength(e);return t===void 0&&this.index--,t}extractFieldTLVEncoded(){if(this.outOfRange(2))return;const e=this.index,t=this.extract8BitUInt(),r=this.extractFieldLVEncoded();if(t===void 0||r===void 0){this.index--;return}const n=this.index;return{tag:t,value:r,tlv:this.buffer.slice(e,n)}}encodeToHexaString(e,t=!1){if(e===void 0||e.length===0)return"";const r=(0,f.bufferToHexaString)(e);return t?r:r.slice(2)}encodeToString(e){let t="",r=0;if(!e)return t;for(;r<=e.length;){const n=e[r];n&&(t+=String.fromCharCode(n)),r++}return t}getCurrentIndex(){return this.index}resetIndex(){this.index=0}getUnparsedRemainingLength(){return this.buffer.length-this.index}outOfRange(e){return this.index+e>this.buffer.length}extractNumber(e,t,r){const n=Number(e)/8;if(this.outOfRange(n))return;let d=0n;if(r)for(let i=0;i<n;i++)d=d<<8n|BigInt(this.buffer[i+this.index]);else for(let i=n-1;i>=0;i--)d=d<<8n|BigInt(this.buffer[i+this.index]);if(t){const i=1n<<e-1n;d&i&&(d-=i<<1n)}return this.index+=n,d}}0&&(module.exports={ByteArrayParser});
 //# sourceMappingURL=ByteArrayParser.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/apdu/utils/ByteArrayParser.ts"],
-  "sourcesContent": ["import { bufferToHexaString, type HexaString } from \"@api/utils/HexaString\";\n\nexport type TaggedField = {\n  readonly tag: number;\n  readonly value: Uint8Array;\n};\n\n/**\n * ByteArrayParser is a utility class to help parse a byte array.\n *\n * It provides methods to extract fields of different types from the buffer.\n *\n * @example\n * ```\n * const parser = new ByteArrayParser(buffer);\n * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));\n * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n * ```\n */\nexport class ByteArrayParser {\n  private index: number = 0;\n\n  constructor(private readonly buffer: Uint8Array) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Test if the length is greater than the response length\n   * @param length: number\n   * @returns {boolean} - Returns false if the length is greater than the response length\n   */\n  testMinimalLength(length: number): boolean {\n    return length <= this.buffer.length - this.index;\n  }\n\n  /**\n   * Extract a single byte from the response\n   * @returns {number | undefined} - Returns the byte extracted from the response\n   */\n  extract8BitUInt(): number | undefined {\n    if (this.outOfRange(1)) return;\n    return this.buffer[this.index++];\n  }\n\n  /**\n   * Extract a 16-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response\n   */\n  extract16BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 16-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit signed integer extracted from the response\n   */\n  extract16BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response\n   */\n  extract32BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit signed integer extracted from the response\n   */\n  extract32BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 64-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit unsigned integer extracted from the response\n   */\n  extract64BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 64-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit signed integer extracted from the response\n   */\n  extract64BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit unsigned integer extracted from the response\n   */\n  extract128BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit signed integer extracted from the response\n   */\n  extract128BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit unsigned integer extracted from the response\n   */\n  extract256BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit signed integer extracted from the response\n   */\n  extract256BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, true, bigEndian);\n  }\n\n  /**\n   * Extract a field of a specified length from the response\n   * @param length: number - The length of the field to extract\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldByLength(length: number): Uint8Array | undefined {\n    if (this.outOfRange(length)) return;\n    if (length === 0) return new Uint8Array();\n    const field = this.buffer.slice(this.index, this.index + length);\n    this.index += length;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is length-value encoded\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldLVEncoded(): Uint8Array | undefined {\n    // extract Length field\n    const length = this.extract8BitUInt();\n    if (length === undefined) return;\n    else if (length === 0) return new Uint8Array();\n    const field = this.extractFieldByLength(length);\n    // if the field is inconsistent then roll back to the initial point\n    if (field === undefined) this.index--;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is tag-length-value encoded\n   * @returns {TaggedField | undefined} - Returns the field extracted from the response\n   */\n  extractFieldTLVEncoded(): TaggedField | undefined {\n    if (this.outOfRange(2)) return;\n\n    const tag = this.extract8BitUInt();\n    const value = this.extractFieldLVEncoded();\n\n    if (tag === undefined || value === undefined) {\n      this.index--;\n      return;\n    }\n    return { tag, value };\n  }\n\n  /**\n   * Encode a value to a hexadecimal string\n   * @param value {Uint8Array} - The value to encode\n   * @param prefix {boolean} - Whether to add a prefix to the encoded value\n   * @returns {string} - The encoded value as a hexadecimal string\n   */\n  encodeToHexaString(value?: Uint8Array, prefix?: false): string;\n  encodeToHexaString(value?: Uint8Array, prefix?: true): HexaString;\n  encodeToHexaString(\n    value?: Uint8Array,\n    prefix: boolean = false,\n  ): HexaString | string {\n    if (value === undefined || value.length === 0) return \"\";\n    const result = bufferToHexaString(value);\n    return prefix ? result : result.slice(2);\n  }\n\n  /**\n   * Encode a value to an ASCII string\n   * @param value {Uint8Array} - The value to encode\n   * @returns {string} - The encoded value as an ASCII string\n   */\n  encodeToString(value?: Uint8Array): string {\n    let result = \"\";\n    let index = 0;\n\n    if (!value) return result;\n\n    while (index <= value.length) {\n      const item = value[index];\n      if (item) result += String.fromCharCode(item);\n      index++;\n    }\n\n    return result;\n  }\n\n  /**\n   * Get the current index of the parser\n   * @returns {number} - The current index of the parser\n   */\n  getCurrentIndex(): number {\n    return this.index;\n  }\n\n  /**\n   * Reset the index of the parser to 0\n   */\n  resetIndex() {\n    this.index = 0;\n  }\n\n  /**\n   * Get the remaining length of the response\n   * @returns {number} - The remaining length of the response\n   */\n  getUnparsedRemainingLength(): number {\n    return this.buffer.length - this.index;\n  }\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check whether the expected length is out of range\n   * @param length: number\n   * @returns {boolean} - Returns true if the expected length is out of range\n   */\n  private outOfRange(length: number): boolean {\n    return this.index + length > this.buffer.length;\n  }\n\n  /**\n   * Extract a number from the buffer\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - True is the number can be signed and converted to two's compliment\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {bigint | undefined} - Returns the number extracted from the buffer\n   */\n  private extractNumber(\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): bigint | undefined {\n    // Check the range\n    const sizeInBytes: number = Number(sizeInBits) / 8;\n    if (this.outOfRange(sizeInBytes)) return;\n\n    // Compute the number\n    let value: bigint = 0n;\n    if (bigEndian) {\n      for (let i = 0; i < sizeInBytes; i++) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    } else {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    }\n\n    // Convert the value to two's complement if it is negative\n    // https://en.wikipedia.org/wiki/Two%27s_complement\n    if (signed) {\n      const limit = 1n << (sizeInBits - 1n);\n      if (value & limit) {\n        value -= limit << 1n;\n      }\n    }\n\n    this.index += sizeInBytes;\n    return value;\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["ByteArrayParser_exports", "__export", "ByteArrayParser", "__toCommonJS", "import_HexaString", "buffer", "length", "bigEndian", "value", "field", "tag", "prefix", "result", "index", "item", "sizeInBits", "signed", "sizeInBytes", "limit"]
+  "sourcesContent": ["import { bufferToHexaString, type HexaString } from \"@api/utils/HexaString\";\n\nexport type TaggedField = {\n  readonly tag: number;\n  readonly value: Uint8Array;\n  readonly tlv: Uint8Array;\n};\n\n/**\n * ByteArrayParser is a utility class to help parse a byte array.\n *\n * It provides methods to extract fields of different types from the buffer.\n *\n * @example\n * ```\n * const parser = new ByteArrayParser(buffer);\n * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));\n * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n * ```\n */\nexport class ByteArrayParser {\n  private index: number = 0;\n\n  constructor(private readonly buffer: Uint8Array) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Test if the length is greater than the response length\n   * @param length: number\n   * @returns {boolean} - Returns false if the length is greater than the response length\n   */\n  testMinimalLength(length: number): boolean {\n    return length <= this.buffer.length - this.index;\n  }\n\n  /**\n   * Extract a single byte from the response\n   * @returns {number | undefined} - Returns the byte extracted from the response\n   */\n  extract8BitUInt(): number | undefined {\n    if (this.outOfRange(1)) return;\n    return this.buffer[this.index++];\n  }\n\n  /**\n   * Extract a 16-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response\n   */\n  extract16BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 16-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 16-bit signed integer extracted from the response\n   */\n  extract16BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(16n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response\n   */\n  extract32BitUInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, false, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 32-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 32-bit signed integer extracted from the response\n   */\n  extract32BitInt(bigEndian: boolean = true): number | undefined {\n    const value = this.extractNumber(32n, true, bigEndian);\n    return value === undefined ? undefined : Number(value);\n  }\n\n  /**\n   * Extract a 64-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit unsigned integer extracted from the response\n   */\n  extract64BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 64-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 64-bit signed integer extracted from the response\n   */\n  extract64BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(64n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit unsigned integer extracted from the response\n   */\n  extract128BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 128-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 128-bit signed integer extracted from the response\n   */\n  extract128BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(128n, true, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit unsigned integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit unsigned integer extracted from the response\n   */\n  extract256BitUInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, false, bigEndian);\n  }\n\n  /**\n   * Extract a 256-bit signed integer from the response\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {number | undefined} - Returns the 256-bit signed integer extracted from the response\n   */\n  extract256BitInt(bigEndian: boolean = true): bigint | undefined {\n    return this.extractNumber(256n, true, bigEndian);\n  }\n\n  /**\n   * Extract a field of a specified length from the response\n   * @param length: number - The length of the field to extract\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldByLength(length: number): Uint8Array | undefined {\n    if (this.outOfRange(length)) return;\n    if (length === 0) return new Uint8Array();\n    const field = this.buffer.slice(this.index, this.index + length);\n    this.index += length;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is length-value encoded\n   * @returns {Uint8Array | undefined} - Returns the field extracted from the response\n   */\n  extractFieldLVEncoded(): Uint8Array | undefined {\n    // extract Length field\n    const length = this.extract8BitUInt();\n    if (length === undefined) return;\n    else if (length === 0) return new Uint8Array();\n    const field = this.extractFieldByLength(length);\n    // if the field is inconsistent then roll back to the initial point\n    if (field === undefined) this.index--;\n    return field;\n  }\n\n  /**\n   * Extract a field from the response that is tag-length-value encoded\n   * @returns {TaggedField | undefined} - Returns the field extracted from the response\n   */\n  extractFieldTLVEncoded(): TaggedField | undefined {\n    if (this.outOfRange(2)) return;\n\n    const startIndex = this.index;\n    const tag = this.extract8BitUInt();\n    const value = this.extractFieldLVEncoded();\n\n    if (tag === undefined || value === undefined) {\n      this.index--;\n      return;\n    }\n    const endIndex = this.index;\n    return { tag, value, tlv: this.buffer.slice(startIndex, endIndex) };\n  }\n\n  /**\n   * Encode a value to a hexadecimal string\n   * @param value {Uint8Array} - The value to encode\n   * @param prefix {boolean} - Whether to add a prefix to the encoded value\n   * @returns {string} - The encoded value as a hexadecimal string\n   */\n  encodeToHexaString(value?: Uint8Array, prefix?: false): string;\n  encodeToHexaString(value?: Uint8Array, prefix?: true): HexaString;\n  encodeToHexaString(\n    value?: Uint8Array,\n    prefix: boolean = false,\n  ): HexaString | string {\n    if (value === undefined || value.length === 0) return \"\";\n    const result = bufferToHexaString(value);\n    return prefix ? result : result.slice(2);\n  }\n\n  /**\n   * Encode a value to an ASCII string\n   * @param value {Uint8Array} - The value to encode\n   * @returns {string} - The encoded value as an ASCII string\n   */\n  encodeToString(value?: Uint8Array): string {\n    let result = \"\";\n    let index = 0;\n\n    if (!value) return result;\n\n    while (index <= value.length) {\n      const item = value[index];\n      if (item) result += String.fromCharCode(item);\n      index++;\n    }\n\n    return result;\n  }\n\n  /**\n   * Get the current index of the parser\n   * @returns {number} - The current index of the parser\n   */\n  getCurrentIndex(): number {\n    return this.index;\n  }\n\n  /**\n   * Reset the index of the parser to 0\n   */\n  resetIndex() {\n    this.index = 0;\n  }\n\n  /**\n   * Get the remaining length of the response\n   * @returns {number} - The remaining length of the response\n   */\n  getUnparsedRemainingLength(): number {\n    return this.buffer.length - this.index;\n  }\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check whether the expected length is out of range\n   * @param length: number\n   * @returns {boolean} - Returns true if the expected length is out of range\n   */\n  private outOfRange(length: number): boolean {\n    return this.index + length > this.buffer.length;\n  }\n\n  /**\n   * Extract a number from the buffer\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - True is the number can be signed and converted to two's compliment\n   * @param bigEndian: boolean - True to decode in big endian, false for little endian\n   * @returns {bigint | undefined} - Returns the number extracted from the buffer\n   */\n  private extractNumber(\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): bigint | undefined {\n    // Check the range\n    const sizeInBytes: number = Number(sizeInBits) / 8;\n    if (this.outOfRange(sizeInBytes)) return;\n\n    // Compute the number\n    let value: bigint = 0n;\n    if (bigEndian) {\n      for (let i = 0; i < sizeInBytes; i++) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    } else {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        value = (value << 8n) | BigInt(this.buffer[i + this.index]!);\n      }\n    }\n\n    // Convert the value to two's complement if it is negative\n    // https://en.wikipedia.org/wiki/Two%27s_complement\n    if (signed) {\n      const limit = 1n << (sizeInBits - 1n);\n      if (value & limit) {\n        value -= limit << 1n;\n      }\n    }\n\n    this.index += sizeInBytes;\n    return value;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["ByteArrayParser_exports", "__export", "ByteArrayParser", "__toCommonJS", "import_HexaString", "buffer", "length", "bigEndian", "value", "field", "startIndex", "tag", "endIndex", "prefix", "result", "index", "item", "sizeInBits", "signed", "sizeInBytes", "limit"]
 }

package/lib/cjs/src/api/command/di/commandModule.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var d=Object.defineProperty;var C=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var c=(n,o)=>{for(var m in o)d(n,m,{get:o[m],enumerable:!0})},p=(n,o,m,a)=>{if(o&&typeof o=="object"||typeof o=="function")for(let e of u(o))!l.call(n,e)&&e!==m&&d(n,e,{get:()=>o[e],enumerable:!(a=C(o,e))||a.enumerable});return n};var f=n=>p(d({},"__esModule",{value:!0}),n);var y={};c(y,{commandModuleFactory:()=>b});module.exports=f(y);var s=require("inversify"),r=require("../../command/use-case/SendCommandUseCase"),i=require("../../../../src/di.stub"),t=require("./commandTypes");const b=({stub:n=!1}={})=>new s.ContainerModule((o,m,a,e,_,A,M)=>{o(t.commandTypes.SendCommandUseCase).to(r.SendCommandUseCase),n&&e(t.commandTypes.SendCommandUseCase).to(i.StubUseCase)});0&&(module.exports={commandModuleFactory});
+"use strict";var n=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var f=(e,o)=>{for(var m in o)n(e,m,{get:o[m],enumerable:!0})},u=(e,o,m,r)=>{if(o&&typeof o=="object"||typeof o=="function")for(let a of i(o))!p.call(e,a)&&a!==m&&n(e,a,{get:()=>o[a],enumerable:!(r=l(o,a))||r.enumerable});return e};var c=e=>u(n({},"__esModule",{value:!0}),e);var M={};f(M,{commandModuleFactory:()=>y});module.exports=c(M);var s=require("inversify"),t=require("../../command/use-case/SendCommandUseCase"),C=require("../../../../src/di.stub"),d=require("./commandTypes");const y=({stub:e=!1}={})=>new s.ContainerModule(({bind:o,rebindSync:m})=>{o(d.commandTypes.SendCommandUseCase).to(t.SendCommandUseCase),e&&m(d.commandTypes.SendCommandUseCase).to(C.StubUseCase)});0&&(module.exports={commandModuleFactory});
 //# sourceMappingURL=commandModule.js.map

package/lib/cjs/src/api/command/di/commandModule.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/di/commandModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandTypes } from \"./commandTypes\";\n\ntype CommandModuleArgs = Partial<{\n  readonly stub: boolean;\n}>;\n\nexport const commandModuleFactory = ({\n  stub = false,\n}: CommandModuleArgs = {}) =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(commandTypes.SendCommandUseCase).to(SendCommandUseCase);\n      if (stub) {\n        rebind(commandTypes.SendCommandUseCase).to(StubUseCase);\n      }\n    },\n  );\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAAmC,oDACnCC,EAA4B,6BAE5BC,EAA6B,0BAMtB,MAAML,EAAuB,CAAC,CACnC,KAAAM,EAAO,EACT,EAAuB,CAAC,IACtB,IAAI,kBACF,CACEC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAK,eAAa,kBAAkB,EAAE,GAAG,oBAAkB,EACvDD,GACFI,EAAO,eAAa,kBAAkB,EAAE,GAAG,aAAW,CAE1D,CACF",
-  "names": ["commandModule_exports", "__export", "commandModuleFactory", "__toCommonJS", "import_inversify", "import_SendCommandUseCase", "import_di", "import_commandTypes", "stub", "bind", "_unbind", "_isBound", "rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandTypes } from \"./commandTypes\";\n\ntype CommandModuleArgs = Partial<{\n  readonly stub: boolean;\n}>;\n\nexport const commandModuleFactory = ({\n  stub = false,\n}: CommandModuleArgs = {}) =>\n  new ContainerModule(({ bind, rebindSync }) => {\n    bind(commandTypes.SendCommandUseCase).to(SendCommandUseCase);\n    if (stub) {\n      rebindSync(commandTypes.SendCommandUseCase).to(StubUseCase);\n    }\n  });\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAAmC,oDACnCC,EAA4B,6BAE5BC,EAA6B,0BAMtB,MAAML,EAAuB,CAAC,CACnC,KAAAM,EAAO,EACT,EAAuB,CAAC,IACtB,IAAI,kBAAgB,CAAC,CAAE,KAAAC,EAAM,WAAAC,CAAW,IAAM,CAC5CD,EAAK,eAAa,kBAAkB,EAAE,GAAG,oBAAkB,EACvDD,GACFE,EAAW,eAAa,kBAAkB,EAAE,GAAG,aAAW,CAE9D,CAAC",
+  "names": ["commandModule_exports", "__export", "commandModuleFactory", "__toCommonJS", "import_inversify", "import_SendCommandUseCase", "import_di", "import_commandTypes", "stub", "bind", "rebindSync"]
 }

package/lib/cjs/src/api/command/di/commandModule.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var n=require("inversify"),r=require("../../command/use-case/SendCommandUseCase"),a=require("../../../internal/device-session/di/deviceSessionModule"),s=require("../../../internal/logger-publisher/di/loggerModule"),c=require("../../../../src/di.stub"),d=require("./commandModule"),m=require("./commandTypes");describe("commandModuleFactory",()=>{describe("Default",()=>{let e,o;beforeEach(()=>{o=(0,d.commandModuleFactory)(),e=new n.Container,e.load(o,(0,a.deviceSessionModuleFactory)(),(0,s.loggerModuleFactory)())}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return non-stubbed sendCommand usecase",()=>{const t=e.get(m.commandTypes.SendCommandUseCase);expect(t).toBeInstanceOf(r.SendCommandUseCase)})}),describe("Stubbed",()=>{let e,o;beforeEach(()=>{o=(0,d.commandModuleFactory)({stub:!0}),e=new n.Container,e.load(o)}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return stubbed sendCommand usecase",()=>{const t=e.get(m.commandTypes.SendCommandUseCase);expect(t).toBeInstanceOf(c.StubUseCase)})})});
+"use strict";var n=require("inversify"),r=require("../../command/use-case/SendCommandUseCase"),a=require("../../../internal/device-session/di/deviceSessionModule"),s=require("../../../internal/logger-publisher/di/loggerModule"),c=require("../../../../src/di.stub"),d=require("./commandModule"),m=require("./commandTypes");describe("commandModuleFactory",()=>{describe("Default",()=>{let e,o;beforeEach(()=>{o=(0,d.commandModuleFactory)(),e=new n.Container,e.loadSync(o,(0,a.deviceSessionModuleFactory)(),(0,s.loggerModuleFactory)())}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return non-stubbed sendCommand usecase",()=>{const t=e.get(m.commandTypes.SendCommandUseCase);expect(t).toBeInstanceOf(r.SendCommandUseCase)})}),describe("Stubbed",()=>{let e,o;beforeEach(()=>{o=(0,d.commandModuleFactory)({stub:!0}),e=new n.Container,e.loadSync(o)}),it("should return the config module",()=>{expect(o).toBeDefined()}),it("should return stubbed sendCommand usecase",()=>{const t=e.get(m.commandTypes.SendCommandUseCase);expect(t).toBeInstanceOf(c.StubUseCase)})})});
 //# sourceMappingURL=commandModule.test.js.map

package/lib/cjs/src/api/command/di/commandModule.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/di/commandModule.test.ts"],
-  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { deviceSessionModuleFactory } from \"@internal/device-session/di/deviceSessionModule\";\nimport { loggerModuleFactory } from \"@internal/logger-publisher/di/loggerModule\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandModuleFactory } from \"./commandModule\";\nimport { commandTypes } from \"./commandTypes\";\n\ndescribe(\"commandModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory();\n      container = new Container();\n      container.load(mod, deviceSessionModuleFactory(), loggerModuleFactory());\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return non-stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get<SendCommandUseCase>(\n        commandTypes.SendCommandUseCase,\n      );\n      expect(sendCommandUseCase).toBeInstanceOf(SendCommandUseCase);\n    });\n  });\n\n  describe(\"Stubbed\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory({ stub: true });\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get(commandTypes.SendCommandUseCase);\n      expect(sendCommandUseCase).toBeInstanceOf(StubUseCase);\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAmC,oDACnCC,EAA2C,2DAC3CC,EAAoC,sDACpCC,EAA4B,6BAE5BC,EAAqC,2BACrCC,EAA6B,0BAE7B,SAAS,uBAAwB,IAAM,CACrC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,wBAAqB,EAC3BD,EAAY,IAAI,YAChBA,EAAU,KAAKC,KAAK,8BAA2B,KAAG,uBAAoB,CAAC,CACzE,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,gDAAiD,IAAM,CACxD,MAAMC,EAAqBF,EAAU,IACnC,eAAa,kBACf,EACA,OAAOE,CAAkB,EAAE,eAAe,oBAAkB,CAC9D,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,IAAIF,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,wBAAqB,CAAE,KAAM,EAAK,CAAC,EACzCD,EAAY,IAAI,YAChBA,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMC,EAAqBF,EAAU,IAAI,eAAa,kBAAkB,EACxE,OAAOE,CAAkB,EAAE,eAAe,aAAW,CACvD,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { SendCommandUseCase } from \"@api/command/use-case/SendCommandUseCase\";\nimport { deviceSessionModuleFactory } from \"@internal/device-session/di/deviceSessionModule\";\nimport { loggerModuleFactory } from \"@internal/logger-publisher/di/loggerModule\";\nimport { StubUseCase } from \"@root/src/di.stub\";\n\nimport { commandModuleFactory } from \"./commandModule\";\nimport { commandTypes } from \"./commandTypes\";\n\ndescribe(\"commandModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory();\n      container = new Container();\n      container.loadSync(\n        mod,\n        deviceSessionModuleFactory(),\n        loggerModuleFactory(),\n      );\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return non-stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get<SendCommandUseCase>(\n        commandTypes.SendCommandUseCase,\n      );\n      expect(sendCommandUseCase).toBeInstanceOf(SendCommandUseCase);\n    });\n  });\n\n  describe(\"Stubbed\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof commandModuleFactory>;\n    beforeEach(() => {\n      mod = commandModuleFactory({ stub: true });\n      container = new Container();\n      container.loadSync(mod);\n    });\n\n    it(\"should return the config module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should return stubbed sendCommand usecase\", () => {\n      const sendCommandUseCase = container.get(commandTypes.SendCommandUseCase);\n      expect(sendCommandUseCase).toBeInstanceOf(StubUseCase);\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAmC,oDACnCC,EAA2C,2DAC3CC,EAAoC,sDACpCC,EAA4B,6BAE5BC,EAAqC,2BACrCC,EAA6B,0BAE7B,SAAS,uBAAwB,IAAM,CACrC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,wBAAqB,EAC3BD,EAAY,IAAI,YAChBA,EAAU,SACRC,KACA,8BAA2B,KAC3B,uBAAoB,CACtB,CACF,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,gDAAiD,IAAM,CACxD,MAAMC,EAAqBF,EAAU,IACnC,eAAa,kBACf,EACA,OAAOE,CAAkB,EAAE,eAAe,oBAAkB,CAC9D,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,IAAIF,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,wBAAqB,CAAE,KAAM,EAAK,CAAC,EACzCD,EAAY,IAAI,YAChBA,EAAU,SAASC,CAAG,CACxB,CAAC,EAED,GAAG,kCAAmC,IAAM,CAC1C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMC,EAAqBF,EAAU,IAAI,eAAa,kBAAkB,EACxE,OAAOE,CAAkB,EAAE,eAAe,aAAW,CACvD,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["import_inversify", "import_SendCommandUseCase", "import_deviceSessionModule", "import_loggerModule", "import_di", "import_commandModule", "import_commandTypes", "container", "mod", "sendCommandUseCase"]
 }

package/lib/cjs/src/api/command/os/GetCustomImageSizeCommand.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var a=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var S=Object.prototype.hasOwnProperty;var f=(r,e)=>{for(var o in e)a(r,o,{get:e[o],enumerable:!0})},z=(r,e,o,m)=>{if(e&&typeof e=="object"\|\|typeof e=="function")for(let t of I(e))!S.call(r,t)&&t!==o&&a(r,t,{get:()=>e[t],enumerable:!(m=E(e,t))\|\|m.enumerable});return r};var G=r=>z(a({},"__esModule",{value:!0}),r);var x={};f(x,{GetCustomImageSizeCommand:()=>A,GetCustomImageSizeCommandError:()=>c});module.exports=G(x);var d=require("../../apdu/utils/ApduBuilder"),i=require("../../apdu/utils/ApduParser"),p=require("../../command/Errors"),s=require("../../command/model/CommandResult"),u=require("../../command/utils/CommandErrors"),C=require("../../command/utils/CommandUtils"),g=require("../../command/utils/GlobalCommandError"),l=require("../../Error");const n={"662e":{message:"Invalid state, no background image loaded."},"662f":{message:"Invalid state, device is in recovery mode."}};class c extends l.DeviceExchangeError{constructor({message:e,errorCode:o}){super({message:e,errorCode:o,tag:"GetCustomImageSizeCommandError"})}}class A{getApdu(){const e={cla:224,ins:100,p1:0,p2:0};return new d.ApduBuilder(e).build()}parseResponse(e){const o=new i.ApduParser(e);if(!C.CommandUtils.isSuccessResponse(e)){const t=o.encodeToHexaString(e.statusCode);return(0,u.isCommandErrorCode)(t,n)?(0,s.CommandResultFactory)({error:new c({...n[t],errorCode:t})}):(0,s.CommandResultFactory)({error:g.GlobalCommandErrorHandler.handle(e)})}const m=o.extract32BitUInt();return m===void 0?(0,s.CommandResultFactory)({error:new p.InvalidStatusWordError("Didn't receive any size")}):(0,s.CommandResultFactory)({data:m})}}0&&(module.exports={GetCustomImageSizeCommand,GetCustomImageSizeCommandError});
2	+ //# sourceMappingURL=GetCustomImageSizeCommand.js.map

package/lib/cjs/src/api/command/os/GetCustomImageSizeCommand.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/GetCustomImageSizeCommand.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 { type Command } from \"@api/command/Command\";\nimport { InvalidStatusWordError } from \"@api/command/Errors\";\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 { type CommandErrorArgs, DeviceExchangeError } from \"@api/Error\";\n\nexport type GetCustomImageSizeResponse = number;\n\nexport type GetCustomImageSizeErrorCodes = \"662e\" | \"662f\";\n\nconst IMAGE_SIZE_ERRORS: CommandErrors<GetCustomImageSizeErrorCodes> = {\n  \"662e\": { message: \"Invalid state, no background image loaded.\" },\n  \"662f\": { message: \"Invalid state, device is in recovery mode.\" },\n};\n\nexport type GetCustomImageSizeCommandResult = CommandResult<\n  GetCustomImageSizeResponse,\n  GetCustomImageSizeErrorCodes\n>;\n\nexport class GetCustomImageSizeCommandError extends DeviceExchangeError<GetCustomImageSizeErrorCodes> {\n  constructor({\n    message,\n    errorCode,\n  }: CommandErrorArgs<GetCustomImageSizeErrorCodes>) {\n    super({ message, errorCode, tag: \"GetCustomImageSizeCommandError\" });\n  }\n}\n\nexport class GetCustomImageSizeCommand\n  implements\n    Command<GetCustomImageSizeResponse, void, GetCustomImageSizeErrorCodes>\n{\n  getApdu(): Apdu {\n    const apduArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x64,\n      p1: 0x00,\n      p2: 0x00,\n    };\n    return new ApduBuilder(apduArgs).build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): GetCustomImageSizeCommandResult {\n    const parser = new ApduParser(apduResponse);\n\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, IMAGE_SIZE_ERRORS)) {\n        return CommandResultFactory({\n          error: new GetCustomImageSizeCommandError({\n            ...IMAGE_SIZE_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    const size = parser.extract32BitUInt();\n    if (size === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Didn't receive any size\"),\n      });\n    }\n\n    return CommandResultFactory({\n      data: size,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,+BAAAE,EAAA,mCAAAC,IAAA,eAAAC,EAAAJ,GACA,IAAAK,EAAkD,uCAClDC,EAA2B,sCAE3BC,EAAuC,+BACvCC,EAGO,4CACPC,EAGO,4CACPC,EAA6B,2CAC7BC,EAA0C,iDAE1CC,EAA2D,sBAM3D,MAAMC,EAAiE,CACrE,OAAQ,CAAE,QAAS,4CAA6C,EAChE,OAAQ,CAAE,QAAS,4CAA6C,CAClE,EAOO,MAAMV,UAAuC,qBAAkD,CACpG,YAAY,CACV,QAAAW,EACA,UAAAC,CACF,EAAmD,CACjD,MAAM,CAAE,QAAAD,EAAS,UAAAC,EAAW,IAAK,gCAAiC,CAAC,CACrE,CACF,CAEO,MAAMb,CAGb,CACE,SAAgB,CACd,MAAMc,EAA4B,CAChC,IAAK,IACL,IAAK,IACL,GAAI,EACJ,GAAI,CACN,EACA,OAAO,IAAI,cAAYA,CAAQ,EAAE,MAAM,CACzC,CAEA,cAAcC,EAA6D,CACzE,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAE1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAMF,EAAYG,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBF,EAAWF,CAAiB,KAC1C,wBAAqB,CAC1B,MAAO,IAAIV,EAA+B,CACxC,GAAGU,EAAkBE,CAAS,EAC9B,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOE,CAAY,CACtD,CAAC,CACH,CAEA,MAAME,EAAOD,EAAO,iBAAiB,EACrC,OAAIC,IAAS,UACJ,wBAAqB,CAC1B,MAAO,IAAI,yBAAuB,yBAAyB,CAC7D,CAAC,KAGI,wBAAqB,CAC1B,KAAMA,CACR,CAAC,CACH,CACF",
+  "names": ["GetCustomImageSizeCommand_exports", "__export", "GetCustomImageSizeCommand", "GetCustomImageSizeCommandError", "__toCommonJS", "import_ApduBuilder", "import_ApduParser", "import_Errors", "import_CommandResult", "import_CommandErrors", "import_CommandUtils", "import_GlobalCommandError", "import_Error", "IMAGE_SIZE_ERRORS", "message", "errorCode", "apduArgs", "apduResponse", "parser", "size"]
+}

package/lib/cjs/src/api/command/os/GetCustomImageSizeCommand.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var n=require("../../command/Errors"),r=require("../../command/model/CommandResult"),a=require("../../command/model/CommandResult"),i=require("../../command/os/GetCustomImageSizeCommand"),o=require("../../device-session/ApduResponse");const u=new Uint8Array([224,100,0,0,0]);describe("GetCustomImageSizeCommand",()=>{let t;beforeEach(()=>{t=new i.GetCustomImageSizeCommand}),it("should return the correct APDU",()=>{const e=t.getApdu();expect(e.getRawApdu()).toStrictEqual(u)}),it("should parse result successfully",()=>{const e=new o.ApduResponse({statusCode:new Uint8Array([144,0]),data:new Uint8Array([0,0,137,233])}),s=t.parseResponse(e);expect(s).toStrictEqual((0,r.CommandResultFactory)({data:35305}))}),it("should fail on invalid size",()=>{const e=new o.ApduResponse({statusCode:new Uint8Array([144,0]),data:new Uint8Array([233])}),s=t.parseResponse(e);expect(s).toStrictEqual((0,r.CommandResultFactory)({error:new n.InvalidStatusWordError("Didn't receive any size")}))}),it("should fail on device error",()=>{const e=new o.ApduResponse({statusCode:new Uint8Array([102,46]),data:new Uint8Array([])}),s=t.parseResponse(e);expect((0,a.isSuccessCommandResult)(s)).toBeFalsy()})});
2	+ //# sourceMappingURL=GetCustomImageSizeCommand.test.js.map

package/lib/cjs/src/api/command/os/GetCustomImageSizeCommand.test.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/GetCustomImageSizeCommand.test.ts"],
+  "sourcesContent": ["import { InvalidStatusWordError } from \"@api/command/Errors\";\nimport { CommandResultFactory } from \"@api/command/model/CommandResult\";\nimport { isSuccessCommandResult } from \"@api/command/model/CommandResult\";\nimport { GetCustomImageSizeCommand } from \"@api/command/os/GetCustomImageSizeCommand\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nconst IMAGE_SIZE_APDU = new Uint8Array([0xe0, 0x64, 0x00, 0x00, 0x00]);\n\ndescribe(\"GetCustomImageSizeCommand\", () => {\n  let command: GetCustomImageSizeCommand;\n\n  beforeEach(() => {\n    command = new GetCustomImageSizeCommand();\n  });\n\n  it(\"should return the correct APDU\", () => {\n    const apdu = command.getApdu();\n    expect(apdu.getRawApdu()).toStrictEqual(IMAGE_SIZE_APDU);\n  });\n\n  it(\"should parse result successfully\", () => {\n    const response: ApduResponse = new ApduResponse({\n      statusCode: new Uint8Array([0x90, 0x00]),\n      data: new Uint8Array([0x00, 0x00, 0x89, 0xe9]),\n    });\n    const result = command.parseResponse(response);\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        data: 35305,\n      }),\n    );\n  });\n\n  it(\"should fail on invalid size\", () => {\n    const response: ApduResponse = new ApduResponse({\n      statusCode: new Uint8Array([0x90, 0x00]),\n      data: new Uint8Array([0xe9]),\n    });\n    const result = command.parseResponse(response);\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"Didn't receive any size\"),\n      }),\n    );\n  });\n\n  it(\"should fail on device error\", () => {\n    const response: ApduResponse = new ApduResponse({\n      statusCode: new Uint8Array([0x66, 0x2e]),\n      data: new Uint8Array([]),\n    });\n    const result = command.parseResponse(response);\n    expect(isSuccessCommandResult(result)).toBeFalsy();\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAAuC,+BACvCC,EAAqC,4CACrCA,EAAuC,4CACvCC,EAA0C,qDAC1CC,EAA6B,4CAE7B,MAAMC,EAAkB,IAAI,WAAW,CAAC,IAAM,IAAM,EAAM,EAAM,CAAI,CAAC,EAErE,SAAS,4BAA6B,IAAM,CAC1C,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAU,IAAI,2BAChB,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzC,MAAMC,EAAOD,EAAQ,QAAQ,EAC7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cAAcF,CAAe,CACzD,CAAC,EAED,GAAG,mCAAoC,IAAM,CAC3C,MAAMG,EAAyB,IAAI,eAAa,CAC9C,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,EAAM,EAAM,IAAM,GAAI,CAAC,CAC/C,CAAC,EACKC,EAASH,EAAQ,cAAcE,CAAQ,EAC7C,OAAOC,CAAM,EAAE,iBACb,wBAAqB,CACnB,KAAM,KACR,CAAC,CACH,CACF,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,MAAMD,EAAyB,IAAI,eAAa,CAC9C,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,GAAI,CAAC,CAC7B,CAAC,EACKC,EAASH,EAAQ,cAAcE,CAAQ,EAC7C,OAAOC,CAAM,EAAE,iBACb,wBAAqB,CACnB,MAAO,IAAI,yBAAuB,yBAAyB,CAC7D,CAAC,CACH,CACF,CAAC,EAED,GAAG,8BAA+B,IAAM,CACtC,MAAMD,EAAyB,IAAI,eAAa,CAC9C,WAAY,IAAI,WAAW,CAAC,IAAM,EAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EACKC,EAASH,EAAQ,cAAcE,CAAQ,EAC7C,UAAO,0BAAuBC,CAAM,CAAC,EAAE,UAAU,CACnD,CAAC,CACH,CAAC",
+  "names": ["import_Errors", "import_CommandResult", "import_GetCustomImageSizeCommand", "import_ApduResponse", "IMAGE_SIZE_APDU", "command", "apdu", "response", "result"]
+}

package/lib/cjs/src/api/command/os/GetOsVersionCommand.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var s=Object.defineProperty;var F=Object.getOwnPropertyDescriptor;var E=Object.getOwnPropertyNames;var I=Object.prototype.hasOwnProperty;var C=(o,r)=>{for(var n in r)s(o,n,{get:r[n],enumerable:!0})},O=(o,r,n,e)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of E(r))!I.call(o,t)&&t!==n&&s(o,t,{get:()=>r[t],enumerable:!(e=F(r,t))||e.enumerable});return o};var R=o=>O(s({},"__esModule",{value:!0}),o);var v={};C(v,{GetOsVersionCommand:()=>G});module.exports=R(v);var l=require("../../apdu/utils/ApduBuilder"),c=require("../../apdu/utils/ApduParser"),d=require("../../command/model/CommandResult"),p=require("../../command/utils/CommandUtils"),g=require("../../command/utils/GlobalCommandError"),u=require("../../device/DeviceModel"),y=require("./SecureElementFlagsParser");class G{args=void 0;getApdu(){const r={cla:224,ins:1,p1:0,p2:0};return new l.ApduBuilder(r).build()}parseResponse(r,n){if(!p.CommandUtils.isSuccessResponse(r))return(0,d.CommandResultFactory)({error:g.GlobalCommandErrorHandler.handle(r)});const e=new c.ApduParser(r),t=parseInt(e.encodeToHexaString(e.extractFieldByLength(4)),16),V=e.encodeToString(e.extractFieldLVEncoded()),a=e.extractFieldLVEncoded()??new Uint8Array(0),x={...new y.SecureElementFlagsParser(a).generalDeviceState()},S=e.encodeToString(e.extractFieldLVEncoded()),f=e.encodeToString(e.extractFieldLVEncoded());let i="00";n===u.DeviceModelId.NANO_X&&(i=e.encodeToHexaString(e.extractFieldLVEncoded()));const A=e.encodeToHexaString(e.extractFieldLVEncoded()),m=e.encodeToHexaString(e.extractFieldLVEncoded());return(0,d.CommandResultFactory)({data:{targetId:t,seVersion:V,seFlags:a,mcuSephVersion:S,mcuBootloaderVersion:f,hwVersion:i,langId:A,recoverState:m||"0",secureElementFlags:x}})}}0&&(module.exports={GetOsVersionCommand});
+"use strict";var g=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var B=Object.prototype.hasOwnProperty;var L=(d,r)=>{for(var n in r)g(d,n,{get:r[n],enumerable:!0})},R=(d,r,n,e)=>{if(r&&typeof r=="object"||typeof r=="function")for(let s of T(r))!B.call(d,s)&&s!==n&&g(d,s,{get:()=>r[s],enumerable:!(e=w(r,s))||e.enumerable});return d};var D=d=>R(g({},"__esModule",{value:!0}),d);var G={};L(G,{GetOsVersionCommand:()=>C});module.exports=D(G);var t=require("semver"),I=require("../../apdu/utils/ApduBuilder"),v=require("../../apdu/utils/ApduParser"),O=require("../../command/Errors"),c=require("../../command/model/CommandResult"),b=require("../../command/utils/CommandUtils"),F=require("../../command/utils/GlobalCommandError"),o=require("../../device/DeviceModel"),N=require("./SecureElementFlagsParser");class C{args=void 0;getApdu(){const r={cla:224,ins:1,p1:0,p2:0};return new I.ApduBuilder(r).build()}parseResponse(r,n){if(!b.CommandUtils.isSuccessResponse(r))return(0,c.CommandResultFactory)({error:F.GlobalCommandErrorHandler.handle(r)});const e=new v.ApduParser(r),s=e.extract32BitUInt();if(s===void 0)return(0,c.CommandResultFactory)({error:new O.InvalidStatusWordError("Missing target ID in OS version")});let l=e.encodeToString(e.extractFieldLVEncoded()),m=e.extractFieldLVEncoded()??new Uint8Array(0);const E={...new N.SecureElementFlagsParser(m).generalDeviceState()};l||(l="0.0.0",m=new Uint8Array);const S=(s&4026531840)!==805306368,h=l.includes("-osu");let a="",y="",p="",f="",V,u,A,x;if(S){p=l,V=s;const i=e.extractFieldLVEncoded();i&&(i.length>=5?(a=e.encodeToString(i),u=parseInt(e.encodeToHexaString(e.extractFieldLVEncoded()),16)):u=parseInt(e.encodeToHexaString(i),16))}else{if(a=l,u=s,y=e.encodeToString(e.extractFieldLVEncoded()),this.isBootloaderVersionSupported(a,n)&&(p=e.encodeToString(e.extractFieldLVEncoded())),this.isHardwareVersionSupported(a,n)?f=e.encodeToHexaString(e.extractFieldLVEncoded()):f="00",this.isLocalizationSupported(a,n)){const i=e.extractFieldLVEncoded();i!==void 0&&(A=parseInt(e.encodeToHexaString(i),16))}if(this.isRecoverSupported(a,n)){const i=e.extractFieldLVEncoded();i!==void 0&&(x=parseInt(e.encodeToHexaString(i),16))}}return(0,c.CommandResultFactory)({data:{isBootloader:S,isOsu:h,targetId:s,seTargetId:u,mcuTargetId:V,seVersion:a,seFlags:m,mcuSephVersion:y,mcuBootloaderVersion:p,hwVersion:f,langId:A,recoverState:x,secureElementFlags:E}})}isBootloaderVersionSupported(r,n){const e=(0,t.coerce)(r)??"";switch(n){case o.DeviceModelId.NANO_S:case o.DeviceModelId.NANO_X:return(0,t.gte)(e,"2.0.0");default:return!0}}isHardwareVersionSupported(r,n){const e=(0,t.coerce)(r)??"";switch(n){case o.DeviceModelId.NANO_X:return(0,t.gte)(e,"2.0.0");default:return!1}}isLocalizationSupported(r,n){const e=(0,t.coerce)(r)??"";switch(n){case o.DeviceModelId.NANO_S:return!1;case o.DeviceModelId.NANO_SP:return(0,t.gte)(e,"1.1.0");case o.DeviceModelId.NANO_X:return(0,t.gte)(e,"2.1.0");default:return!0}}isRecoverSupported(r,n){const e=(0,t.coerce)(r)??"";switch(n){case o.DeviceModelId.NANO_S:return!1;case o.DeviceModelId.NANO_SP:return(0,t.gte)(e,"1.1.2");case o.DeviceModelId.NANO_X:return(0,t.gte)(e,"2.2.3");case o.DeviceModelId.STAX:return(0,t.gte)(e,"1.4.0");case o.DeviceModelId.FLEX:return(0,t.gte)(e,"1.0.1");default:return!0}}}0&&(module.exports={GetOsVersionCommand});
 //# sourceMappingURL=GetOsVersionCommand.js.map

package/lib/cjs/src/api/command/os/GetOsVersionCommand.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/os/GetOsVersionCommand.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 { type Command } from \"@api/command/Command\";\nimport {\n  type CommandResult,\n  CommandResultFactory,\n} from \"@api/command/model/CommandResult\";\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { GlobalCommandErrorHandler } from \"@api/command/utils/GlobalCommandError\";\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport {\n  type DeviceGeneralState,\n  type EndorsementInformation,\n  type OnboardingStatus,\n  type WordsInformation,\n} from \"@api/device/SecureElementFlags\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { SecureElementFlagsParser } from \"./SecureElementFlagsParser\";\n\n/**\n * Response of the GetOsVersionCommand.\n */\nexport type GetOsVersionResponse = {\n  /**\n   * Target identifier.\n   */\n  readonly targetId: number;\n\n  /**\n   * Version of BOLOS on the secure element (SE).\n   * {@link https://developers.ledger.com/docs/device-app/architecture/bolos/hardware-architecture | Hardware Architecture}\n   */\n  readonly seVersion: string;\n\n  /**\n   * Secure element flags.\n   * Used to represent the current state of the secure element.\n   */\n  readonly seFlags: Uint8Array;\n\n  /**\n   * Version of the microcontroller unit (MCU) SEPH, which is the SE-MCU link protocol.\n   * {@link https://developers.ledger.com/docs/device-app/architecture/bolos/hardware-architecture | Hardware Architecture}\n   */\n  readonly mcuSephVersion: string;\n\n  /**\n   * Version of the MCU bootloader.\n   */\n  readonly mcuBootloaderVersion: string;\n\n  /**\n   * Hardware revision version.\n   * Only available for Ledger Nano X in which case it's \"00\" or \"01\".\n   */\n  readonly hwVersion: string;\n\n  /**\n   * Identifier of the installed language pack.\n   * Can be one of:\n   * - \"00\": English\n   * - \"01\": French\n   * - \"02\": Spanish\n   */\n  readonly langId: string; // [SHOULD] be an enum\n\n  /**\n   * State for Ledger Recover. // [SHOULD] Add more information about this field\n   */\n  readonly recoverState: string;\n\n  /**\n   * The parsed secure element flags.\n   */\n  readonly secureElementFlags: DeviceGeneralState &\n    EndorsementInformation &\n    WordsInformation &\n    OnboardingStatus;\n};\n\nexport type GetOsVersionCommandResult = CommandResult<GetOsVersionResponse>;\n\n/**\n * Command to get information about the device firmware.\n */\nexport class GetOsVersionCommand implements Command<GetOsVersionResponse> {\n  readonly args = undefined;\n\n  getApdu(): Apdu {\n    const getOsVersionApduArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x01,\n      p1: 0x00,\n      p2: 0x00,\n    };\n    return new ApduBuilder(getOsVersionApduArgs).build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n    deviceModelId: DeviceModelId,\n  ): GetOsVersionCommandResult {\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n    const parser = new ApduParser(apduResponse);\n\n    const targetId = parseInt(\n      parser.encodeToHexaString(parser.extractFieldByLength(4)),\n      16,\n    );\n    const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n    const seFlags = parser.extractFieldLVEncoded() ?? new Uint8Array(0);\n    const seFlagsParser = new SecureElementFlagsParser(seFlags);\n    // This is the parsed secure element flags.\n    const secureElementFlags = { ...seFlagsParser.generalDeviceState() };\n\n    const mcuSephVersion = parser.encodeToString(\n      parser.extractFieldLVEncoded(),\n    );\n    const mcuBootloaderVersion = parser.encodeToString(\n      parser.extractFieldLVEncoded(),\n    );\n\n    let hwVersion = \"00\";\n    if (deviceModelId === DeviceModelId.NANO_X) {\n      hwVersion = parser.encodeToHexaString(parser.extractFieldLVEncoded());\n    }\n\n    const langId = parser.encodeToHexaString(parser.extractFieldLVEncoded());\n    const recoverState = parser.encodeToHexaString(\n      parser.extractFieldLVEncoded(),\n    );\n\n    return CommandResultFactory({\n      data: {\n        targetId,\n        seVersion,\n        seFlags,\n        mcuSephVersion,\n        mcuBootloaderVersion,\n        hwVersion,\n        langId,\n        recoverState: recoverState ? recoverState : \"0\",\n        secureElementFlags,\n      },\n    });\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,IAAA,eAAAC,EAAAH,GACA,IAAAI,EAAkD,uCAClDC,EAA2B,sCAE3BC,EAGO,4CACPC,EAA6B,2CAC7BC,EAA0C,iDAC1CC,EAA8B,mCAS9BC,EAAyC,sCAoElC,MAAMR,CAA6D,CAC/D,KAAO,OAEhB,SAAgB,CACd,MAAMS,EAAwC,CAC5C,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EACA,OAAO,IAAI,cAAYA,CAAoB,EAAE,MAAM,CACrD,CAEA,cACEC,EACAC,EAC2B,CAC3B,GAAI,CAAC,eAAa,kBAAkBD,CAAY,EAC9C,SAAO,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOA,CAAY,CACtD,CAAC,EAEH,MAAME,EAAS,IAAI,aAAWF,CAAY,EAEpCG,EAAW,SACfD,EAAO,mBAAmBA,EAAO,qBAAqB,CAAC,CAAC,EACxD,EACF,EACME,EAAYF,EAAO,eAAeA,EAAO,sBAAsB,CAAC,EAChEG,EAAUH,EAAO,sBAAsB,GAAK,IAAI,WAAW,CAAC,EAG5DI,EAAqB,CAAE,GAFP,IAAI,2BAAyBD,CAAO,EAEZ,mBAAmB,CAAE,EAE7DE,EAAiBL,EAAO,eAC5BA,EAAO,sBAAsB,CAC/B,EACMM,EAAuBN,EAAO,eAClCA,EAAO,sBAAsB,CAC/B,EAEA,IAAIO,EAAY,KACZR,IAAkB,gBAAc,SAClCQ,EAAYP,EAAO,mBAAmBA,EAAO,sBAAsB,CAAC,GAGtE,MAAMQ,EAASR,EAAO,mBAAmBA,EAAO,sBAAsB,CAAC,EACjES,EAAeT,EAAO,mBAC1BA,EAAO,sBAAsB,CAC/B,EAEA,SAAO,wBAAqB,CAC1B,KAAM,CACJ,SAAAC,EACA,UAAAC,EACA,QAAAC,EACA,eAAAE,EACA,qBAAAC,EACA,UAAAC,EACA,OAAAC,EACA,aAAcC,GAA8B,IAC5C,mBAAAL,CACF,CACF,CAAC,CACH,CACF",
-  "names": ["GetOsVersionCommand_exports", "__export", "GetOsVersionCommand", "__toCommonJS", "import_ApduBuilder", "import_ApduParser", "import_CommandResult", "import_CommandUtils", "import_GlobalCommandError", "import_DeviceModel", "import_SecureElementFlagsParser", "getOsVersionApduArgs", "apduResponse", "deviceModelId", "parser", "targetId", "seVersion", "seFlags", "secureElementFlags", "mcuSephVersion", "mcuBootloaderVersion", "hwVersion", "langId", "recoverState"]
+  "sourcesContent": ["import { coerce, gte } from \"semver\";\n\nimport { type Apdu } from \"@api/apdu/model/Apdu\";\nimport { ApduBuilder, type ApduBuilderArgs } from \"@api/apdu/utils/ApduBuilder\";\nimport { ApduParser } from \"@api/apdu/utils/ApduParser\";\nimport { type Command } from \"@api/command/Command\";\nimport { InvalidStatusWordError } from \"@api/command/Errors\";\nimport {\n  type CommandResult,\n  CommandResultFactory,\n} from \"@api/command/model/CommandResult\";\nimport { CommandUtils } from \"@api/command/utils/CommandUtils\";\nimport { GlobalCommandErrorHandler } from \"@api/command/utils/GlobalCommandError\";\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport {\n  type DeviceGeneralState,\n  type EndorsementInformation,\n  type OnboardingStatus,\n  type WordsInformation,\n} from \"@api/device/SecureElementFlags\";\nimport { type ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { SecureElementFlagsParser } from \"./SecureElementFlagsParser\";\n\n/**\n * Response of the GetOsVersionCommand.\n */\nexport type GetOsVersionResponse = {\n  /**\n   * Indicated if the device is running in bootloader mode.\n   * It can happens during a firmware update process.\n   */\n  readonly isBootloader: boolean;\n\n  /**\n   * Indicated if the device firmware is an OS Updater (OSU).\n   * It can happens during a firmware update process.\n   */\n  readonly isOsu: boolean;\n\n  /**\n   * Target identifier.\n   */\n  readonly targetId: number;\n\n  /**\n   * Target identifier of the secure element.\n   * Not always available when the device is in bootloader mode.\n   */\n  readonly seTargetId: number | undefined;\n\n  /**\n   * Target identifier of the microcontroller unit (MCU).\n   * Only available when the device is in bootloader mode.\n   */\n  readonly mcuTargetId: number | undefined;\n\n  /**\n   * Version of BOLOS on the secure element (SE).\n   * {@link https://developers.ledger.com/docs/device-app/architecture/bolos/hardware-architecture | Hardware Architecture}\n   */\n  readonly seVersion: string;\n\n  /**\n   * Secure element flags.\n   * Used to represent the current state of the secure element.\n   */\n  readonly seFlags: Uint8Array;\n\n  /**\n   * Version of the microcontroller unit (MCU) SEPH, which is the SE-MCU link protocol.\n   * {@link https://developers.ledger.com/docs/device-app/architecture/bolos/hardware-architecture | Hardware Architecture}\n   */\n  readonly mcuSephVersion: string;\n\n  /**\n   * Version of the MCU bootloader.\n   */\n  readonly mcuBootloaderVersion: string;\n\n  /**\n   * Hardware revision version.\n   * Only available for Ledger Nano X in which case it's \"00\" or \"01\".\n   */\n  readonly hwVersion: string;\n\n  /**\n   * Identifier of the installed language pack.\n   * Can be one of:\n   * - \"00\": English\n   * - \"01\": French\n   * - \"02\": Spanish\n   * - \"03\": Portuguese\n   * - \"04\": German\n   * - \"05\": Russian\n   * - \"06\": Turkish\n   */\n  readonly langId: number | undefined;\n\n  /**\n   * State for Ledger Recover. // [SHOULD] Add more information about this field\n   */\n  readonly recoverState: number | undefined;\n\n  /**\n   * The parsed secure element flags.\n   */\n  readonly secureElementFlags: DeviceGeneralState &\n    EndorsementInformation &\n    WordsInformation &\n    OnboardingStatus;\n};\n\nexport type GetOsVersionCommandResult = CommandResult<GetOsVersionResponse>;\n\n/**\n * Command to get information about the device firmware.\n */\nexport class GetOsVersionCommand implements Command<GetOsVersionResponse> {\n  readonly args = undefined;\n\n  getApdu(): Apdu {\n    const getOsVersionApduArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x01,\n      p1: 0x00,\n      p2: 0x00,\n    };\n    return new ApduBuilder(getOsVersionApduArgs).build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n    deviceModelId: DeviceModelId,\n  ): GetOsVersionCommandResult {\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n    const parser = new ApduParser(apduResponse);\n    const targetId = parser.extract32BitUInt();\n    if (targetId === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Missing target ID in OS version\"),\n      });\n    }\n\n    let version = parser.encodeToString(parser.extractFieldLVEncoded());\n    let seFlags = parser.extractFieldLVEncoded() ?? new Uint8Array(0);\n    const seFlagsParser = new SecureElementFlagsParser(seFlags);\n    // This is the parsed secure element flags.\n    const secureElementFlags = { ...seFlagsParser.generalDeviceState() };\n\n    // Handle old firmwares with no version\n    if (!version) {\n      version = \"0.0.0\";\n      seFlags = new Uint8Array();\n    }\n\n    const isBootloader = (targetId & 0xf0000000) !== 0x30000000;\n    const isOsu = version.includes(\"-osu\");\n    let seVersion: string = \"\";\n    let mcuSephVersion: string = \"\";\n    let mcuBootloaderVersion: string = \"\";\n    let hwVersion: string = \"\";\n    let mcuTargetId: number | undefined = undefined;\n    let seTargetId: number | undefined = undefined;\n    let langId: number | undefined = undefined;\n    let recoverState: number | undefined = undefined;\n\n    if (isBootloader) {\n      mcuBootloaderVersion = version;\n      mcuTargetId = targetId;\n\n      const seData = parser.extractFieldLVEncoded();\n      if (seData) {\n        if (seData.length >= 5) {\n          // It means it's a version followed by the seTargetId\n          seVersion = parser.encodeToString(seData);\n          seTargetId = parseInt(\n            parser.encodeToHexaString(parser.extractFieldLVEncoded()),\n            16,\n          );\n        } else {\n          // It's the seTargetId\n          seTargetId = parseInt(parser.encodeToHexaString(seData), 16);\n        }\n      }\n    } else {\n      seVersion = version;\n      seTargetId = targetId;\n\n      mcuSephVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n\n      if (this.isBootloaderVersionSupported(seVersion, deviceModelId)) {\n        mcuBootloaderVersion = parser.encodeToString(\n          parser.extractFieldLVEncoded(),\n        );\n      }\n\n      if (this.isHardwareVersionSupported(seVersion, deviceModelId)) {\n        hwVersion = parser.encodeToHexaString(parser.extractFieldLVEncoded());\n      } else {\n        hwVersion = \"00\";\n      }\n\n      if (this.isLocalizationSupported(seVersion, deviceModelId)) {\n        const langIdBuffer = parser.extractFieldLVEncoded();\n        if (langIdBuffer !== undefined) {\n          langId = parseInt(parser.encodeToHexaString(langIdBuffer), 16);\n        }\n      }\n\n      if (this.isRecoverSupported(seVersion, deviceModelId)) {\n        const recoverStateBuffer = parser.extractFieldLVEncoded();\n        if (recoverStateBuffer !== undefined) {\n          recoverState = parseInt(\n            parser.encodeToHexaString(recoverStateBuffer),\n            16,\n          );\n        }\n      }\n    }\n\n    return CommandResultFactory({\n      data: {\n        isBootloader,\n        isOsu,\n        targetId,\n        seTargetId,\n        mcuTargetId,\n        seVersion,\n        seFlags,\n        mcuSephVersion,\n        mcuBootloaderVersion,\n        hwVersion,\n        langId,\n        recoverState,\n        secureElementFlags,\n      },\n    });\n  }\n\n  private isBootloaderVersionSupported(\n    seVersion: string,\n    deviceModelId: DeviceModelId,\n  ): boolean {\n    const version = coerce(seVersion) ?? \"\";\n    switch (deviceModelId) {\n      case DeviceModelId.NANO_S:\n      case DeviceModelId.NANO_X:\n        return gte(version, \"2.0.0\");\n      default:\n        return true;\n    }\n  }\n\n  private isHardwareVersionSupported(\n    seVersion: string,\n    deviceModelId: DeviceModelId,\n  ): boolean {\n    const version = coerce(seVersion) ?? \"\";\n    switch (deviceModelId) {\n      case DeviceModelId.NANO_X:\n        return gte(version, \"2.0.0\");\n      default:\n        return false;\n    }\n  }\n\n  private isLocalizationSupported(\n    seVersion: string,\n    deviceModelId: DeviceModelId,\n  ): boolean {\n    const version = coerce(seVersion) ?? \"\";\n    switch (deviceModelId) {\n      case DeviceModelId.NANO_S:\n        return false;\n      case DeviceModelId.NANO_SP:\n        return gte(version, \"1.1.0\");\n      case DeviceModelId.NANO_X:\n        return gte(version, \"2.1.0\");\n      default:\n        return true;\n    }\n  }\n\n  private isRecoverSupported(\n    seVersion: string,\n    deviceModelId: DeviceModelId,\n  ): boolean {\n    const version = coerce(seVersion) ?? \"\";\n    switch (deviceModelId) {\n      case DeviceModelId.NANO_S:\n        return false;\n      case DeviceModelId.NANO_SP:\n        return gte(version, \"1.1.2\");\n      case DeviceModelId.NANO_X:\n        return gte(version, \"2.2.3\");\n      case DeviceModelId.STAX:\n        return gte(version, \"1.4.0\");\n      case DeviceModelId.FLEX:\n        return gte(version, \"1.0.1\");\n      default:\n        return true;\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["GetOsVersionCommand_exports", "__export", "GetOsVersionCommand", "__toCommonJS", "import_semver", "import_ApduBuilder", "import_ApduParser", "import_Errors", "import_CommandResult", "import_CommandUtils", "import_GlobalCommandError", "import_DeviceModel", "import_SecureElementFlagsParser", "getOsVersionApduArgs", "apduResponse", "deviceModelId", "parser", "targetId", "version", "seFlags", "secureElementFlags", "isBootloader", "isOsu", "seVersion", "mcuSephVersion", "mcuBootloaderVersion", "hwVersion", "mcuTargetId", "seTargetId", "langId", "recoverState", "seData", "langIdBuffer", "recoverStateBuffer"]
 }

package/lib/cjs/src/api/command/os/GetOsVersionCommand.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var r=require("../../command/model/CommandResult"),x=require("../../device/DeviceModel"),o=require("../../device-session/ApduResponse"),n=require("./__mocks__/GetOsVersionCommand"),a=require("./GetOsVersionCommand");const d=Uint8Array.from([224,1,0,0,0]),c=Uint8Array.from([51,0,0,4,5,50,46,50,46,51,4,230,0,0,0,4,50,46,51,48,4,49,46,49,54,1,0,1,0,1,0,144,0]),p=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:c}),i=Uint8Array.from([51,16,0,4,5,49,46,49,46,49,4,230,0,0,0,4,52,46,48,51,4,51,46,49,50,1,0,1,0,144,0]),m=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:i}),S=Uint8Array.from([51,32,0,4,5,49,46,51,46,48,4,230,0,0,0,4,53,46,50,52,4,48,46,52,56,1,0,1,0,144,0]),A=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:S});describe("GetOsVersionCommand",()=>{let t;beforeEach(()=>{t=new a.GetOsVersionCommand}),describe("getApdu",()=>{it("should return the GetOsVersion apdu",()=>{const e=t.getApdu();expect(e.getRawApdu()).toStrictEqual(d)})}),describe("parseResponse",()=>{describe("Nano X",()=>{it("should parse the LNX response",()=>{const e=t.parseResponse(p,x.DeviceModelId.NANO_X),s=(0,r.CommandResultFactory)({data:(0,n.getOsVersionCommandResponseMockBuilder)(x.DeviceModelId.NANO_X)});expect(e).toStrictEqual(s)})}),describe("Nano S Plus",()=>{it("should parse the LNSP response",()=>{const e=t.parseResponse(m,x.DeviceModelId.NANO_SP),s=(0,r.CommandResultFactory)({data:(0,n.getOsVersionCommandResponseMockBuilder)(x.DeviceModelId.NANO_SP)});expect(e).toStrictEqual(s)})}),describe("Stax",()=>{it("should parse the STAX response",()=>{const e=t.parseResponse(A,x.DeviceModelId.STAX),s=(0,r.CommandResultFactory)({data:(0,n.getOsVersionCommandResponseMockBuilder)(x.DeviceModelId.STAX)});expect(e).toStrictEqual(s)})}),describe("Error handling",()=>{it("should return an error if the response is not successful",()=>{const e=new o.ApduResponse({statusCode:Uint8Array.from([110,128]),data:Uint8Array.from([])}),s=t.parseResponse(e,x.DeviceModelId.NANO_S);expect((0,r.isSuccessCommandResult)(s)).toBeFalsy()})})})});
+"use strict";var r=require("../../command/model/CommandResult"),t=require("../../device/DeviceModel"),o=require("../../device-session/ApduResponse"),a=require("./__mocks__/GetOsVersionCommand"),n=require("./GetOsVersionCommand");const d=Uint8Array.from([224,1,0,0,0]),i=Uint8Array.from([51,0,0,4,5,50,46,50,46,51,4,230,0,0,0,4,50,46,51,48,4,49,46,49,54,1,0,1,0,1,0,144,0]),c=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:i}),u=Uint8Array.from([51,16,0,4,5,49,46,49,46,49,4,230,0,0,0,4,52,46,48,51,4,51,46,49,50,1,0,1,0,144,0]),l=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:u}),p=Uint8Array.from([51,32,0,4,5,49,46,51,46,48,4,230,0,0,0,4,53,46,50,52,4,48,46,52,56,1,0,1,0,144,0]),S=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:p}),m=Uint8Array.from([5,1,0,3,4,49,46,49,54,4,244,216,170,67,5,50,46,50,46,51,4,51,0,0,4,144,0]),O=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:m}),A=Uint8Array.from([51,0,0,4,0,4,238,0,0,0,4,50,46,51,48,1,1,1,0,1,0,144,0]),f=new o.ApduResponse({statusCode:Uint8Array.from([144,0]),data:A});describe("GetOsVersionCommand",()=>{let s;beforeEach(()=>{s=new n.GetOsVersionCommand}),describe("getApdu",()=>{it("should return the GetOsVersion apdu",()=>{const e=s.getApdu();expect(e.getRawApdu()).toStrictEqual(d)})}),describe("parseResponse",()=>{describe("Nano X",()=>{it("should parse the LNX response",()=>{const e=s.parseResponse(c,t.DeviceModelId.NANO_X),x=(0,r.CommandResultFactory)({data:(0,a.getOsVersionCommandResponseMockBuilder)(t.DeviceModelId.NANO_X)});expect(e).toStrictEqual(x)})}),describe("Nano S Plus",()=>{it("should parse the LNSP response",()=>{const e=s.parseResponse(l,t.DeviceModelId.NANO_SP),x=(0,r.CommandResultFactory)({data:(0,a.getOsVersionCommandResponseMockBuilder)(t.DeviceModelId.NANO_SP)});expect(e).toStrictEqual(x)})}),describe("Stax",()=>{it("should parse the STAX response",()=>{const e=s.parseResponse(S,t.DeviceModelId.STAX),x=(0,r.CommandResultFactory)({data:(0,a.getOsVersionCommandResponseMockBuilder)(t.DeviceModelId.STAX)});expect(e).toStrictEqual(x)})}),describe("Bootloader",()=>{it("should parse the bootloader response",()=>{const e=s.parseResponse(O,t.DeviceModelId.STAX),x=(0,r.CommandResultFactory)({data:{isBootloader:!0,isOsu:!1,targetId:83951619,seTargetId:855638020,seVersion:"2.2.3",seFlags:new Uint8Array([244,216,170,67]),mcuTargetId:83951619,mcuSephVersion:"",mcuBootloaderVersion:"1.16",hwVersion:"",langId:void 0,recoverState:void 0,secureElementFlags:{isPinValidated:!0,hasMcuSerialNumber:!0,hasValidCertificate:!0,isCustomAuthorityConnectionAllowed:!0,isSecureConnectionAllowed:!1,isOnboarded:!0,isMcuCodeSigned:!1,isInRecoveryMode:!1}}});expect(e).toStrictEqual(x)})}),describe("Old firmware",()=>{it("should parse the old firmware response",()=>{const e=s.parseResponse(f,t.DeviceModelId.NANO_X),x=(0,r.CommandResultFactory)({data:{isBootloader:!1,isOsu:!1,targetId:855638020,seTargetId:855638020,seVersion:"0.0.0",seFlags:new Uint8Array,mcuTargetId:void 0,mcuSephVersion:"2.30",mcuBootloaderVersion:"",hwVersion:"00",langId:void 0,recoverState:void 0,secureElementFlags:{isPinValidated:!0,hasMcuSerialNumber:!0,hasValidCertificate:!0,isCustomAuthorityConnectionAllowed:!1,isSecureConnectionAllowed:!0,isOnboarded:!0,isMcuCodeSigned:!0,isInRecoveryMode:!1}}});expect(e).toStrictEqual(x)})}),describe("Error handling",()=>{it("should return an error if the response is not successful",()=>{const e=new o.ApduResponse({statusCode:Uint8Array.from([110,128]),data:Uint8Array.from([])}),x=s.parseResponse(e,t.DeviceModelId.NANO_S);expect((0,r.isSuccessCommandResult)(x)).toBeFalsy()})})})});
 //# sourceMappingURL=GetOsVersionCommand.test.js.map

package/lib/cjs/src/api/command/os/GetOsVersionCommand.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/api/command/os/GetOsVersionCommand.test.ts"],
-  "sourcesContent": ["import {\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@api/command/model/CommandResult\";\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { getOsVersionCommandResponseMockBuilder } from \"./__mocks__/GetOsVersionCommand\";\nimport { GetOsVersionCommand } from \"./GetOsVersionCommand\";\n\nconst GET_OS_VERSION_APDU = Uint8Array.from([0xe0, 0x01, 0x00, 0x00, 0x00]);\n\nconst LNX_RESPONSE_DATA_GOOD = Uint8Array.from([\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, 0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst LNX_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA_GOOD,\n});\n\nconst LNSP_REPONSE_DATA_GOOD = Uint8Array.from([\n  0x33, 0x10, 0x00, 0x04, 0x05, 0x31, 0x2e, 0x31, 0x2e, 0x31, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x34, 0x2e, 0x30, 0x33, 0x04, 0x33, 0x2e, 0x31, 0x32, 0x01,\n  0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst LNSP_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNSP_REPONSE_DATA_GOOD,\n});\n\nconst STAX_RESPONSE_DATA_GOOD = Uint8Array.from([\n  0x33, 0x20, 0x00, 0x04, 0x05, 0x31, 0x2e, 0x33, 0x2e, 0x30, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x35, 0x2e, 0x32, 0x34, 0x04, 0x30, 0x2e, 0x34, 0x38, 0x01,\n  0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst STAX_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: STAX_RESPONSE_DATA_GOOD,\n});\n\ndescribe(\"GetOsVersionCommand\", () => {\n  let command: GetOsVersionCommand;\n\n  beforeEach(() => {\n    command = new GetOsVersionCommand();\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return the GetOsVersion apdu\", () => {\n      const apdu = command.getApdu();\n      expect(apdu.getRawApdu()).toStrictEqual(GET_OS_VERSION_APDU);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    describe(\"Nano X\", () => {\n      it(\"should parse the LNX response\", () => {\n        const parsed = command.parseResponse(\n          LNX_RESPONSE_GOOD,\n          DeviceModelId.NANO_X,\n        );\n\n        const expected = CommandResultFactory({\n          data: getOsVersionCommandResponseMockBuilder(DeviceModelId.NANO_X),\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Nano S Plus\", () => {\n      it(\"should parse the LNSP response\", () => {\n        const parsed = command.parseResponse(\n          LNSP_RESPONSE_GOOD,\n          DeviceModelId.NANO_SP,\n        );\n\n        const expected = CommandResultFactory({\n          data: getOsVersionCommandResponseMockBuilder(DeviceModelId.NANO_SP),\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Stax\", () => {\n      it(\"should parse the STAX response\", () => {\n        const parsed = command.parseResponse(\n          STAX_RESPONSE_GOOD,\n          DeviceModelId.STAX,\n        );\n\n        const expected = CommandResultFactory({\n          data: getOsVersionCommandResponseMockBuilder(DeviceModelId.STAX),\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Error handling\", () => {\n      it(\"should return an error if the response is not successful\", () => {\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from([0x6e, 0x80]),\n          data: Uint8Array.from([]),\n        });\n        const result = command.parseResponse(response, DeviceModelId.NANO_S);\n\n        expect(isSuccessCommandResult(result)).toBeFalsy();\n      });\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["import_CommandResult", "import_DeviceModel", "import_ApduResponse", "import_GetOsVersionCommand", "GET_OS_VERSION_APDU", "LNX_RESPONSE_DATA_GOOD", "LNX_RESPONSE_GOOD", "LNSP_REPONSE_DATA_GOOD", "LNSP_RESPONSE_GOOD", "STAX_RESPONSE_DATA_GOOD", "STAX_RESPONSE_GOOD", "command", "apdu", "parsed", "expected", "response", "result"]
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@api/command/model/CommandResult\";\nimport { DeviceModelId } from \"@api/device/DeviceModel\";\nimport { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { getOsVersionCommandResponseMockBuilder } from \"./__mocks__/GetOsVersionCommand\";\nimport { GetOsVersionCommand } from \"./GetOsVersionCommand\";\n\nconst GET_OS_VERSION_APDU = Uint8Array.from([0xe0, 0x01, 0x00, 0x00, 0x00]);\n\nconst LNX_RESPONSE_DATA_GOOD = Uint8Array.from([\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, 0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst LNX_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA_GOOD,\n});\n\nconst LNSP_REPONSE_DATA_GOOD = Uint8Array.from([\n  0x33, 0x10, 0x00, 0x04, 0x05, 0x31, 0x2e, 0x31, 0x2e, 0x31, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x34, 0x2e, 0x30, 0x33, 0x04, 0x33, 0x2e, 0x31, 0x32, 0x01,\n  0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst LNSP_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNSP_REPONSE_DATA_GOOD,\n});\n\nconst STAX_RESPONSE_DATA_GOOD = Uint8Array.from([\n  0x33, 0x20, 0x00, 0x04, 0x05, 0x31, 0x2e, 0x33, 0x2e, 0x30, 0x04, 0xe6, 0x00,\n  0x00, 0x00, 0x04, 0x35, 0x2e, 0x32, 0x34, 0x04, 0x30, 0x2e, 0x34, 0x38, 0x01,\n  0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst STAX_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: STAX_RESPONSE_DATA_GOOD,\n});\n\nconst BL_RESPONSE_DATA_GOOD = Uint8Array.from([\n  0x05, 0x01, 0x00, 0x03, 0x04, 0x31, 0x2e, 0x31, 0x36, 0x04, 0xf4, 0xd8, 0xaa,\n  0x43, 0x05, 0x32, 0x2e, 0x32, 0x2e, 0x33, 0x04, 0x33, 0x00, 0x00, 0x04, 0x90,\n  0x00,\n]);\nconst BL_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: BL_RESPONSE_DATA_GOOD,\n});\n\nconst OLD_FM_RESPONSE_DATA_GOOD = Uint8Array.from([\n  0x33, 0x00, 0x00, 0x04, 0x00, 0x04, 0xee, 0x00, 0x00, 0x00, 0x04, 0x32, 0x2e,\n  0x33, 0x30, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x90, 0x00,\n]);\nconst OLD_FM_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: OLD_FM_RESPONSE_DATA_GOOD,\n});\n\ndescribe(\"GetOsVersionCommand\", () => {\n  let command: GetOsVersionCommand;\n\n  beforeEach(() => {\n    command = new GetOsVersionCommand();\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return the GetOsVersion apdu\", () => {\n      const apdu = command.getApdu();\n      expect(apdu.getRawApdu()).toStrictEqual(GET_OS_VERSION_APDU);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    describe(\"Nano X\", () => {\n      it(\"should parse the LNX response\", () => {\n        const parsed = command.parseResponse(\n          LNX_RESPONSE_GOOD,\n          DeviceModelId.NANO_X,\n        );\n\n        const expected = CommandResultFactory({\n          data: getOsVersionCommandResponseMockBuilder(DeviceModelId.NANO_X),\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Nano S Plus\", () => {\n      it(\"should parse the LNSP response\", () => {\n        const parsed = command.parseResponse(\n          LNSP_RESPONSE_GOOD,\n          DeviceModelId.NANO_SP,\n        );\n\n        const expected = CommandResultFactory({\n          data: getOsVersionCommandResponseMockBuilder(DeviceModelId.NANO_SP),\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Stax\", () => {\n      it(\"should parse the STAX response\", () => {\n        const parsed = command.parseResponse(\n          STAX_RESPONSE_GOOD,\n          DeviceModelId.STAX,\n        );\n\n        const expected = CommandResultFactory({\n          data: getOsVersionCommandResponseMockBuilder(DeviceModelId.STAX),\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Bootloader\", () => {\n      it(\"should parse the bootloader response\", () => {\n        const parsed = command.parseResponse(\n          BL_RESPONSE_GOOD,\n          DeviceModelId.STAX,\n        );\n\n        const expected = CommandResultFactory({\n          data: {\n            isBootloader: true,\n            isOsu: false,\n            targetId: 83951619,\n            seTargetId: 855638020,\n            seVersion: \"2.2.3\",\n            seFlags: new Uint8Array([0xf4, 0xd8, 0xaa, 0x43]),\n            mcuTargetId: 83951619,\n            mcuSephVersion: \"\",\n            mcuBootloaderVersion: \"1.16\",\n            hwVersion: \"\",\n            langId: undefined,\n            recoverState: undefined,\n            secureElementFlags: {\n              isPinValidated: true,\n              hasMcuSerialNumber: true,\n              hasValidCertificate: true,\n              isCustomAuthorityConnectionAllowed: true,\n              isSecureConnectionAllowed: false,\n              isOnboarded: true,\n              isMcuCodeSigned: false,\n              isInRecoveryMode: false,\n            },\n          },\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Old firmware\", () => {\n      it(\"should parse the old firmware response\", () => {\n        const parsed = command.parseResponse(\n          OLD_FM_RESPONSE_GOOD,\n          DeviceModelId.NANO_X,\n        );\n\n        const expected = CommandResultFactory({\n          data: {\n            isBootloader: false,\n            isOsu: false,\n            targetId: 855638020,\n            seTargetId: 855638020,\n            seVersion: \"0.0.0\",\n            seFlags: new Uint8Array(),\n            mcuTargetId: undefined,\n            mcuSephVersion: \"2.30\",\n            mcuBootloaderVersion: \"\",\n            hwVersion: \"00\",\n            langId: undefined,\n            recoverState: undefined,\n            secureElementFlags: {\n              isPinValidated: true,\n              hasMcuSerialNumber: true,\n              hasValidCertificate: true,\n              isCustomAuthorityConnectionAllowed: false,\n              isSecureConnectionAllowed: true,\n              isOnboarded: true,\n              isMcuCodeSigned: true,\n              isInRecoveryMode: false,\n            },\n          },\n        });\n\n        expect(parsed).toStrictEqual(expected);\n      });\n    });\n\n    describe(\"Error handling\", () => {\n      it(\"should return an error if the response is not successful\", () => {\n        const response = new ApduResponse({\n          statusCode: Uint8Array.from([0x6e, 0x80]),\n          data: Uint8Array.from([]),\n        });\n        const result = command.parseResponse(response, DeviceModelId.NANO_S);\n\n        expect(isSuccessCommandResult(result)).toBeFalsy();\n      });\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["import_CommandResult", "import_DeviceModel", "import_ApduResponse", "import_GetOsVersionCommand", "GET_OS_VERSION_APDU", "LNX_RESPONSE_DATA_GOOD", "LNX_RESPONSE_GOOD", "LNSP_REPONSE_DATA_GOOD", "LNSP_RESPONSE_GOOD", "STAX_RESPONSE_DATA_GOOD", "STAX_RESPONSE_GOOD", "BL_RESPONSE_DATA_GOOD", "BL_RESPONSE_GOOD", "OLD_FM_RESPONSE_DATA_GOOD", "OLD_FM_RESPONSE_GOOD", "command", "apdu", "parsed", "expected", "response", "result"]
 }

package/lib/cjs/src/api/command/os/ListLanguagePackCommand.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var d=Object.defineProperty;var P=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var R=(o,r)=>{for(var e in r)d(o,e,{get:r[e],enumerable:!0})},I=(o,r,e,n)=>{if(r&&typeof r=="object"\|\|typeof r=="function")for(let a of x(r))!y.call(o,a)&&a!==e&&d(o,a,{get:()=>r[a],enumerable:!(n=P(r,a))\|\|n.enumerable});return o};var S=o=>I(d({},"__esModule",{value:!0}),o);var B={};R(B,{ListLanguagePackCommand:()=>b,ListLanguagePackCommandError:()=>A});module.exports=S(B);var p=require("../../apdu/utils/ApduBuilder"),c=require("../../apdu/utils/ApduParser"),i=require("../../command/Errors"),t=require("../../command/model/CommandResult"),L=require("../../command/utils/CommandErrors"),C=require("../../command/utils/CommandUtils"),l=require("../../command/utils/GlobalCommandError"),f=require("../../Error"),m=require("../../utils/HexaString");const g={"662d":{message:"Invalid LIST_ARG, first command must be sent with P1_LIST_LANGUAGE_PACKS_FIRST."}};class A extends f.DeviceExchangeError{constructor({message:r,errorCode:e}){super({message:r,errorCode:e,tag:"ListLanguagePackCommandError"})}}class b{constructor(r){this.args=r}getApdu(){const r={cla:224,ins:52,p1:this.args.firstChunk?0:1,p2:0};return new p.ApduBuilder(r).build()}parseResponse(r){const e=new c.ApduParser(r);if(!C.CommandUtils.isSuccessResponse(r)){const s=e.encodeToHexaString(r.statusCode);return(0,L.isCommandErrorCode)(s,g)?(0,t.CommandResultFactory)({error:new A({...g[s],errorCode:s})}):(0,t.CommandResultFactory)({error:l.GlobalCommandErrorHandler.handle(r)})}if(e.extract8BitUInt()===void 0)return(0,t.CommandResultFactory)({data:void 0});e.extract8BitUInt();const a=e.extractFieldLVEncoded();if(a===void 0)return(0,t.CommandResultFactory)({error:new i.InvalidStatusWordError("Failed to get language pack id")});const u=e.extractFieldLVEncoded();if(u===void 0)return(0,t.CommandResultFactory)({error:new i.InvalidStatusWordError("Failed to get language pack size")});const E=parseInt((0,m.bufferToHexaString)(a),16),k=parseInt((0,m.bufferToHexaString)(u),16);return(0,t.CommandResultFactory)({data:{id:E,size:k}})}}0&&(module.exports={ListLanguagePackCommand,ListLanguagePackCommandError});
2	+ //# sourceMappingURL=ListLanguagePackCommand.js.map

package/lib/cjs/src/api/command/os/ListLanguagePackCommand.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/command/os/ListLanguagePackCommand.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 { type Command } from \"@api/command/Command\";\nimport { InvalidStatusWordError } from \"@api/command/Errors\";\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 { type CommandErrorArgs, DeviceExchangeError } from \"@api/Error\";\nimport { bufferToHexaString } from \"@api/utils/HexaString\";\n\nexport type ListLanguagePackCommandArgs = {\n  readonly firstChunk: boolean;\n};\n\nexport type ListLanguagePackResponse =\n  | {\n      readonly id: number;\n      readonly size: number;\n    }\n  | undefined;\n\nexport type ListLanguagePackErrorCodes = \"662d\";\n\nconst LANGUAGE_PACK_ERRORS: CommandErrors<ListLanguagePackErrorCodes> = {\n  \"662d\": {\n    message:\n      \"Invalid LIST_ARG, first command must be sent with P1_LIST_LANGUAGE_PACKS_FIRST.\",\n  },\n};\n\nexport type ListLanguagePackCommandResult = CommandResult<\n  ListLanguagePackResponse,\n  ListLanguagePackErrorCodes\n>;\n\nexport class ListLanguagePackCommandError extends DeviceExchangeError<ListLanguagePackErrorCodes> {\n  constructor({\n    message,\n    errorCode,\n  }: CommandErrorArgs<ListLanguagePackErrorCodes>) {\n    super({ message, errorCode, tag: \"ListLanguagePackCommandError\" });\n  }\n}\n\nexport class ListLanguagePackCommand\n  implements\n    Command<\n      ListLanguagePackResponse,\n      ListLanguagePackCommandArgs,\n      ListLanguagePackErrorCodes\n    >\n{\n  constructor(private args: ListLanguagePackCommandArgs) {}\n\n  getApdu(): Apdu {\n    const apduArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x34,\n      p1: this.args.firstChunk ? 0x00 : 0x01,\n      p2: 0x00,\n    };\n    return new ApduBuilder(apduArgs).build();\n  }\n\n  parseResponse(apduResponse: ApduResponse): ListLanguagePackCommandResult {\n    const parser = new ApduParser(apduResponse);\n\n    if (!CommandUtils.isSuccessResponse(apduResponse)) {\n      const errorCode = parser.encodeToHexaString(apduResponse.statusCode);\n      if (isCommandErrorCode(errorCode, LANGUAGE_PACK_ERRORS)) {\n        return CommandResultFactory({\n          error: new ListLanguagePackCommandError({\n            ...LANGUAGE_PACK_ERRORS[errorCode],\n            errorCode,\n          }),\n        });\n      }\n      return CommandResultFactory({\n        error: GlobalCommandErrorHandler.handle(apduResponse),\n      });\n    }\n\n    const tlvVersion = parser.extract8BitUInt();\n    if (tlvVersion === undefined) {\n      // No more language package\n      return CommandResultFactory({\n        data: undefined,\n      });\n    }\n\n    parser.extract8BitUInt(); // total length\n    const idBuffer = parser.extractFieldLVEncoded();\n    if (idBuffer === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Failed to get language pack id\"),\n      });\n    }\n\n    const sizeBuffer = parser.extractFieldLVEncoded();\n    if (sizeBuffer === undefined) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Failed to get language pack size\"),\n      });\n    }\n\n    const id = parseInt(bufferToHexaString(idBuffer), 16);\n    const size = parseInt(bufferToHexaString(sizeBuffer), 16);\n    return CommandResultFactory({\n      data: { id, size },\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,6BAAAE,EAAA,iCAAAC,IAAA,eAAAC,EAAAJ,GACA,IAAAK,EAAkD,uCAClDC,EAA2B,sCAE3BC,EAAuC,+BACvCC,EAGO,4CACPC,EAGO,4CACPC,EAA6B,2CAC7BC,EAA0C,iDAE1CC,EAA2D,sBAC3DC,EAAmC,iCAenC,MAAMC,EAAkE,CACtE,OAAQ,CACN,QACE,iFACJ,CACF,EAOO,MAAMX,UAAqC,qBAAgD,CAChG,YAAY,CACV,QAAAY,EACA,UAAAC,CACF,EAAiD,CAC/C,MAAM,CAAE,QAAAD,EAAS,UAAAC,EAAW,IAAK,8BAA+B,CAAC,CACnE,CACF,CAEO,MAAMd,CAOb,CACE,YAAoBe,EAAmC,CAAnC,UAAAA,CAAoC,CAExD,SAAgB,CACd,MAAMC,EAA4B,CAChC,IAAK,IACL,IAAK,GACL,GAAI,KAAK,KAAK,WAAa,EAAO,EAClC,GAAI,CACN,EACA,OAAO,IAAI,cAAYA,CAAQ,EAAE,MAAM,CACzC,CAEA,cAAcC,EAA2D,CACvE,MAAMC,EAAS,IAAI,aAAWD,CAAY,EAE1C,GAAI,CAAC,eAAa,kBAAkBA,CAAY,EAAG,CACjD,MAAMH,EAAYI,EAAO,mBAAmBD,EAAa,UAAU,EACnE,SAAI,sBAAmBH,EAAWF,CAAoB,KAC7C,wBAAqB,CAC1B,MAAO,IAAIX,EAA6B,CACtC,GAAGW,EAAqBE,CAAS,EACjC,UAAAA,CACF,CAAC,CACH,CAAC,KAEI,wBAAqB,CAC1B,MAAO,4BAA0B,OAAOG,CAAY,CACtD,CAAC,CACH,CAGA,GADmBC,EAAO,gBAAgB,IACvB,OAEjB,SAAO,wBAAqB,CAC1B,KAAM,MACR,CAAC,EAGHA,EAAO,gBAAgB,EACvB,MAAMC,EAAWD,EAAO,sBAAsB,EAC9C,GAAIC,IAAa,OACf,SAAO,wBAAqB,CAC1B,MAAO,IAAI,yBAAuB,gCAAgC,CACpE,CAAC,EAGH,MAAMC,EAAaF,EAAO,sBAAsB,EAChD,GAAIE,IAAe,OACjB,SAAO,wBAAqB,CAC1B,MAAO,IAAI,yBAAuB,kCAAkC,CACtE,CAAC,EAGH,MAAMC,EAAK,YAAS,sBAAmBF,CAAQ,EAAG,EAAE,EAC9CG,EAAO,YAAS,sBAAmBF,CAAU,EAAG,EAAE,EACxD,SAAO,wBAAqB,CAC1B,KAAM,CAAE,GAAAC,EAAI,KAAAC,CAAK,CACnB,CAAC,CACH,CACF",
+  "names": ["ListLanguagePackCommand_exports", "__export", "ListLanguagePackCommand", "ListLanguagePackCommandError", "__toCommonJS", "import_ApduBuilder", "import_ApduParser", "import_Errors", "import_CommandResult", "import_CommandErrors", "import_CommandUtils", "import_GlobalCommandError", "import_Error", "import_HexaString", "LANGUAGE_PACK_ERRORS", "message", "errorCode", "args", "apduArgs", "apduResponse", "parser", "idBuffer", "sizeBuffer", "id", "size"]
+}

package/lib/cjs/src/api/command/os/ListLanguagePackCommand.test.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";var a=require("../../command/Errors"),r=require("../../command/model/CommandResult"),u=require("../../command/model/CommandResult"),o=require("../../command/os/ListLanguagePackCommand"),n=require("../../device-session/ApduResponse");const i=new Uint8Array([224,52,0,0,0]),d=new Uint8Array([224,52,1,0,0]);describe("ListLanguagePackCommand",()=>{let t;beforeEach(()=>{t=new o.ListLanguagePackCommand({firstChunk:!0})}),it("should return the correct APDU",()=>{const e=t.getApdu();expect(e.getRawApdu()).toStrictEqual(i)}),it("should return the correct next chunks APDU",()=>{t=new o.ListLanguagePackCommand({firstChunk:!1});const e=t.getApdu();expect(e.getRawApdu()).toStrictEqual(d)}),it("should parse result successfully",()=>{const e=new n.ApduResponse({statusCode:new Uint8Array([144,0]),data:new Uint8Array([1,15,1,1,4,0,0,80,0,5,48,46,48,46,52,0])}),s=t.parseResponse(e);expect(s).toStrictEqual((0,r.CommandResultFactory)({data:{id:1,size:20480}}))}),it("should parse empty result successfully",()=>{const e=new n.ApduResponse({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}),s=t.parseResponse(e);expect(s).toStrictEqual((0,r.CommandResultFactory)({data:void 0}))}),it("should fail on invalid id",()=>{const e=new n.ApduResponse({statusCode:new Uint8Array([144,0]),data:new Uint8Array([1,15])}),s=t.parseResponse(e);expect(s).toStrictEqual((0,r.CommandResultFactory)({error:new a.InvalidStatusWordError("Failed to get language pack id")}))}),it("should fail on invalid size",()=>{const e=new n.ApduResponse({statusCode:new Uint8Array([144,0]),data:new Uint8Array([1,15,1,1])}),s=t.parseResponse(e);expect(s).toStrictEqual((0,r.CommandResultFactory)({error:new a.InvalidStatusWordError("Failed to get language pack size")}))}),it("should fail on device error",()=>{const e=new n.ApduResponse({statusCode:new Uint8Array([102,45]),data:new Uint8Array([])}),s=t.parseResponse(e);expect((0,u.isSuccessCommandResult)(s)).toBeFalsy()})});
2	+ //# sourceMappingURL=ListLanguagePackCommand.test.js.map