@ledgerhq/device-management-kit 0.0.0-develop-20241011001048 → 0.0.0-develop-20241219141541

package/lib/esm/src/api/apdu/utils/ApduParser.js

@@ -1,73 +1,2 @@
-import { ByteArrayParser } from "./ByteArrayParser";
-/**
- * ApduParser is a utility class to help parse APDU responses.
- *
- * It provides methods to extract fields of different types from the response.
- *
- * @example
- * ```
- * const parser = new ApduParser(apduResponse);
- * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));
- * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());
- * ```
- */
-export class ApduParser {
-    parser;
-    constructor(response) {
-        this.parser = new ByteArrayParser(response.data);
-    }
-    /**
-     * Test if the length is greater than the response length
-     * @param length: number
-     * @returns {boolean} - Returns false if the length is greater than the response length
-     */
-    testMinimalLength = (length) => this.parser.testMinimalLength(length);
-    /**
-     * Extract a single byte from the response
-     * @returns {number | undefined} - Returns the byte extracted from the response
-     */
-    extract8BitUInt = () => this.parser.extract8BitUInt();
-    /**
-     * Extract a 16-bit unsigned integer (Big Endian coding) from the response
-     * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response
-     */
-    extract16BitUInt = () => this.parser.extract16BitUInt();
-    /**
-     * Extract a 32-bit unsigned integer (Big Endian coding) from the response
-     * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response
-     */
-    extract32BitUInt = () => this.parser.extract32BitUInt();
-    /**
-     * Extract a field of a specified length from the response
-     * @param length: number - The length of the field to extract
-     * @returns {Uint8Array | undefined} - Returns the field extracted from the response
-     */
-    extractFieldByLength = (length) => this.parser.extractFieldByLength(length);
-    /**
-     * Extract a field from the response that is length-value encoded
-     * @returns {Uint8Array | undefined} - Returns the field extracted from the response
-     */
-    extractFieldLVEncoded = () => this.parser.extractFieldLVEncoded();
-    /**
-     * Extract a field from the response that is tag-length-value encoded
-     * @returns {TaggedField | undefined} - Returns the field extracted from the response
-     */
-    extractFieldTLVEncoded = () => this.parser.extractFieldTLVEncoded();
-    encodeToHexaString(value, prefix = false) {
-        return prefix
-            ? this.parser.encodeToHexaString(value, true)
-            : this.parser.encodeToHexaString(value, false);
-    }
-    /**
-     * Encode a value to an ASCII string
-     * @param value {Uint8Array} - The value to encode
-     * @returns {string} - The encoded value as an ASCII string
-     */
-    encodeToString = (value) => this.parser.encodeToString(value);
-    /**
-     * Get the remaining length of the response
-     * @returns {number} - The remaining length of the response
-     */
-    getUnparsedRemainingLength = () => this.parser.getUnparsedRemainingLength();
-}
-//# sourceMappingURL=ApduParser.js.map
+import{ByteArrayParser as t}from"./ByteArrayParser";class i{parser;constructor(e){this.parser=new t(e.data)}testMinimalLength=e=>this.parser.testMinimalLength(e);extract8BitUInt=()=>this.parser.extract8BitUInt();extract16BitUInt=()=>this.parser.extract16BitUInt();extract32BitUInt=()=>this.parser.extract32BitUInt();extractFieldByLength=e=>this.parser.extractFieldByLength(e);extractFieldLVEncoded=()=>this.parser.extractFieldLVEncoded();extractFieldTLVEncoded=()=>this.parser.extractFieldTLVEncoded();encodeToHexaString(e,r=!1){return r?this.parser.encodeToHexaString(e,!0):this.parser.encodeToHexaString(e,!1)}encodeToString=e=>this.parser.encodeToString(e);getUnparsedRemainingLength=()=>this.parser.getUnparsedRemainingLength()}export{i as ApduParser};
+//# sourceMappingURL=ApduParser.js.map

package/lib/esm/src/api/apdu/utils/ApduParser.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"ApduParser.js","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ApduParser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAOpD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,UAAU;IACb,MAAM,CAAkB;IAEhC,YAAY,QAAsB;QAChC,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAED;;;;OAIG;IACH,iBAAiB,GAAG,CAAC,MAAc,EAAW,EAAE,CAC9C,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAExC;;;OAGG;IACH,eAAe,GAAG,GAAuB,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC;IAE1E;;;OAGG;IACH,gBAAgB,GAAG,GAAuB,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;IAE5E;;;OAGG;IACH,gBAAgB,GAAG,GAAuB,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,CAAC;IAE5E;;;;OAIG;IACH,oBAAoB,GAAG,CAAC,MAAc,EAA0B,EAAE,CAChE,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IAE3C;;;OAGG;IACH,qBAAqB,GAAG,GAA2B,EAAE,CACnD,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;IAEtC;;;OAGG;IACH,sBAAsB,GAAG,GAA4B,EAAE,CACrD,IAAI,CAAC,MAAM,CAAC,sBAAsB,EAAE,CAAC;IAUvC,kBAAkB,CAChB,KAAkB,EAClB,SAAkB,KAAK;QAEvB,OAAO,MAAM;YACX,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC;YAC7C,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;IAED;;;;OAIG;IACH,cAAc,GAAG,CAAC,KAAkB,EAAU,EAAE,CAC9C,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAEpC;;;OAGG;IACH,0BAA0B,GAAG,GAAW,EAAE,CACxC,IAAI,CAAC,MAAM,CAAC,0BAA0B,EAAE,CAAC;CAC5C"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/apdu/utils/ApduParser.ts"],
+  "sourcesContent": ["import { type ApduResponse } from \"@api/device-session/ApduResponse\";\nimport { type HexaString } from \"@api/utils/HexaString\";\n\nimport { ByteArrayParser } from \"./ByteArrayParser\";\n\nexport type TaggedField = {\n  readonly tag: number;\n  readonly value: Uint8Array;\n};\n\n/**\n * ApduParser is a utility class to help parse APDU responses.\n *\n * It provides methods to extract fields of different types from the response.\n *\n * @example\n * ```\n * const parser = new ApduParser(apduResponse);\n * const targetId = parser.encodeToHexaString(parser.extractFieldByLength(4));\n * const seVersion = parser.encodeToString(parser.extractFieldLVEncoded());\n * ```\n */\nexport class ApduParser {\n  private parser: ByteArrayParser;\n\n  constructor(response: ApduResponse) {\n    this.parser = new ByteArrayParser(response.data);\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    this.parser.testMinimalLength(length);\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 => this.parser.extract8BitUInt();\n\n  /**\n   * Extract a 16-bit unsigned integer (Big Endian coding) from the response\n   * @returns {number | undefined} - Returns the 16-bit unsigned integer extracted from the response\n   */\n  extract16BitUInt = (): number | undefined => this.parser.extract16BitUInt();\n\n  /**\n   * Extract a 32-bit unsigned integer (Big Endian coding) from the response\n   * @returns {number | undefined} - Returns the 32-bit unsigned integer extracted from the response\n   */\n  extract32BitUInt = (): number | undefined => this.parser.extract32BitUInt();\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    this.parser.extractFieldByLength(length);\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    this.parser.extractFieldLVEncoded();\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    this.parser.extractFieldTLVEncoded();\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    return prefix\n      ? this.parser.encodeToHexaString(value, true)\n      : this.parser.encodeToHexaString(value, false);\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    this.parser.encodeToString(value);\n\n  /**\n   * Get the remaining length of the response\n   * @returns {number} - The remaining length of the response\n   */\n  getUnparsedRemainingLength = (): number =>\n    this.parser.getUnparsedRemainingLength();\n}\n"],
+  "mappings": "AAGA,OAAS,mBAAAA,MAAuB,oBAmBzB,MAAMC,CAAW,CACd,OAER,YAAYC,EAAwB,CAClC,KAAK,OAAS,IAAIF,EAAgBE,EAAS,IAAI,CACjD,CAOA,kBAAqBC,GACnB,KAAK,OAAO,kBAAkBA,CAAM,EAMtC,gBAAkB,IAA0B,KAAK,OAAO,gBAAgB,EAMxE,iBAAmB,IAA0B,KAAK,OAAO,iBAAiB,EAM1E,iBAAmB,IAA0B,KAAK,OAAO,iBAAiB,EAO1E,qBAAwBA,GACtB,KAAK,OAAO,qBAAqBA,CAAM,EAMzC,sBAAwB,IACtB,KAAK,OAAO,sBAAsB,EAMpC,uBAAyB,IACvB,KAAK,OAAO,uBAAuB,EAUrC,mBACEC,EACAC,EAAkB,GACG,CACrB,OAAOA,EACH,KAAK,OAAO,mBAAmBD,EAAO,EAAI,EAC1C,KAAK,OAAO,mBAAmBA,EAAO,EAAK,CACjD,CAOA,eAAkBA,GAChB,KAAK,OAAO,eAAeA,CAAK,EAMlC,2BAA6B,IAC3B,KAAK,OAAO,2BAA2B,CAC3C",
+  "names": ["ByteArrayParser", "ApduParser", "response", "length", "value", "prefix"]
+}

package/lib/esm/src/api/apdu/utils/ApduParser.test.js

@@ -0,0 +1,2 @@
+import{ApduResponse as a}from"../../device-session/ApduResponse";import{ApduParser as n}from"./ApduParser";const r=new Uint8Array([144,0]),o=new Uint8Array([1]),x=new Uint8Array([0]),c=new Uint8Array([1,2,3,...Array(253).fill(170)]);let t,e=new a({statusCode:r,data:o});describe("ApduParser",()=>{it("should create an instance",()=>{t=new n(e),expect(t).toBeDefined(),expect(t).toBeInstanceOf(n)}),it("Extract a single byte",()=>{t=new n(e),expect(t.extract8BitUInt()).toBe(1)}),it("Extract 16-bit & 32-bit number",()=>{e=new a({statusCode:r,data:c}),t=new n(e),expect(t.extract16BitUInt()).toBe(258),expect(t.extract16BitUInt()).toBe(938)}),it("Test zero length",()=>{e=new a({statusCode:r,data:x}),t=new n(e);const s=t.extract8BitUInt();expect(s).toBe(0)})});
+//# sourceMappingURL=ApduParser.test.js.map

package/lib/esm/src/api/apdu/utils/ApduParser.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/apdu/utils/ApduParser.test.ts"],
+  "sourcesContent": ["import { ApduResponse } from \"@api/device-session/ApduResponse\";\n\nimport { ApduParser } from \"./ApduParser\";\n\nconst STATUS_WORD_SUCCESS = new Uint8Array([0x90, 0x00]);\nconst RESPONSE_ONE_BYTE = new Uint8Array([0x01]);\nconst RESPONSE_LV_ZERO = new Uint8Array([0x00]);\nconst RESPONSE_ALL_BYTES = new Uint8Array([\n  0x01,\n  0x02,\n  0x03,\n  ...Array<number>(253).fill(0xaa),\n]);\n\nlet parser: ApduParser;\nlet response: ApduResponse = new ApduResponse({\n  statusCode: STATUS_WORD_SUCCESS,\n  data: RESPONSE_ONE_BYTE,\n});\n\ndescribe(\"ApduParser\", () => {\n  it(\"should create an instance\", () => {\n    parser = new ApduParser(response);\n    expect(parser).toBeDefined();\n    expect(parser).toBeInstanceOf(ApduParser);\n  });\n\n  it(\"Extract a single byte\", () => {\n    parser = new ApduParser(response);\n    expect(parser.extract8BitUInt()).toBe(0x01);\n  });\n\n  it(\"Extract 16-bit & 32-bit number\", () => {\n    response = new ApduResponse({\n      statusCode: STATUS_WORD_SUCCESS,\n      data: RESPONSE_ALL_BYTES,\n    });\n    parser = new ApduParser(response);\n    expect(parser.extract16BitUInt()).toBe(0x0102);\n    expect(parser.extract16BitUInt()).toBe(0x03aa);\n  });\n\n  it(\"Test zero length\", () => {\n    response = new ApduResponse({\n      statusCode: STATUS_WORD_SUCCESS,\n      data: RESPONSE_LV_ZERO,\n    });\n    parser = new ApduParser(response);\n    const value = parser.extract8BitUInt();\n    expect(value).toBe(0);\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,gBAAAA,MAAoB,mCAE7B,OAAS,cAAAC,MAAkB,eAE3B,MAAMC,EAAsB,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,EACjDC,EAAoB,IAAI,WAAW,CAAC,CAAI,CAAC,EACzCC,EAAmB,IAAI,WAAW,CAAC,CAAI,CAAC,EACxCC,EAAqB,IAAI,WAAW,CACxC,EACA,EACA,EACA,GAAG,MAAc,GAAG,EAAE,KAAK,GAAI,CACjC,CAAC,EAED,IAAIC,EACAC,EAAyB,IAAIP,EAAa,CAC5C,WAAYE,EACZ,KAAMC,CACR,CAAC,EAED,SAAS,aAAc,IAAM,CAC3B,GAAG,4BAA6B,IAAM,CACpCG,EAAS,IAAIL,EAAWM,CAAQ,EAChC,OAAOD,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,eAAeL,CAAU,CAC1C,CAAC,EAED,GAAG,wBAAyB,IAAM,CAChCK,EAAS,IAAIL,EAAWM,CAAQ,EAChC,OAAOD,EAAO,gBAAgB,CAAC,EAAE,KAAK,CAAI,CAC5C,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzCC,EAAW,IAAIP,EAAa,CAC1B,WAAYE,EACZ,KAAMG,CACR,CAAC,EACDC,EAAS,IAAIL,EAAWM,CAAQ,EAChC,OAAOD,EAAO,iBAAiB,CAAC,EAAE,KAAK,GAAM,EAC7C,OAAOA,EAAO,iBAAiB,CAAC,EAAE,KAAK,GAAM,CAC/C,CAAC,EAED,GAAG,mBAAoB,IAAM,CAC3BC,EAAW,IAAIP,EAAa,CAC1B,WAAYE,EACZ,KAAME,CACR,CAAC,EACDE,EAAS,IAAIL,EAAWM,CAAQ,EAChC,MAAMC,EAAQF,EAAO,gBAAgB,EACrC,OAAOE,CAAK,EAAE,KAAK,CAAC,CACtB,CAAC,CACH,CAAC",
+  "names": ["ApduResponse", "ApduParser", "STATUS_WORD_SUCCESS", "RESPONSE_ONE_BYTE", "RESPONSE_LV_ZERO", "RESPONSE_ALL_BYTES", "parser", "response", "value"]
+}

package/lib/esm/src/api/apdu/utils/AppBuilderError.js

@@ -1,29 +1,2 @@
-import { APDU_MAX_PAYLOAD } from "./ApduBuilder";
-export class ValueOverflowError {
-    _tag = "ValueOverflow";
-    originalError;
-    message;
-    constructor(value, max = APDU_MAX_PAYLOAD) {
-        this.message = `Value overflow for ${value}, max is ${max}`;
-    }
-}
-export class DataOverflowError {
-    _tag = "DataOverflow";
-    message;
-    originalError;
-    constructor(value, remaining = 0) {
-        this.message =
-            remaining === 0
-                ? `this.data is already full (value: ${value})`
-                : `this.data will overflow with "${value}", remaining bytes: ${remaining}`;
-    }
-}
-export class HexaStringEncodeError {
-    _tag = "HexaString";
-    message;
-    originalError;
-    constructor(value) {
-        this.message = `Invalid encoded hexa string or length is null: ${value}`;
-    }
-}
-//# sourceMappingURL=AppBuilderError.js.map
+import{APDU_MAX_PAYLOAD as a}from"./ApduBuilder";class l{_tag="ValueOverflow";originalError;message;constructor(r,e=a){this.message=`Value overflow for ${r}, max is ${e}`}}class s{_tag="DataOverflow";message;originalError;constructor(r,e=0){this.message=e===0?`this.data is already full (value: ${r})`:`this.data will overflow with "${r}", remaining bytes: ${e}`}}class i{_tag="HexaString";message;originalError;constructor(r){this.message=`Invalid encoded hexa string or length is null: ${r}`}}export{s as DataOverflowError,i as HexaStringEncodeError,l as ValueOverflowError};
+//# sourceMappingURL=AppBuilderError.js.map

package/lib/esm/src/api/apdu/utils/AppBuilderError.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"AppBuilderError.js","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/AppBuilderError.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAMjD,MAAM,OAAO,kBAAkB;IACpB,IAAI,GAAG,eAAe,CAAC;IACvB,aAAa,CAAS;IACtB,OAAO,CAAS;IACzB,YAAY,KAAa,EAAE,MAAuB,gBAAgB;QAChE,IAAI,CAAC,OAAO,GAAG,sBAAsB,KAAK,YAAY,GAAG,EAAE,CAAC;IAC9D,CAAC;CACF;AAED,MAAM,OAAO,iBAAiB;IACnB,IAAI,GAAG,cAAc,CAAC;IACtB,OAAO,CAAS;IAChB,aAAa,CAAS;IAC/B,YAAY,KAAa,EAAE,SAAS,GAAG,CAAC;QACtC,IAAI,CAAC,OAAO;YACV,SAAS,KAAK,CAAC;gBACb,CAAC,CAAC,qCAAqC,KAAK,GAAG;gBAC/C,CAAC,CAAC,iCAAiC,KAAK,uBAAuB,SAAS,EAAE,CAAC;IACjF,CAAC;CACF;AAED,MAAM,OAAO,qBAAqB;IACvB,IAAI,GAAG,YAAY,CAAC;IACpB,OAAO,CAAS;IAChB,aAAa,CAAS;IAC/B,YAAY,KAAa;QACvB,IAAI,CAAC,OAAO,GAAG,kDAAkD,KAAK,EAAE,CAAC;IAC3E,CAAC;CACF"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/apdu/utils/AppBuilderError.ts"],
+  "sourcesContent": ["import { type DmkError } from \"@api/Error\";\n\nimport { APDU_MAX_PAYLOAD } from \"./ApduBuilder\";\n\ninterface DmkAppBuilderError extends DmkError {\n  readonly message: string;\n}\n\nexport class ValueOverflowError implements DmkAppBuilderError {\n  readonly _tag = \"ValueOverflow\";\n  readonly originalError?: Error;\n  readonly message: string;\n  constructor(value: string, max: number | bigint = APDU_MAX_PAYLOAD) {\n    this.message = `Value overflow for ${value}, max is ${max}`;\n  }\n}\n\nexport class DataOverflowError implements DmkAppBuilderError {\n  readonly _tag = \"DataOverflow\";\n  readonly message: string;\n  readonly originalError?: Error;\n  constructor(value: string, remaining = 0) {\n    this.message =\n      remaining === 0\n        ? `this.data is already full (value: ${value})`\n        : `this.data will overflow with \"${value}\", remaining bytes: ${remaining}`;\n  }\n}\n\nexport class HexaStringEncodeError implements DmkAppBuilderError {\n  readonly _tag = \"HexaString\";\n  readonly message: string;\n  readonly originalError?: Error;\n  constructor(value: string) {\n    this.message = `Invalid encoded hexa string or length is null: ${value}`;\n  }\n}\n\n/**\n * Type for all possible errors that can be thrown by the AppBuilder.\n */\nexport type AppBuilderError =\n  | ValueOverflowError\n  | DataOverflowError\n  | HexaStringEncodeError;\n"],
+  "mappings": "AAEA,OAAS,oBAAAA,MAAwB,gBAM1B,MAAMC,CAAiD,CACnD,KAAO,gBACP,cACA,QACT,YAAYC,EAAeC,EAAuBH,EAAkB,CAClE,KAAK,QAAU,sBAAsBE,CAAK,YAAYC,CAAG,EAC3D,CACF,CAEO,MAAMC,CAAgD,CAClD,KAAO,eACP,QACA,cACT,YAAYF,EAAeG,EAAY,EAAG,CACxC,KAAK,QACHA,IAAc,EACV,qCAAqCH,CAAK,IAC1C,iCAAiCA,CAAK,uBAAuBG,CAAS,EAC9E,CACF,CAEO,MAAMC,CAAoD,CACtD,KAAO,aACP,QACA,cACT,YAAYJ,EAAe,CACzB,KAAK,QAAU,kDAAkDA,CAAK,EACxE,CACF",
+  "names": ["APDU_MAX_PAYLOAD", "ValueOverflowError", "value", "max", "DataOverflowError", "remaining", "HexaStringEncodeError"]
+}

package/lib/esm/src/api/apdu/utils/ByteArrayBuilder.js

@@ -1,301 +1,2 @@
-import { hexaStringToBuffer } from "../../utils/HexaString";
-import { DataOverflowError, HexaStringEncodeError, ValueOverflowError, } from "./AppBuilderError";
-const MAX_32_BIT_UINT = 0xffffffff;
-/**
- * ByteArrayBuilder is a utility class to help build APDU payloads.
- * It allows to easily add data to the payload of an APDU command
- * and to encode this data in different formats.
- *
- * @example
- * ```
- * const builder = new ByteArrayBuilder(255)
- *  .add8BitUIntToData(0x05)
- *  .add16BitUIntToData(0x0607)
- *  .addHexaStringToData("0x0809")
- *  .addAsciiStringToData("hello")
- *
- * const payload = builder.build();
- * const builderErrors = builder.getErrors();
- * ```
- */
-export class ByteArrayBuilder {
-    maxPayloadSize;
-    data = new Uint8Array();
-    errors = []; // Custom Error
-    constructor(maxPayloadSize = MAX_32_BIT_UINT) {
-        this.maxPayloadSize = maxPayloadSize;
-    }
-    // ==========
-    // Public API
-    // ==========
-    /**
-     * Build a new payload instance with the current state of the builder
-     * @returns {payload} - Returns a new payload instance
-     */
-    build = () => this.data;
-    /**
-     * Try to build a new payload instance with the current state of the builder
-     * if the builder don't contain any error.
-     * @returns {payload | undefined} - Returns a new payload instance or undefined
-     */
-    tryBuild = () => {
-        return this.hasErrors() ? undefined : this.data;
-    };
-    /**
-     * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)
-     * @param value: number | bigint - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add8BitUIntToData = (value) => {
-        return this.addNumberToData(value, 8n, false, false);
-    };
-    /**
-     * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add16BitUIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 16n, false, bigEndian);
-    };
-    /**
-     * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add32BitUIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 32n, false, bigEndian);
-    };
-    /**
-     * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add64BitUIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 64n, false, bigEndian);
-    };
-    /**
-     * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add16BitIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 16n, true, bigEndian);
-    };
-    /**
-     * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add32BitIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 32n, true, bigEndian);
-    };
-    /**
-     * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)
-     * @param value: number | bigint - The value to add to the data
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    add64BitIntToData = (value, bigEndian = true) => {
-        return this.addNumberToData(value, 64n, true, bigEndian);
-    };
-    /**
-     * Add a Uint8Array to the payload if it has enough remaining space
-     * @param value: Uint8Array - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addBufferToData = (value) => {
-        if (!this.hasEnoughLengthRemaining(value)) {
-            this.errors.push(new DataOverflowError(value.toString()));
-            return this;
-        }
-        this.data = Uint8Array.from([...this.data, ...value]);
-        return this;
-    };
-    /**
-     * Add a string to the payload if it has enough remaining space
-     * and it can be formatted as a hexadecimal string
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addHexaStringToData = (value) => {
-        const result = hexaStringToBuffer(value);
-        if (result === null || result.length === 0) {
-            this.errors.push(new HexaStringEncodeError(value));
-            return this;
-        }
-        this.addBufferToData(result);
-        return this;
-    };
-    /**
-     * Add an ascii string to the data field if it has enough remaining space
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addAsciiStringToData = (value) => {
-        const bytes = new TextEncoder().encode(value);
-        this.addBufferToData(bytes);
-        return this;
-    };
-    /**
-     * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space
-     * Length-Value encoding is a way to encode data in a binary format with the first byte
-     * being the length of the data and the following bytes being the data itself
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    encodeInLVFromHexa = (value) => {
-        const result = hexaStringToBuffer(value);
-        if (result === null || result.length === 0) {
-            this.errors.push(new HexaStringEncodeError(value));
-            return this;
-        }
-        if (!this.hasEnoughLengthRemaining(result, true)) {
-            this.errors.push(new DataOverflowError(value));
-            return this;
-        }
-        // values are always being well formatted at this point
-        // therefore no status test is needed
-        this.add8BitUIntToData(result.length);
-        this.addBufferToData(result);
-        return this;
-    };
-    /**
-     * Add a Length-Value encoded buffer to the data field if it has enough remaining space
-     * Length-Value encoding is a way to encode data in a binary format with the first byte
-     * being the length of the data and the following bytes being the data itself
-     * @param value: Uint8Array - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    encodeInLVFromBuffer = (value) => {
-        if (!this.hasEnoughLengthRemaining(value, true)) {
-            this.errors.push(new DataOverflowError(value.toString()));
-            return this;
-        }
-        this.add8BitUIntToData(value.length);
-        this.addBufferToData(value);
-        return this;
-    };
-    /**
-     * Add a Length-Value encoded ascii string to the data field if it has enough remaining space
-     * Length-Value encoding is a way to encode data in a binary format with the first byte
-     * being the length of the data and the following bytes being the data itself
-     * @param value: string - The value to add to the data
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    encodeInLVFromAscii = (value) => {
-        if (!this.hasEnoughLengthRemaining(value, true)) {
-            this.errors.push(new DataOverflowError(value));
-            return this;
-        }
-        this.add8BitUIntToData(value.length);
-        this.addAsciiStringToData(value);
-        return this;
-    };
-    /**
-     * Returns the remaining payload length
-     * @returns {number}
-     */
-    getAvailablePayloadLength = () => {
-        return this.maxPayloadSize - this.data.length;
-    };
-    /**
-     * Returns the current errors
-     * @returns {AppBuilderError[]} - Returns an array of errors
-     */
-    getErrors = () => this.errors;
-    /**
-     * Verifies if the builder contains errors
-     * @returns {boolean} - Returns wether the builder contains errors or not
-     */
-    hasErrors = () => this.errors.length !== 0;
-    // ===========
-    // Private API
-    // ===========
-    /**
-     * Check if there is enough space to add a value to the data field
-     * @param value {string | Uint8Array | number[]} - Value to add to the data
-     * @param hasLv {boolean} - Length-Value encoding flag
-     * @returns {boolean} - Returns true if there is enough space to add the value
-     */
-    hasEnoughLengthRemaining = (value, hasLv = false) => {
-        return (this.data.length + value.length + (hasLv ? 1 : 0) <= this.maxPayloadSize);
-    };
-    /**
-     * Add a number to the payload
-     * @param value: number | bigint - The value to add to the data
-     * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16
-     * @param signed: boolean - Whether the value is signed or unsigned.
-     * @param bigEndian: boolean - True to encode in big endian, false for little endian
-     * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder
-     */
-    addNumberToData(value, sizeInBits, signed, bigEndian) {
-        // Convert the number to two's complement and check its bounds
-        let converted = this.checkBoundsAndConvert(value, sizeInBits, signed);
-        if (converted === undefined) {
-            return this;
-        }
-        // Compute the buffer
-        const sizeInBytes = Number(sizeInBits) / 8;
-        const buffer = new Uint8Array(sizeInBytes);
-        if (bigEndian) {
-            for (let i = sizeInBytes - 1; i >= 0; i--) {
-                buffer[i] = Number(converted & 0xffn);
-                converted >>= 8n;
-            }
-        }
-        else {
-            for (let i = 0; i < sizeInBytes; i++) {
-                buffer[i] = Number(converted & 0xffn);
-                converted >>= 8n;
-            }
-        }
-        return this.addBufferToData(buffer);
-    }
-    /**
-     * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.
-     * @param value The value to check and convert.
-     * @param sizeInBits The size of the value in bits.
-     * @param signed Whether the value is signed or unsigned.
-     * @returns The converted value, or null if the value is out of bounds.
-     */
-    checkBoundsAndConvert(value, sizeInBits, signed) {
-        // Normalize the value to a bigint
-        if (typeof value === "number") {
-            if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER) {
-                this.errors.push(new ValueOverflowError(value.toString()));
-                return;
-            }
-            value = BigInt(value);
-        }
-        if (!signed) {
-            // Check if the value is within the bounds of an unsigned integer
-            const limit = 1n << sizeInBits;
-            if (value < 0 || value >= limit) {
-                this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));
-                return;
-            }
-        }
-        else {
-            // Check if the value is within the bounds of a signed integer
-            const limit = 1n << (sizeInBits - 1n);
-            if (value >= limit || value < -limit) {
-                this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));
-                return;
-            }
-            // Convert the value to two's complement if it is negative
-            // https://en.wikipedia.org/wiki/Two%27s_complement
-            if (value < 0n) {
-                const mask = (1n << sizeInBits) - 1n;
-                value = -value;
-                value = (~value & mask) + 1n;
-            }
-        }
-        return value;
-    }
-}
-//# sourceMappingURL=ByteArrayBuilder.js.map
+import{hexaStringToBuffer as h}from"../../utils/HexaString";import{DataOverflowError as a,HexaStringEncodeError as b,ValueOverflowError as u}from"./AppBuilderError";const B=4294967295;class l{constructor(r=B){this.maxPayloadSize=r}data=new Uint8Array;errors=[];build=()=>this.data;tryBuild=()=>this.hasErrors()?void 0:this.data;add8BitUIntToData=r=>this.addNumberToData(r,8n,!1,!1);add16BitUIntToData=(r,t=!0)=>this.addNumberToData(r,16n,!1,t);add32BitUIntToData=(r,t=!0)=>this.addNumberToData(r,32n,!1,t);add64BitUIntToData=(r,t=!0)=>this.addNumberToData(r,64n,!1,t);add128BitUIntToData=(r,t=!0)=>this.addNumberToData(r,128n,!1,t);add256BitUIntToData=(r,t=!0)=>this.addNumberToData(r,256n,!1,t);add16BitIntToData=(r,t=!0)=>this.addNumberToData(r,16n,!0,t);add32BitIntToData=(r,t=!0)=>this.addNumberToData(r,32n,!0,t);add64BitIntToData=(r,t=!0)=>this.addNumberToData(r,64n,!0,t);add128BitIntToData=(r,t=!0)=>this.addNumberToData(r,128n,!0,t);add256BitIntToData=(r,t=!0)=>this.addNumberToData(r,256n,!0,t);addBufferToData=r=>this.hasEnoughLengthRemaining(r)?(this.data=Uint8Array.from([...this.data,...r]),this):(this.errors.push(new a(r.toString())),this);addHexaStringToData=r=>{const t=h(r);return t===null||t.length===0?(this.errors.push(new b(r)),this):(this.addBufferToData(t),this)};addAsciiStringToData=r=>{const t=new TextEncoder().encode(r);return this.addBufferToData(t),this};encodeInLVFromHexa=r=>{const t=h(r);return t===null||t.length===0?(this.errors.push(new b(r)),this):this.hasEnoughLengthRemaining(t,!0)?(this.add8BitUIntToData(t.length),this.addBufferToData(t),this):(this.errors.push(new a(r)),this)};encodeInLVFromBuffer=r=>this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addBufferToData(r),this):(this.errors.push(new a(r.toString())),this);encodeInLVFromAscii=r=>this.hasEnoughLengthRemaining(r,!0)?(this.add8BitUIntToData(r.length),this.addAsciiStringToData(r),this):(this.errors.push(new a(r)),this);getAvailablePayloadLength=()=>this.maxPayloadSize-this.data.length;getErrors=()=>this.errors;hasErrors=()=>this.errors.length!==0;hasEnoughLengthRemaining=(r,t=!1)=>this.data.length+r.length+(t?1:0)<=this.maxPayloadSize;addNumberToData(r,t,o,e){let n=this.checkBoundsAndConvert(r,t,o);if(n===void 0)return this;const d=Number(t)/8,s=new Uint8Array(d);if(e)for(let i=d-1;i>=0;i--)s[i]=Number(n&0xffn),n>>=8n;else for(let i=0;i<d;i++)s[i]=Number(n&0xffn),n>>=8n;return this.addBufferToData(s)}checkBoundsAndConvert(r,t,o){if(typeof r=="number"){if(!Number.isInteger(r)||r>Number.MAX_SAFE_INTEGER){this.errors.push(new u(r.toString()));return}r=BigInt(r)}if(o){const e=1n<<t-1n;if(r>=e||r<-e){this.errors.push(new u(r.toString(),e-1n));return}if(r<0n){const n=(1n<<t)-1n;r=-r,r=(~r&n)+1n}}else{const e=1n<<t;if(r<0||r>=e){this.errors.push(new u(r.toString(),e-1n));return}}return r}}export{l as ByteArrayBuilder};
+//# sourceMappingURL=ByteArrayBuilder.js.map

package/lib/esm/src/api/apdu/utils/ByteArrayBuilder.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"ByteArrayBuilder.js","sourceRoot":"","sources":["../../../../../../src/api/apdu/utils/ByteArrayBuilder.ts"],"names":[],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/api/apdu/utils/ByteArrayBuilder.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@api/utils/HexaString\";\n\nimport {\n  type AppBuilderError,\n  DataOverflowError,\n  HexaStringEncodeError,\n  ValueOverflowError,\n} from \"./AppBuilderError\";\n\nconst MAX_32_BIT_UINT = 0xffffffff;\n\n/**\n * ByteArrayBuilder is a utility class to help build APDU payloads.\n * It allows to easily add data to the payload of an APDU command\n * and to encode this data in different formats.\n *\n * @example\n * ```\n * const builder = new ByteArrayBuilder(255)\n *  .add8BitUIntToData(0x05)\n *  .add16BitUIntToData(0x0607)\n *  .addHexaStringToData(\"0x0809\")\n *  .addAsciiStringToData(\"hello\")\n *\n * const payload = builder.build();\n * const builderErrors = builder.getErrors();\n * ```\n */\nexport class ByteArrayBuilder {\n  private data: Uint8Array = new Uint8Array();\n  private readonly errors: AppBuilderError[] = []; // Custom Error\n\n  constructor(private maxPayloadSize: number = MAX_32_BIT_UINT) {}\n\n  // ==========\n  // Public API\n  // ==========\n\n  /**\n   * Build a new payload instance with the current state of the builder\n   * @returns {payload} - Returns a new payload instance\n   */\n  build = (): Uint8Array => this.data;\n\n  /**\n   * Try to build a new payload instance with the current state of the builder\n   * if the builder don't contain any error.\n   * @returns {payload | undefined} - Returns a new payload instance or undefined\n   */\n  tryBuild = (): Uint8Array | undefined => {\n    return this.hasErrors() ? undefined : this.data;\n  };\n\n  /**\n   * Add a 8-bit unsigned integer to the payload (max value 0xff = 255)\n   * @param value: number | bigint - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add8BitUIntToData = (value: number | bigint): ByteArrayBuilder => {\n    return this.addNumberToData(value, 8n, false, false);\n  };\n\n  /**\n   * Add a 16-bit unsigned integer to the payload (max value 0xffff = 65535)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, false, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit unsigned integer to the payload (max value 0xffffffff = 4294967295)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, false, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit unsigned integer to the payload (max value 0xffffffffffffffff = 18446744073709551615)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, false, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, false, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit unsigned integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitUIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, false, bigEndian);\n  };\n\n  /**\n   * Add a 16-bit signed integer to the payload (value between -0x8000 to 0x7fff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add16BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 16n, true, bigEndian);\n  };\n\n  /**\n   * Add a 32-bit signed integer to the payload (value between -0x80000000 to 0x7fffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add32BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 32n, true, bigEndian);\n  };\n\n  /**\n   * Add a 64-bit signed integer to the payload (value between -0x8000000000000000 to 0x7fffffffffffffff)\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add64BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 64n, true, bigEndian);\n  };\n\n  /**\n   * Add a 128-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add128BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 128n, true, bigEndian);\n  };\n\n  /**\n   * Add a 256-bit signed integer to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  add256BitIntToData = (\n    value: number | bigint,\n    bigEndian: boolean = true,\n  ): ByteArrayBuilder => {\n    return this.addNumberToData(value, 256n, true, bigEndian);\n  };\n\n  /**\n   * Add a Uint8Array to the payload if it has enough remaining space\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addBufferToData = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.data = Uint8Array.from([...this.data, ...value]);\n    return this;\n  };\n\n  /**\n   * Add a string to the payload if it has enough remaining space\n   * and it can be formatted as a hexadecimal string\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addHexaStringToData = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add an ascii string to the data field if it has enough remaining space\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  addAsciiStringToData = (value: string): ByteArrayBuilder => {\n    const bytes = new TextEncoder().encode(value);\n    this.addBufferToData(bytes);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded hexadecimal string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromHexa = (value: string): ByteArrayBuilder => {\n    const result = hexaStringToBuffer(value);\n    if (result === null || result.length === 0) {\n      this.errors.push(new HexaStringEncodeError(value));\n      return this;\n    }\n\n    if (!this.hasEnoughLengthRemaining(result, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n    // values are always being well formatted at this point\n    // therefore no status test is needed\n    this.add8BitUIntToData(result.length);\n    this.addBufferToData(result);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded buffer to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: Uint8Array - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromBuffer = (value: Uint8Array): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value.toString()));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addBufferToData(value);\n    return this;\n  };\n\n  /**\n   * Add a Length-Value encoded ascii string to the data field if it has enough remaining space\n   * Length-Value encoding is a way to encode data in a binary format with the first byte\n   * being the length of the data and the following bytes being the data itself\n   * @param value: string - The value to add to the data\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  encodeInLVFromAscii = (value: string): ByteArrayBuilder => {\n    if (!this.hasEnoughLengthRemaining(value, true)) {\n      this.errors.push(new DataOverflowError(value));\n      return this;\n    }\n\n    this.add8BitUIntToData(value.length);\n    this.addAsciiStringToData(value);\n    return this;\n  };\n\n  /**\n   * Returns the remaining payload length\n   * @returns {number}\n   */\n  getAvailablePayloadLength = (): number => {\n    return this.maxPayloadSize - this.data.length;\n  };\n\n  /**\n   * Returns the current errors\n   * @returns {AppBuilderError[]} - Returns an array of errors\n   */\n  getErrors = (): AppBuilderError[] => this.errors;\n\n  /**\n   * Verifies if the builder contains errors\n   * @returns {boolean} - Returns wether the builder contains errors or not\n   */\n  hasErrors = (): boolean => this.errors.length !== 0;\n\n  // ===========\n  // Private API\n  // ===========\n\n  /**\n   * Check if there is enough space to add a value to the data field\n   * @param value {string | Uint8Array | number[]} - Value to add to the data\n   * @param hasLv {boolean} - Length-Value encoding flag\n   * @returns {boolean} - Returns true if there is enough space to add the value\n   */\n  private hasEnoughLengthRemaining = (\n    value: string | Uint8Array | number[],\n    hasLv: boolean = false,\n  ): boolean => {\n    return (\n      this.data.length + value.length + (hasLv ? 1 : 0) <= this.maxPayloadSize\n    );\n  };\n\n  /**\n   * Add a number to the payload\n   * @param value: number | bigint - The value to add to the data\n   * @param sizeInBits: bigint - The number size in bits, for example 16 for a uint16\n   * @param signed: boolean - Whether the value is signed or unsigned.\n   * @param bigEndian: boolean - True to encode in big endian, false for little endian\n   * @returns {ByteArrayBuilder} - Returns the current instance of ByteArrayBuilder\n   */\n  private addNumberToData(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n    bigEndian: boolean,\n  ): ByteArrayBuilder {\n    // Convert the number to two's complement and check its bounds\n    let converted = this.checkBoundsAndConvert(value, sizeInBits, signed);\n    if (converted === undefined) {\n      return this;\n    }\n\n    // Compute the buffer\n    const sizeInBytes = Number(sizeInBits) / 8;\n    const buffer = new Uint8Array(sizeInBytes);\n    if (bigEndian) {\n      for (let i = sizeInBytes - 1; i >= 0; i--) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    } else {\n      for (let i = 0; i < sizeInBytes; i++) {\n        buffer[i] = Number(converted & 0xffn);\n        converted >>= 8n;\n      }\n    }\n    return this.addBufferToData(buffer);\n  }\n\n  /**\n   * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.\n   * @param value The value to check and convert.\n   * @param sizeInBits The size of the value in bits.\n   * @param signed Whether the value is signed or unsigned.\n   * @returns The converted value, or null if the value is out of bounds.\n   */\n  private checkBoundsAndConvert(\n    value: number | bigint,\n    sizeInBits: bigint,\n    signed: boolean,\n  ): bigint | undefined {\n    // Normalize the value to a bigint\n    if (typeof value === \"number\") {\n      if (!Number.isInteger(value) || value > Number.MAX_SAFE_INTEGER) {\n        this.errors.push(new ValueOverflowError(value.toString()));\n        return;\n      }\n      value = BigInt(value);\n    }\n\n    if (!signed) {\n      // Check if the value is within the bounds of an unsigned integer\n      const limit = 1n << sizeInBits;\n      if (value < 0 || value >= limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\n      }\n    } else {\n      // Check if the value is within the bounds of a signed integer\n      const limit = 1n << (sizeInBits - 1n);\n      if (value >= limit || value < -limit) {\n        this.errors.push(new ValueOverflowError(value.toString(), limit - 1n));\n        return;\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 (value < 0n) {\n        const mask = (1n << sizeInBits) - 1n;\n        value = -value;\n        value = (~value & mask) + 1n;\n      }\n    }\n    return value;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["hexaStringToBuffer", "DataOverflowError", "HexaStringEncodeError", "ValueOverflowError", "MAX_32_BIT_UINT", "ByteArrayBuilder", "maxPayloadSize", "value", "bigEndian", "result", "bytes", "hasLv", "sizeInBits", "signed", "converted", "sizeInBytes", "buffer", "limit", "mask"]
+}

package/lib/esm/src/api/apdu/utils/ByteArrayBuilder.test.js

@@ -0,0 +1,2 @@
+import{hexaStringToBuffer as b}from"../../utils/HexaString";import{APDU_MAX_PAYLOAD as a}from"./ApduBuilder";import{DataOverflowError as l,HexaStringEncodeError as d}from"./AppBuilderError";import{ByteArrayBuilder as n}from"./ByteArrayBuilder";const u=new Uint8Array([]),y=new Uint8Array([1]),A=new Uint8Array([128,129,130,131,132]),p=new Uint8Array([133,134,135,136]),E=new Uint8Array([3,161,162,163]),w=new Uint8Array([5,109,97,109,97,110]),s=new Uint8Array([2,240,241]),h=new Uint8Array([1,51,2,1,35,69,103,128,129,130,131,132,133,134,135,136,3,161,162,163,5,109,97,109,97,110,2,240,241]),i=new Uint8Array([...Array(255).fill(170)]),g=new Uint8Array([...Array(254).fill(170)]);let f;describe("ByteArrayBuilder",()=>{const x=(e,t,r,o)=>{if(o)switch(r){case 2:f.add16BitIntToData(e,t);break;case 4:f.add32BitIntToData(e,t);break;case 8:f.add64BitIntToData(e,t);break;case 16:f.add128BitIntToData(e,t);break;case 32:f.add256BitIntToData(e,t);break}else switch(r){case 2:f.add16BitUIntToData(e,t);break;case 4:f.add32BitUIntToData(e,t);break;case 8:f.add64BitUIntToData(e,t);break;case 16:f.add128BitUIntToData(e,t);break;case 32:f.add256BitUIntToData(e,t);break}};describe("clean",()=>{beforeEach(()=>{f=new n(a)}),it("should create an instance",()=>{expect(f).toBeDefined(),expect(f).toBeInstanceOf(n)})}),describe("simple",()=>{beforeEach(()=>{f=new n(a)}),it("should serialize with an empty body",()=>{expect(f.build()).toEqual(u)}),it("should serialize with an single byte body",()=>{f=new n(1),f.add8BitUIntToData(1),expect(f.build()).toEqual(y),expect(f.getErrors()).toEqual([])}),it.each([[2,!1,!0,13058,"3302"],[2,!1,!1,0x3302n,"0233"],[2,!0,!0,4200n,"1068"],[2,!0,!0,-4200n,"ef98"],[2,!0,!1,4200,"6810"],[2,!0,!1,-4200,"98ef"],[4,!1,!0,0x01234567n,"01234567"],[4,!1,!1,0x01234567n,"67452301"],[4,!0,!0,123456789,"075bcd15"],[4,!0,!0,-123456789,"f8a432eb"],[4,!0,!1,123456789,"15cd5b07"],[4,!0,!1,-123456789,"eb32a4f8"],[8,!1,!0,14147778004927559n,"0032435442584447"],[8,!1,!1,14147778004927559n,"4744584254433200"],[8,!0,!0,14147778004927559n,"0032435442584447"],[8,!0,!0,-14147778004927559n,"ffcdbcabbda7bbb9"],[8,!0,!1,14147778004927559n,"4744584254433200"],[8,!0,!1,-14147778004927559n,"b9bba7bdabbccdff"],[16,!1,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!1,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!0,0x00324354425844470032435442584447n,"00324354425844470032435442584447"],[16,!0,!0,-0x00324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[16,!0,!1,0x00324354425844470032435442584447n,"47445842544332004744584254433200"],[16,!0,!1,-0x00324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdff"],[32,!1,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!1,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!0,0x0032435442584447003243544258444700324354425844470032435442584447n,"0032435442584447003243544258444700324354425844470032435442584447"],[32,!0,!0,-0x0032435442584447003243544258444700324354425844470032435442584447n,"ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb8ffcdbcabbda7bbb9"],[32,!0,!1,0x0032435442584447003243544258444700324354425844470032435442584447n,"4744584254433200474458425443320047445842544332004744584254433200"],[32,!0,!1,-0x0032435442584447003243544258444700324354425844470032435442584447n,"b9bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdffb8bba7bdabbccdff"]])("serialize the following number: size %i, signed %s, bigEndian %s, value %i, expected %s",(e,t,r,o,c)=>{f=new n(e),x(o,r,e,t),expect(f.build()).toEqual(b(c)),expect(f.getErrors()).toEqual([]),f=new n(e-1),x(o,r,e,t),expect(f.getErrors().length).toEqual(1),expect(f.build()).toEqual(Uint8Array.from([]))}),it.each([[2,!1,!0,0xffffn,"ffff"],[2,!0,!0,0x7fffn,"7fff"],[2,!0,!0,-0x8000n,"8000"],[4,!1,!0,0xffffffffn,"ffffffff"],[4,!0,!0,0x7fffffffn,"7fffffff"],[4,!0,!0,-0x80000000n,"80000000"],[8,!1,!0,0xffffffffffffffffn,"ffffffffffffffff"],[8,!0,!0,0x7fffffffffffffffn,"7fffffffffffffff"],[8,!0,!0,-0x8000000000000000n,"8000000000000000"],[16,!1,!0,0xffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffff"],[16,!0,!0,0x7fffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffff"],[16,!0,!0,-0x80000000000000000000000000000000n,"80000000000000000000000000000000"],[32,!1,!0,0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,"7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],[32,!0,!0,-0x8000000000000000000000000000000000000000000000000000000000000000n,"8000000000000000000000000000000000000000000000000000000000000000"]])("serialize the number to the limit: size %i, signed %s, bigEndian %s, value %i, expected %s",(e,t,r,o,c)=>{f=new n(e),x(o,r,e,t),expect(f.build()).toEqual(b(c)),expect(f.getErrors()).toEqual([])}),it("Serialize from float to bigint",()=>{f=new n(4),f.add32BitIntToData(1234567893e-1,!1),expect(f.getErrors().length).toEqual(1),expect(f.build()).toEqual(Uint8Array.from([]))}),it("should serialize with an 5 byte body from an hexastring",()=>{f.addHexaStringToData("0x8081828384"),expect(f.build()).toEqual(A),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body from an hexastring without '0x'",()=>{f.addHexaStringToData("85868788"),expect(f.build()).toEqual(p),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an hexastring",()=>{f.encodeInLVFromHexa("0xA1A2A3"),expect(f.build()).toEqual(E),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from an ascci string",()=>{f.encodeInLVFromAscii("maman"),expect(f.build()).toEqual(w),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const e=new Uint8Array([240,241]);f.encodeInLVFromBuffer(e),expect(f.build()).toEqual(s),expect(f.getErrors()).toEqual([])}),it("should serialize with an 4 byte body LV encoded from a buffer",()=>{const e=new Uint8Array([240,241]);f.encodeInLVFromBuffer(e),expect(f.build()).toEqual(s),expect(f.getErrors()).toEqual([])}),it("should serialize with an complete body of 0xAA",()=>{const e=new Uint8Array(255).fill(170,0,255);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getErrors()).toEqual([])})}),describe("mixed",()=>{beforeEach(()=>{f=new n(a)}),it("should serialize with all previous field",()=>{let e=a;f.add8BitUIntToData(1),e--,expect(f.getAvailablePayloadLength()).toBe(e),f.add16BitUIntToData(13058),e-=2,expect(f.getAvailablePayloadLength()).toBe(e),f.add32BitUIntToData(19088743),e-=4,expect(f.getAvailablePayloadLength()).toBe(e),f.addHexaStringToData("0x8081828384"),e-=5,expect(f.getAvailablePayloadLength()).toBe(e),f.addHexaStringToData("85868788"),e-=4,expect(f.getAvailablePayloadLength()).toBe(e),f.encodeInLVFromHexa("0xA1A2A3"),e-=4,expect(f.getAvailablePayloadLength()).toBe(e),f.encodeInLVFromAscii("maman"),e-=6,expect(f.getAvailablePayloadLength()).toBe(e);const t=new Uint8Array([240,241]);f.encodeInLVFromBuffer(t),e-=3,expect(f.getAvailablePayloadLength()).toBe(e),expect(f.build()).toEqual(h)})}),describe("error",()=>{beforeEach(()=>{f=new n(a)}),it.each([[2,!1,!0,0x10000n],[2,!0,!0,0x8000n],[2,!0,!0,-0x8001n],[4,!1,!0,0x100000000n],[4,!0,!0,0x80000000n],[4,!0,!0,-0x80000001n],[8,!1,!0,0x10000000000000000n],[8,!0,!0,0x8000000000000000n],[8,!0,!0,-0x8000000000000001n]])("serialize the number overflowed: size %i, signed %s, bigEndian %s, value %i",(e,t,r,o)=>{f=new n(e),x(o,r,e,t),expect(f.getErrors().length).toEqual(1),expect(f.build()).toEqual(Uint8Array.from([]))}),it("error due to a string not well coded",()=>{f.addHexaStringToData(":08081828384").addHexaStringToData("80818n8384").addHexaStringToData("808182838z"),expect(f.build()).toEqual(u),expect(f.getAvailablePayloadLength()).toBe(a),expect(f.getErrors()).toEqual([new d(":08081828384"),new d("80818n8384"),new d("808182838z")])}),it("error due direct overflow",()=>{const e=new Uint8Array(256).fill(170,0,256);f.addBufferToData(e),expect(f.build()).toEqual(u),expect(f.getAvailablePayloadLength()).toBe(a),expect(f.getErrors()).toEqual([new l(e.toString())])}),it("error due to subsequent overflow with 1-byte array",()=>{const e=new Uint8Array(a).fill(170,0,a);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0);const t=new Uint8Array(1);t.set([255],0),f.addBufferToData(t),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),expect(f.getErrors()).toEqual([new l(t.toString())])}),it("error due to subsequent overflow with 1-char ascii",()=>{const e=new Uint8Array(a).fill(170,0,a);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0);const t="a";f.addAsciiStringToData(t),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),expect(f.getErrors()).toEqual([new l(new TextEncoder().encode(t).toString())])}),it("error due to subsequent overflow with 1-char hexastring",()=>{const e=new Uint8Array(a).fill(170,0,a);f.addBufferToData(e),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),f.addHexaStringToData("0xB4").addHexaStringToData("e1"),expect(f.build()).toEqual(i),expect(f.getAvailablePayloadLength()).toBe(0),expect(f.getErrors()).toEqual([new l("180"),new l("225")])}),it("error due to empty values",()=>{const e="";f.addHexaStringToData(e).encodeInLVFromHexa(e),expect(f.build()).toEqual(u),expect(f.getAvailablePayloadLength()).toBe(a),expect(f.getErrors()).toEqual([new d(e),new d(e)])}),it("error due to subsequent overflow with 1-char LV",()=>{const e=new Uint8Array(a-1).fill(170,0,a-1);f.addBufferToData(e),expect(f.build()).toEqual(g),expect(f.getAvailablePayloadLength()).toBe(1);const t="n",r="e1",o=new Uint8Array(1);o.set([255],0),f.encodeInLVFromAscii(t).encodeInLVFromHexa(r).encodeInLVFromBuffer(o),expect(f.build()).toEqual(g),expect(f.getAvailablePayloadLength()).toBe(1),expect(f.getErrors()).toEqual([new l(t),new l(r),new l(o.toString())])})})});
+//# sourceMappingURL=ByteArrayBuilder.test.js.map