@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol 0.0.0-legacy-speculos-datasource-20250821095840 → 0.0.0-lifi-with-logger-20251208144248

package/lib/esm/api/crypto/noble/NobleCryptoService.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleCryptoService.test.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\n\nimport { Curve, EncryptionAlgo, HashAlgo } from \"@api/crypto/CryptoService\";\n\nimport { NobleCryptoService } from \"./NobleCryptoService\";\nimport { NobleKey } from \"./NobleKey\";\nimport { NobleKeyPair } from \"./NobleKeyPair\";\n\ndescribe(\"NobleCryptoService\", () => {\n  let cryptoService: NobleCryptoService;\n\n  beforeEach(() => {\n    cryptoService = new NobleCryptoService();\n  });\n\n  it(\"should generate random bytes of correct length\", () => {\n    const length = 32;\n    const bytes = cryptoService.randomBytes(length);\n    expect(bytes.length).toBe(length);\n  });\n\n  it(\"should hash data correctly with SHA256\", () => {\n    const data = new TextEncoder().encode(\"test\");\n    const hashResult = cryptoService.hash(data, HashAlgo.SHA256);\n    expect(hashResult).toEqual(\n      hexaStringToBuffer(\n        \"9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08\",\n      )!,\n    );\n  });\n\n  it(\"should compute HMAC correctly with SHA256\", () => {\n    const key = new Uint8Array(32).fill(0x61);\n    const message = new TextEncoder().encode(\"test message\");\n    const hmacResult = cryptoService.hmac(key, message, HashAlgo.SHA256);\n    expect(hmacResult).toEqual(\n      hexaStringToBuffer(\n        \"0b19ad8fef1660f7a191465effeea922079633ada962f52cb60103d9935cc460\",\n      )!,\n    );\n  });\n\n  it(\"should create a key pair\", async () => {\n    const keyPair = await cryptoService.createKeyPair(Curve.K256);\n    expect(keyPair instanceof NobleKeyPair).toBeTruthy();\n  });\n\n  it(\"should import a key pair\", () => {\n    const privateKey = new Uint8Array(32).fill(1);\n    const keyPair = cryptoService.importKeyPair(privateKey, Curve.K256);\n    expect(keyPair instanceof NobleKeyPair).toBeTruthy();\n  });\n\n  it(\"should create a symmetric key\", async () => {\n    const symmetricKey = await cryptoService.createSymmetricKey(\n      EncryptionAlgo.AES256_GCM,\n    );\n    expect(symmetricKey instanceof NobleKey).toBeTruthy();\n  });\n\n  it(\"should import a symmetric key\", () => {\n    const keyMaterial = new Uint8Array(32).fill(1);\n    const symmetricKey = cryptoService.importSymmetricKey(\n      keyMaterial,\n      EncryptionAlgo.AES256_GCM,\n    );\n    expect(symmetricKey instanceof NobleKey).toBeTruthy();\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,sBAAAA,MAA0B,kCAEnC,OAAS,SAAAC,EAAO,kBAAAC,EAAgB,YAAAC,MAAgB,4BAEhD,OAAS,sBAAAC,MAA0B,uBACnC,OAAS,YAAAC,MAAgB,aACzB,OAAS,gBAAAC,MAAoB,iBAE7B,SAAS,qBAAsB,IAAM,CACnC,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAgB,IAAIH,CACtB,CAAC,EAED,GAAG,iDAAkD,IAAM,CAEzD,MAAMI,EAAQD,EAAc,YAAY,EAAM,EAC9C,OAAOC,EAAM,MAAM,EAAE,KAAK,EAAM,CAClC,CAAC,EAED,GAAG,yCAA0C,IAAM,CACjD,MAAMC,EAAO,IAAI,YAAY,EAAE,OAAO,MAAM,EACtCC,EAAaH,EAAc,KAAKE,EAAMN,EAAS,MAAM,EAC3D,OAAOO,CAAU,EAAE,QACjBV,EACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMW,EAAM,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EAClCC,EAAU,IAAI,YAAY,EAAE,OAAO,cAAc,EACjDC,EAAaN,EAAc,KAAKI,EAAKC,EAAST,EAAS,MAAM,EACnE,OAAOU,CAAU,EAAE,QACjBb,EACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,2BAA4B,SAAY,CACzC,MAAMc,EAAU,MAAMP,EAAc,cAAcN,EAAM,IAAI,EAC5D,OAAOa,aAAmBR,CAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,2BAA4B,IAAM,CACnC,MAAMS,EAAa,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACtCD,EAAUP,EAAc,cAAcQ,EAAYd,EAAM,IAAI,EAClE,OAAOa,aAAmBR,CAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,gCAAiC,SAAY,CAC9C,MAAMU,EAAe,MAAMT,EAAc,mBACvCL,EAAe,UACjB,EACA,OAAOc,aAAwBX,CAAQ,EAAE,WAAW,CACtD,CAAC,EAED,GAAG,gCAAiC,IAAM,CACxC,MAAMY,EAAc,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACvCD,EAAeT,EAAc,mBACjCU,EACAf,EAAe,UACjB,EACA,OAAOc,aAAwBX,CAAQ,EAAE,WAAW,CACtD,CAAC,CACH,CAAC",
+  "names": ["hexaStringToBuffer", "Curve", "EncryptionAlgo", "HashAlgo", "NobleCryptoService", "NobleKey", "NobleKeyPair", "cryptoService", "bytes", "data", "hashResult", "key", "message", "hmacResult", "keyPair", "privateKey", "symmetricKey", "keyMaterial"]
+}

package/lib/esm/api/crypto/noble/NobleKey.js

@@ -0,0 +1,2 @@
+import{gcm as i}from"@noble/ciphers/aes";import{randomBytes as c}from"@noble/ciphers/webcrypto";import{EncryptionAlgo as e}from"../../crypto/CryptoService";import{AES256_BLOCK_SIZE as o,AES256_KEY_SIZE as p}from"../../crypto/Key";class n{constructor(r){this.key=r}static async generate(r=e.AES256_GCM){if(r!==e.AES256_GCM)throw new Error(`Unsupported encryption algorithm ${r}`);return new n(c(p))}static from(r,t=e.AES256_GCM){if(t!==e.AES256_GCM)throw new Error(`Unsupported encryption algorithm ${t}`);return new n(r)}async encrypt(r,t){return i(this.key,r.slice(0,o)).encrypt(t)}async decrypt(r,t){return i(this.key,r.slice(0,o)).decrypt(t)}}export{n as NobleKey};
+//# sourceMappingURL=NobleKey.js.map

package/lib/esm/api/crypto/noble/NobleKey.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKey.ts"],
+  "sourcesContent": ["import { gcm } from \"@noble/ciphers/aes\";\nimport { randomBytes } from \"@noble/ciphers/webcrypto\";\n\nimport { EncryptionAlgo } from \"@api/crypto/CryptoService\";\nimport { AES256_BLOCK_SIZE, AES256_KEY_SIZE, type Key } from \"@api/crypto/Key\";\n\nexport class NobleKey implements Key {\n  static async generate(\n    algo: EncryptionAlgo = EncryptionAlgo.AES256_GCM,\n  ): Promise<NobleKey> {\n    if (algo !== EncryptionAlgo.AES256_GCM) {\n      throw new Error(`Unsupported encryption algorithm ${algo}`);\n    }\n    return new NobleKey(randomBytes(AES256_KEY_SIZE));\n  }\n\n  static from(\n    keyMaterial: Uint8Array,\n    algo: EncryptionAlgo = EncryptionAlgo.AES256_GCM,\n  ): NobleKey {\n    if (algo !== EncryptionAlgo.AES256_GCM) {\n      throw new Error(`Unsupported encryption algorithm ${algo}`);\n    }\n    return new NobleKey(keyMaterial);\n  }\n\n  private constructor(private key: Uint8Array) {}\n\n  async encrypt(iv: Uint8Array, data: Uint8Array): Promise<Uint8Array> {\n    const cipher = gcm(this.key, iv.slice(0, AES256_BLOCK_SIZE));\n    return cipher.encrypt(data);\n  }\n\n  async decrypt(\n    iv: Uint8Array,\n    encryptedData: Uint8Array,\n  ): Promise<Uint8Array> {\n    const cipher = gcm(this.key, iv.slice(0, AES256_BLOCK_SIZE));\n    return cipher.decrypt(encryptedData);\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,OAAAA,MAAW,qBACpB,OAAS,eAAAC,MAAmB,2BAE5B,OAAS,kBAAAC,MAAsB,4BAC/B,OAAS,qBAAAC,EAAmB,mBAAAC,MAAiC,kBAEtD,MAAMC,CAAwB,CAoB3B,YAAoBC,EAAiB,CAAjB,SAAAA,CAAkB,CAnB9C,aAAa,SACXC,EAAuBL,EAAe,WACnB,CACnB,GAAIK,IAASL,EAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCK,CAAI,EAAE,EAE5D,OAAO,IAAIF,EAASJ,EAAYG,CAAe,CAAC,CAClD,CAEA,OAAO,KACLI,EACAD,EAAuBL,EAAe,WAC5B,CACV,GAAIK,IAASL,EAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCK,CAAI,EAAE,EAE5D,OAAO,IAAIF,EAASG,CAAW,CACjC,CAIA,MAAM,QAAQC,EAAgBC,EAAuC,CAEnE,OADeV,EAAI,KAAK,IAAKS,EAAG,MAAM,EAAGN,CAAiB,CAAC,EAC7C,QAAQO,CAAI,CAC5B,CAEA,MAAM,QACJD,EACAE,EACqB,CAErB,OADeX,EAAI,KAAK,IAAKS,EAAG,MAAM,EAAGN,CAAiB,CAAC,EAC7C,QAAQQ,CAAa,CACrC,CACF",
+  "names": ["gcm", "randomBytes", "EncryptionAlgo", "AES256_BLOCK_SIZE", "AES256_KEY_SIZE", "NobleKey", "key", "algo", "keyMaterial", "iv", "data", "encryptedData"]
+}

package/lib/esm/api/crypto/noble/NobleKey.test.js

@@ -0,0 +1,2 @@
+import{AES256_BLOCK_SIZE as r,AES256_KEY_SIZE as i}from"../../crypto/Key";import{NobleKey as o}from"./NobleKey";describe("NobleKey",()=>{const t=new TextEncoder().encode("Test Data");it("should encrypt and decrypt data correctly",async()=>{const c=await o.generate(),e=new Uint8Array(r).fill(2),a=await c.encrypt(e,t),n=await c.decrypt(e,a);expect(a).not.toEqual(t),expect(n).toEqual(t)}),it("should encrypt and decrypt data from key material",async()=>{const c=new Uint8Array(i).fill(1),e=o.from(c),a=new Uint8Array(r).fill(2),n=await e.encrypt(a,t),y=await e.decrypt(a,n);expect(n).not.toEqual(t),expect(y).toEqual(t)})});
+//# sourceMappingURL=NobleKey.test.js.map

package/lib/esm/api/crypto/noble/NobleKey.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKey.test.ts"],
+  "sourcesContent": ["import { AES256_BLOCK_SIZE, AES256_KEY_SIZE } from \"@api/crypto/Key\";\n\nimport { NobleKey } from \"./NobleKey\";\n\ndescribe(\"NobleKey\", () => {\n  const testData = new TextEncoder().encode(\"Test Data\");\n\n  it(\"should encrypt and decrypt data correctly\", async () => {\n    const key = await NobleKey.generate();\n    const iv = new Uint8Array(AES256_BLOCK_SIZE).fill(0x02);\n    const encryptedData = await key.encrypt(iv, testData);\n    const decryptedData = await key.decrypt(iv, encryptedData);\n\n    expect(encryptedData).not.toEqual(testData);\n    expect(decryptedData).toEqual(testData);\n  });\n\n  it(\"should encrypt and decrypt data from key material\", async () => {\n    const keyMaterial = new Uint8Array(AES256_KEY_SIZE).fill(0x01);\n    const key = NobleKey.from(keyMaterial);\n    const iv = new Uint8Array(AES256_BLOCK_SIZE).fill(0x02);\n    const encryptedData = await key.encrypt(iv, testData);\n    const decryptedData = await key.decrypt(iv, encryptedData);\n\n    expect(encryptedData).not.toEqual(testData);\n    expect(decryptedData).toEqual(testData);\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,qBAAAA,EAAmB,mBAAAC,MAAuB,kBAEnD,OAAS,YAAAC,MAAgB,aAEzB,SAAS,WAAY,IAAM,CACzB,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,4CAA6C,SAAY,CAC1D,MAAMC,EAAM,MAAMF,EAAS,SAAS,EAC9BG,EAAK,IAAI,WAAWL,CAAiB,EAAE,KAAK,CAAI,EAChDM,EAAgB,MAAMF,EAAI,QAAQC,EAAIF,CAAQ,EAC9CI,EAAgB,MAAMH,EAAI,QAAQC,EAAIC,CAAa,EAEzD,OAAOA,CAAa,EAAE,IAAI,QAAQH,CAAQ,EAC1C,OAAOI,CAAa,EAAE,QAAQJ,CAAQ,CACxC,CAAC,EAED,GAAG,oDAAqD,SAAY,CAClE,MAAMK,EAAc,IAAI,WAAWP,CAAe,EAAE,KAAK,CAAI,EACvDG,EAAMF,EAAS,KAAKM,CAAW,EAC/BH,EAAK,IAAI,WAAWL,CAAiB,EAAE,KAAK,CAAI,EAChDM,EAAgB,MAAMF,EAAI,QAAQC,EAAIF,CAAQ,EAC9CI,EAAgB,MAAMH,EAAI,QAAQC,EAAIC,CAAa,EAEzD,OAAOA,CAAa,EAAE,IAAI,QAAQH,CAAQ,EAC1C,OAAOI,CAAa,EAAE,QAAQJ,CAAQ,CACxC,CAAC,CACH,CAAC",
+  "names": ["AES256_BLOCK_SIZE", "AES256_KEY_SIZE", "NobleKey", "testData", "key", "iv", "encryptedData", "decryptedData", "keyMaterial"]
+}

package/lib/esm/api/crypto/noble/NobleKeyPair.js

@@ -0,0 +1,2 @@
+import{bufferToHexaString as n}from"@ledgerhq/device-management-kit";import{p256 as u}from"@noble/curves/nist.js";import{secp256k1 as o}from"@noble/curves/secp256k1.js";import{Curve as s}from"../../crypto/CryptoService";import{SigFormat as c}from"../../crypto/KeyPair";class i{constructor(r,e,t){this.curve=r;this.privateKey=e;this.publicKey=t}static async generate(r){const e=i.getCurve(r),{secretKey:t,publicKey:a}=e.keygen();return new i(e,t,a)}static from(r,e){const t=i.getCurve(e),a=t.getPublicKey(r);return new i(t,r,a)}static getCurve(r){switch(r){case s.K256:return o;case s.P256:return u;default:throw new Error(`Unsupported curve ${r}`)}}get id(){return n(this.privateKey)}async sign(r,e){return this.curve.sign(r,this.privateKey).toBytes(e===c.DER?"der":"compact")}async verify(r,e,t){return this.curve.verify(e,r,this.publicKey,{format:t===c.DER?"der":"compact"})}async deriveSharedSecret(r,e=!0){return this.curve.getSharedSecret(this.privateKey,r,e)}getPublicKey(){return this.publicKey}getPublicKeyToHex(){return n(this.publicKey,!1)}}export{i as NobleKeyPair};
+//# sourceMappingURL=NobleKeyPair.js.map

package/lib/esm/api/crypto/noble/NobleKeyPair.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKeyPair.ts"],
+  "sourcesContent": ["import { bufferToHexaString } from \"@ledgerhq/device-management-kit\";\nimport type { CurveFn } from \"@noble/curves/abstract/weierstrass.js\";\nimport { p256 } from \"@noble/curves/nist.js\";\nimport { secp256k1 } from \"@noble/curves/secp256k1.js\";\n\nimport { Curve } from \"@api/crypto/CryptoService\";\nimport { type KeyPair, SigFormat } from \"@api/crypto/KeyPair\";\n\nexport class NobleKeyPair implements KeyPair {\n  static async generate(curve: Curve): Promise<NobleKeyPair> {\n    const curveImpl = NobleKeyPair.getCurve(curve);\n    const { secretKey, publicKey } = curveImpl.keygen();\n    return new NobleKeyPair(curveImpl, secretKey, publicKey);\n  }\n\n  static from(privateKey: Uint8Array, curve: Curve): NobleKeyPair {\n    const curveImpl = NobleKeyPair.getCurve(curve);\n    const publicKey = curveImpl.getPublicKey(privateKey);\n    return new NobleKeyPair(curveImpl, privateKey, publicKey);\n  }\n\n  private static getCurve(curve: Curve): CurveFn {\n    switch (curve) {\n      case Curve.K256:\n        return secp256k1;\n      case Curve.P256:\n        return p256;\n      default:\n        throw new Error(`Unsupported curve ${curve}`);\n    }\n  }\n\n  private constructor(\n    private curve: CurveFn,\n    private privateKey: Uint8Array,\n    private publicKey: Uint8Array,\n  ) {}\n\n  get id() {\n    return bufferToHexaString(this.privateKey);\n  }\n\n  async sign(data: Uint8Array, format?: SigFormat): Promise<Uint8Array> {\n    return this.curve\n      .sign(data, this.privateKey)\n      .toBytes(format === SigFormat.DER ? \"der\" : \"compact\");\n  }\n\n  async verify(\n    data: Uint8Array,\n    signature: Uint8Array,\n    format?: SigFormat,\n  ): Promise<boolean> {\n    return this.curve.verify(signature, data, this.publicKey, {\n      format: format === SigFormat.DER ? \"der\" : \"compact\",\n    });\n  }\n\n  async deriveSharedSecret(\n    peerPublicKey: Uint8Array,\n    isCompressed: boolean = true,\n  ): Promise<Uint8Array> {\n    return this.curve.getSharedSecret(\n      this.privateKey,\n      peerPublicKey,\n      isCompressed,\n    );\n  }\n\n  getPublicKey(): Uint8Array {\n    return this.publicKey;\n  }\n\n  getPublicKeyToHex(): string {\n    return bufferToHexaString(this.publicKey, false);\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,sBAAAA,MAA0B,kCAEnC,OAAS,QAAAC,MAAY,wBACrB,OAAS,aAAAC,MAAiB,6BAE1B,OAAS,SAAAC,MAAa,4BACtB,OAAuB,aAAAC,MAAiB,sBAEjC,MAAMC,CAAgC,CAwBnC,YACEC,EACAC,EACAC,EACR,CAHQ,WAAAF,EACA,gBAAAC,EACA,eAAAC,CACP,CA3BH,aAAa,SAASF,EAAqC,CACzD,MAAMG,EAAYJ,EAAa,SAASC,CAAK,EACvC,CAAE,UAAAI,EAAW,UAAAF,CAAU,EAAIC,EAAU,OAAO,EAClD,OAAO,IAAIJ,EAAaI,EAAWC,EAAWF,CAAS,CACzD,CAEA,OAAO,KAAKD,EAAwBD,EAA4B,CAC9D,MAAMG,EAAYJ,EAAa,SAASC,CAAK,EACvCE,EAAYC,EAAU,aAAaF,CAAU,EACnD,OAAO,IAAIF,EAAaI,EAAWF,EAAYC,CAAS,CAC1D,CAEA,OAAe,SAASF,EAAuB,CAC7C,OAAQA,EAAO,CACb,KAAKH,EAAM,KACT,OAAOD,EACT,KAAKC,EAAM,KACT,OAAOF,EACT,QACE,MAAM,IAAI,MAAM,qBAAqBK,CAAK,EAAE,CAChD,CACF,CAQA,IAAI,IAAK,CACP,OAAON,EAAmB,KAAK,UAAU,CAC3C,CAEA,MAAM,KAAKW,EAAkBC,EAAyC,CACpE,OAAO,KAAK,MACT,KAAKD,EAAM,KAAK,UAAU,EAC1B,QAAQC,IAAWR,EAAU,IAAM,MAAQ,SAAS,CACzD,CAEA,MAAM,OACJO,EACAE,EACAD,EACkB,CAClB,OAAO,KAAK,MAAM,OAAOC,EAAWF,EAAM,KAAK,UAAW,CACxD,OAAQC,IAAWR,EAAU,IAAM,MAAQ,SAC7C,CAAC,CACH,CAEA,MAAM,mBACJU,EACAC,EAAwB,GACH,CACrB,OAAO,KAAK,MAAM,gBAChB,KAAK,WACLD,EACAC,CACF,CACF,CAEA,cAA2B,CACzB,OAAO,KAAK,SACd,CAEA,mBAA4B,CAC1B,OAAOf,EAAmB,KAAK,UAAW,EAAK,CACjD,CACF",
+  "names": ["bufferToHexaString", "p256", "secp256k1", "Curve", "SigFormat", "NobleKeyPair", "curve", "privateKey", "publicKey", "curveImpl", "secretKey", "data", "format", "signature", "peerPublicKey", "isCompressed"]
+}

package/lib/esm/api/crypto/noble/NobleKeyPair.test.js

@@ -0,0 +1,2 @@
+import{Curve as r}from"../../crypto/CryptoService";import{SigFormat as n}from"../../crypto/KeyPair";import{NobleKeyPair as i}from"./NobleKeyPair";describe("NobleKeyPair",()=>{const c=new TextEncoder().encode("Test Data");it("should generate a key pair with correct public key",async()=>{const e=(await i.generate(r.K256)).getPublicKey();expect(e).toBeDefined(),expect(e.byteLength).toBeGreaterThan(0)}),it("should create a key pair from a private key",()=>{const t=new Uint8Array(32).fill(1),e=i.from(t,r.K256);expect(e.getPublicKey()).toBeDefined()}),it("should sign and verify data correctly",async()=>{const t=await i.generate(r.K256),e=await t.sign(c),a=await t.verify(c,e);expect(a).toBeTruthy()}),it("should sign and verify data correctly, in DER format",async()=>{const t=await i.generate(r.K256),e=await t.sign(c,n.DER),a=await t.verify(c,e,n.DER);expect(a).toBeTruthy()}),it("should derive a shared secret with another public key",async()=>{const t=await i.generate(r.K256),e=await i.generate(r.K256),a=await t.deriveSharedSecret(e.getPublicKey()),o=await e.deriveSharedSecret(t.getPublicKey());expect(a).toBeDefined(),expect(a.byteLength).toBeGreaterThan(0),expect(a).toStrictEqual(o)}),it("should convert public key to hex string",async()=>{const e=(await i.generate(r.K256)).getPublicKeyToHex();expect(typeof e).toBe("string"),expect(e.length).toBeGreaterThan(0)})});
+//# sourceMappingURL=NobleKeyPair.test.js.map

package/lib/esm/api/crypto/noble/NobleKeyPair.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKeyPair.test.ts"],
+  "sourcesContent": ["import { Curve } from \"@api/crypto/CryptoService\";\nimport { SigFormat } from \"@api/crypto/KeyPair\";\n\nimport { NobleKeyPair } from \"./NobleKeyPair\";\n\ndescribe(\"NobleKeyPair\", () => {\n  const testData = new TextEncoder().encode(\"Test Data\");\n\n  it(\"should generate a key pair with correct public key\", async () => {\n    const keyPair = await NobleKeyPair.generate(Curve.K256);\n    const publicKey = keyPair.getPublicKey();\n    expect(publicKey).toBeDefined();\n    expect(publicKey.byteLength).toBeGreaterThan(0);\n  });\n\n  it(\"should create a key pair from a private key\", () => {\n    const privateKey = new Uint8Array(32).fill(1);\n    const keyPair = NobleKeyPair.from(privateKey, Curve.K256);\n    expect(keyPair.getPublicKey()).toBeDefined();\n  });\n\n  it(\"should sign and verify data correctly\", async () => {\n    const keyPair = await NobleKeyPair.generate(Curve.K256);\n    const signature = await keyPair.sign(testData);\n    const isVerified = await keyPair.verify(testData, signature);\n    expect(isVerified).toBeTruthy();\n  });\n\n  it(\"should sign and verify data correctly, in DER format\", async () => {\n    const keyPair = await NobleKeyPair.generate(Curve.K256);\n    const signature = await keyPair.sign(testData, SigFormat.DER);\n    const isVerified = await keyPair.verify(testData, signature, SigFormat.DER);\n    expect(isVerified).toBeTruthy();\n  });\n\n  it(\"should derive a shared secret with another public key\", async () => {\n    const keyPair = await NobleKeyPair.generate(Curve.K256);\n    const otherKeyPair = await NobleKeyPair.generate(Curve.K256);\n    const sharedSecret1 = await keyPair.deriveSharedSecret(\n      otherKeyPair.getPublicKey(),\n    );\n    const sharedSecret2 = await otherKeyPair.deriveSharedSecret(\n      keyPair.getPublicKey(),\n    );\n\n    expect(sharedSecret1).toBeDefined();\n    expect(sharedSecret1.byteLength).toBeGreaterThan(0);\n    expect(sharedSecret1).toStrictEqual(sharedSecret2);\n  });\n\n  it(\"should convert public key to hex string\", async () => {\n    const keyPair = await NobleKeyPair.generate(Curve.K256);\n    const hexPublicKey = keyPair.getPublicKeyToHex();\n    expect(typeof hexPublicKey).toBe(\"string\");\n    expect(hexPublicKey.length).toBeGreaterThan(0);\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,SAAAA,MAAa,4BACtB,OAAS,aAAAC,MAAiB,sBAE1B,OAAS,gBAAAC,MAAoB,iBAE7B,SAAS,eAAgB,IAAM,CAC7B,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,qDAAsD,SAAY,CAEnE,MAAMC,GADU,MAAMF,EAAa,SAASF,EAAM,IAAI,GAC5B,aAAa,EACvC,OAAOI,CAAS,EAAE,YAAY,EAC9B,OAAOA,EAAU,UAAU,EAAE,gBAAgB,CAAC,CAChD,CAAC,EAED,GAAG,8CAA+C,IAAM,CACtD,MAAMC,EAAa,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACtCC,EAAUJ,EAAa,KAAKG,EAAYL,EAAM,IAAI,EACxD,OAAOM,EAAQ,aAAa,CAAC,EAAE,YAAY,CAC7C,CAAC,EAED,GAAG,wCAAyC,SAAY,CACtD,MAAMA,EAAU,MAAMJ,EAAa,SAASF,EAAM,IAAI,EAChDO,EAAY,MAAMD,EAAQ,KAAKH,CAAQ,EACvCK,EAAa,MAAMF,EAAQ,OAAOH,EAAUI,CAAS,EAC3D,OAAOC,CAAU,EAAE,WAAW,CAChC,CAAC,EAED,GAAG,uDAAwD,SAAY,CACrE,MAAMF,EAAU,MAAMJ,EAAa,SAASF,EAAM,IAAI,EAChDO,EAAY,MAAMD,EAAQ,KAAKH,EAAUF,EAAU,GAAG,EACtDO,EAAa,MAAMF,EAAQ,OAAOH,EAAUI,EAAWN,EAAU,GAAG,EAC1E,OAAOO,CAAU,EAAE,WAAW,CAChC,CAAC,EAED,GAAG,wDAAyD,SAAY,CACtE,MAAMF,EAAU,MAAMJ,EAAa,SAASF,EAAM,IAAI,EAChDS,EAAe,MAAMP,EAAa,SAASF,EAAM,IAAI,EACrDU,EAAgB,MAAMJ,EAAQ,mBAClCG,EAAa,aAAa,CAC5B,EACME,EAAgB,MAAMF,EAAa,mBACvCH,EAAQ,aAAa,CACvB,EAEA,OAAOI,CAAa,EAAE,YAAY,EAClC,OAAOA,EAAc,UAAU,EAAE,gBAAgB,CAAC,EAClD,OAAOA,CAAa,EAAE,cAAcC,CAAa,CACnD,CAAC,EAED,GAAG,0CAA2C,SAAY,CAExD,MAAMC,GADU,MAAMV,EAAa,SAASF,EAAM,IAAI,GACzB,kBAAkB,EAC/C,OAAO,OAAOY,CAAY,EAAE,KAAK,QAAQ,EACzC,OAAOA,EAAa,MAAM,EAAE,gBAAgB,CAAC,CAC/C,CAAC,CACH,CAAC",
+  "names": ["Curve", "SigFormat", "NobleKeyPair", "testData", "publicKey", "privateKey", "keyPair", "signature", "isVerified", "otherKeyPair", "sharedSecret1", "sharedSecret2", "hexPublicKey"]
+}

package/lib/esm/api/index.js

@@ -1,2 +1,2 @@
-export*from"./app-binder/AuthenticateDeviceActionTypes";export*from"./app-binder/KeypairFromBytes";export*from"./app-binder/LKRPTypes";export*from"./LedgerKeyringProtocol";export*from"./LedgerKeyringProtocolBuilder";export*from"../internal/externalTypes";
+export*from"./app-binder/AuthenticateDeviceActionTypes";export*from"./crypto/CryptoService";export*from"./crypto/Key";export*from"./crypto/KeyPair";export*from"./crypto/noble/NobleCryptoService";export*from"./crypto/noble/NobleKey";export*from"./crypto/noble/NobleKeyPair";export*from"./model/Env";export*from"./model/Errors";export*from"./model/JWT";export*from"./model/Permissions";export*from"./LedgerKeyringProtocol";export*from"./LedgerKeyringProtocolBuilder";export*from"../internal/externalTypes";
 //# sourceMappingURL=index.js.map

package/lib/esm/api/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/index.ts"],
-  "sourcesContent": ["export * from \"./app-binder/AuthenticateDeviceActionTypes\";\nexport * from \"./app-binder/KeypairFromBytes\";\nexport * from \"./app-binder/LKRPTypes\";\nexport * from \"@api/LedgerKeyringProtocol\";\nexport * from \"@api/LedgerKeyringProtocolBuilder\";\nexport * from \"@internal/externalTypes\";\n"],
-  "mappings": "AAAA,WAAc,6CACd,WAAc,gCACd,WAAc,yBACd,WAAc,6BACd,WAAc,oCACd,WAAc",
+  "sourcesContent": ["export * from \"./app-binder/AuthenticateDeviceActionTypes\";\nexport * from \"./crypto/CryptoService\";\nexport * from \"./crypto/Key\";\nexport * from \"./crypto/KeyPair\";\nexport * from \"./crypto/noble/NobleCryptoService\";\nexport * from \"./crypto/noble/NobleKey\";\nexport * from \"./crypto/noble/NobleKeyPair\";\nexport * from \"./model/Env\";\nexport * from \"./model/Errors\";\nexport * from \"./model/JWT\";\nexport * from \"./model/Permissions\";\nexport * from \"@api/LedgerKeyringProtocol\";\nexport * from \"@api/LedgerKeyringProtocolBuilder\";\nexport * from \"@internal/externalTypes\";\n"],
+  "mappings": "AAAA,WAAc,6CACd,WAAc,yBACd,WAAc,eACd,WAAc,mBACd,WAAc,oCACd,WAAc,0BACd,WAAc,8BACd,WAAc,cACd,WAAc,iBACd,WAAc,cACd,WAAc,sBACd,WAAc,6BACd,WAAc,oCACd,WAAc",
   "names": []
 }

package/lib/esm/api/model/Env.js

@@ -0,0 +1,2 @@
+var g=(e=>(e.PROD="prod",e.STAGING="staging",e))(g||{});export{g as LKRPEnv};
+//# sourceMappingURL=Env.js.map

package/lib/esm/api/model/Env.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/model/Env.ts"],
+  "sourcesContent": ["export enum LKRPEnv {\n  PROD = \"prod\",\n  STAGING = \"staging\",\n}\n"],
+  "mappings": "AAAO,IAAKA,OACVA,EAAA,KAAO,OACPA,EAAA,QAAU,UAFAA,OAAA",
+  "names": ["LKRPEnv"]
+}

package/lib/esm/api/model/Errors.js

@@ -0,0 +1,2 @@
+import{GeneralDmkError as e}from"@ledgerhq/device-management-kit";class d extends e{constructor(r){super(r.message);this.err=r;this.status=r.status,this.message=r.message}_tag="LedgerKeyringProtocolError";message;status}class i extends e{constructor(r=null,s=`Current keyPair is not a member of the trustchain${r?` ${r}`:""}.`){super(s);this.trustchainId=r;this.message=s}_tag="LedgerKeyringProtocolError"}class u extends e{constructor(r="The trustchain is outdated."){super(r);this.message=r}_tag="LedgerKeyringProtocolError"}class c extends e{constructor(r="Ledger Sync must be initialized from Ledger Live with this device."){super(r);this.message=r}_tag="LedgerKeyringProtocolError"}class g extends e{constructor(r){super(r);this.err=r}_tag="LedgerKeyringProtocolError"}class l extends e{constructor(r){super(r);this.err=r}_tag="LedgerKeyringProtocolError"}class y extends e{constructor(r){const s=r&&typeof r=="object"&&"type"in r&&typeof r.type=="number"&&`0x${r.type.toString(16).padStart(2,"0")}`;let n="Unsupported command";s&&(n+=`: ${s}`);super(n);this.command=r;this.message=n}_tag="LedgerKeyringProtocolError";message}class p extends e{constructor(r){super(r);this.message=r}_tag="LedgerKeyringProtocolError"}export{d as LKRPDataSourceError,l as LKRPMissingDataError,u as LKRPOutdatedTrustchainError,g as LKRPParsingError,c as LKRPTrustchainNotReady,i as LKRPUnauthorizedError,p as LKRPUnknownError,y as LKRPUnsupportedCommandError};
+//# sourceMappingURL=Errors.js.map

package/lib/esm/api/model/Errors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/model/Errors.ts"],
+  "sourcesContent": ["import { GeneralDmkError } from \"@ledgerhq/device-management-kit\";\n\nexport type LKRPDataSourceErrorStatus =\n  | \"UNAUTHORIZED\"\n  | \"BAD_REQUEST\"\n  | \"UNKNOWN\";\n\nexport class LKRPDataSourceError extends GeneralDmkError {\n  override _tag = \"LedgerKeyringProtocolError\";\n  public readonly message: string;\n  public readonly status: LKRPDataSourceErrorStatus;\n\n  constructor(\n    readonly err: {\n      status: LKRPDataSourceErrorStatus;\n      message: string;\n    },\n  ) {\n    super(err.message);\n    this.status = err.status;\n    this.message = err.message;\n  }\n}\n\nexport class LKRPUnauthorizedError extends GeneralDmkError {\n  override _tag = \"LedgerKeyringProtocolError\";\n  constructor(\n    readonly trustchainId: string | null = null,\n    readonly message: string = `Current keyPair is not a member of the trustchain${trustchainId ? ` ${trustchainId}` : \"\"}.`,\n  ) {\n    super(message);\n  }\n}\n\nexport class LKRPOutdatedTrustchainError extends GeneralDmkError {\n  override _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly message = \"The trustchain is outdated.\") {\n    super(message);\n  }\n}\n\nexport class LKRPTrustchainNotReady extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(\n    readonly message = \"Ledger Sync must be initialized from Ledger Live with this device.\",\n  ) {\n    super(message);\n  }\n}\n\nexport class LKRPParsingError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class LKRPMissingDataError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class LKRPUnsupportedCommandError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  readonly message: string;\n  constructor(readonly command: unknown) {\n    const commandType =\n      command &&\n      typeof command === \"object\" &&\n      \"type\" in command &&\n      typeof command.type === \"number\" &&\n      `0x${command.type.toString(16).padStart(2, \"0\")}`;\n    let message = `Unsupported command`;\n    if (commandType) message += `: ${commandType}`;\n\n    super(message);\n\n    this.message = message;\n  }\n}\n\nexport class LKRPUnknownError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly message: string) {\n    super(message);\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,kCAOzB,MAAMC,UAA4BD,CAAgB,CAKvD,YACWE,EAIT,CACA,MAAMA,EAAI,OAAO,EALR,SAAAA,EAMT,KAAK,OAASA,EAAI,OAClB,KAAK,QAAUA,EAAI,OACrB,CAbS,KAAO,6BACA,QACA,MAYlB,CAEO,MAAMC,UAA8BH,CAAgB,CAEzD,YACWI,EAA8B,KAC9BC,EAAkB,oDAAoDD,EAAe,IAAIA,CAAY,GAAK,EAAE,IACrH,CACA,MAAMC,CAAO,EAHJ,kBAAAD,EACA,aAAAC,CAGX,CANS,KAAO,4BAOlB,CAEO,MAAMC,UAAoCN,CAAgB,CAE/D,YAAqBK,EAAU,8BAA+B,CAC5D,MAAMA,CAAO,EADM,aAAAA,CAErB,CAHS,KAAO,4BAIlB,CAEO,MAAME,UAA+BP,CAAgB,CAE1D,YACWK,EAAU,qEACnB,CACA,MAAMA,CAAO,EAFJ,aAAAA,CAGX,CALkB,KAAO,4BAM3B,CAEO,MAAMG,UAAyBR,CAAgB,CAEpD,YAAqBE,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMO,UAA6BT,CAAgB,CAExD,YAAqBE,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMQ,UAAoCV,CAAgB,CAG/D,YAAqBW,EAAkB,CACrC,MAAMC,EACJD,GACA,OAAOA,GAAY,UACnB,SAAUA,GACV,OAAOA,EAAQ,MAAS,UACxB,KAAKA,EAAQ,KAAK,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,GACjD,IAAIN,EAAU,sBACVO,IAAaP,GAAW,KAAKO,CAAW,IAE5C,MAAMP,CAAO,EAVM,aAAAM,EAYnB,KAAK,QAAUN,CACjB,CAfkB,KAAO,6BAChB,OAeX,CAEO,MAAMQ,UAAyBb,CAAgB,CAEpD,YAAqBK,EAAiB,CACpC,MAAMA,CAAO,EADM,aAAAA,CAErB,CAHkB,KAAO,4BAI3B",
+  "names": ["GeneralDmkError", "LKRPDataSourceError", "err", "LKRPUnauthorizedError", "trustchainId", "message", "LKRPOutdatedTrustchainError", "LKRPTrustchainNotReady", "LKRPParsingError", "LKRPMissingDataError", "LKRPUnsupportedCommandError", "command", "commandType", "LKRPUnknownError"]
+}

package/lib/esm/api/model/JWT.js

@@ -0,0 +1 @@
+//# sourceMappingURL=JWT.js.map

package/lib/esm/api/model/Permissions.js

@@ -0,0 +1,2 @@
+var C=(f=>(f[f.OWNER=4294967295]="OWNER",f[f.CAN_ENCRYPT=1]="CAN_ENCRYPT",f[f.CAN_DERIVE=2]="CAN_DERIVE",f[f.CAN_ADD_BLOCK=4]="CAN_ADD_BLOCK",f))(C||{});export{C as Permissions};
+//# sourceMappingURL=Permissions.js.map

package/lib/esm/api/model/Permissions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/model/Permissions.ts"],
+  "sourcesContent": ["/**\n * https://ledgerhq.atlassian.net/wiki/spaces/TA/pages/5865144361/ARCH+LKRP+-+v2+specifications#Member-permissions\n */\nexport enum Permissions {\n  OWNER = 0xffffffff, // Owners of the stream have access to everything\n  CAN_ENCRYPT = 1, // The member can have access to the stream private key\n  CAN_DERIVE = 1 << 1, // The member can have access to the stream chain code (if a member have access to the private key and the chain code it is able to derive sub-streams)\n  CAN_ADD_BLOCK = 1 << 2, // The member is authorized to issue blocks in the current stream\n}\n"],
+  "mappings": "AAGO,IAAKA,OACVA,IAAA,MAAQ,YAAR,QACAA,IAAA,YAAc,GAAd,cACAA,IAAA,WAAa,GAAb,aACAA,IAAA,cAAgB,GAAhB,gBAJUA,OAAA",
+  "names": ["Permissions"]
+}

package/lib/esm/internal/DefaultLedgerKeyringProtocol.js

@@ -1,2 +1,2 @@
-import{ByteArrayBuilder as f,ByteArrayParser as h}from"@ledgerhq/device-management-kit";import{Maybe as c,Nothing as A}from"purify-ts";import{KeypairFromBytes as l}from"../api/app-binder/KeypairFromBytes";import{makeContainer as K}from"./di";import{AES_BLOCK_SIZE as u,CryptoUtils as n}from"./utils/crypto";import{useCasesTypes as U}from"./use-cases/di/useCasesTypes";class P{name;_container;constructor({dmk:r,sessionId:a,baseUrl:e}){this.name="Ledger Keyring Protocol",this._container=K({dmk:r,sessionId:a,baseUrl:e})}authenticate(r,a,e,t,o,i){return this._container.get(U.AuthenticateUseCase).execute(r,a,e,t,o,i)}encryptData(r,a){const e=new l(r),t=n.randomKeypair(),o=e.ecdh(t.pubKeyToU8a()).slice(1),i=n.hmac(new Uint8Array,o),s=n.randomBytes(16),y=n.encrypt(i,s,a),m=y.subarray(0,-u),p=y.subarray(-u);return new f().add8BitUIntToData(0).addBufferToData(t.pubKeyToU8a()).addBufferToData(s).addBufferToData(p).addBufferToData(m).build()}decryptData(r,a){const e=new h(a);return e.extract8BitUInt()!==0?A:c.sequence([c.fromNullable(e.extractFieldByLength(33)),c.fromNullable(e.extractFieldByLength(16)),c.fromNullable(e.extractFieldByLength(16)),c.fromNullable(e.extractFieldByLength(e.getUnparsedRemainingLength()))]).map(t=>{const o=t[0],i=t[1],s=t[2],y=t[3],p=new l(r).ecdh(o).slice(1),d=n.hmac(new Uint8Array,p),g=new Uint8Array([...y,...s]);return n.decrypt(d,i,g)})}}export{P as DefaultLedgerKeyringProtocol};
+import{makeContainer as i}from"./di";import{useCasesTypes as r}from"./use-cases/di/useCasesTypes";class y{name;_container;constructor({dmk:e,applicationId:t,cryptoService:a,env:n,baseUrl:o}){this.name="Ledger Keyring Protocol",this._container=i({dmk:e,applicationId:t,cryptoService:a,env:n,baseUrl:o})}authenticate(e){return this._container.get(r.AuthenticateUseCase).execute(e)}encryptData(e,t){return this._container.get(r.EncryptDataUseCase).execute(e,t)}decryptData(e,t){return this._container.get(r.DecryptDataUseCase).execute(e,t)}}export{y as DefaultLedgerKeyringProtocol};
 //# sourceMappingURL=DefaultLedgerKeyringProtocol.js.map

package/lib/esm/internal/DefaultLedgerKeyringProtocol.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/DefaultLedgerKeyringProtocol.ts"],
-  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport {\n  ByteArrayBuilder,\n  ByteArrayParser,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\nimport { Maybe, Nothing } from \"purify-ts\";\n\nimport { type AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { KeypairFromBytes } from \"@api/app-binder/KeypairFromBytes\";\nimport {\n  type JWT,\n  type Keypair,\n  type Permissions,\n} from \"@api/app-binder/LKRPTypes\";\nimport { type LedgerKeyringProtocol } from \"@api/LedgerKeyringProtocol\";\nimport { makeContainer } from \"@internal/di\";\nimport { AES_BLOCK_SIZE, CryptoUtils } from \"@internal/utils/crypto\";\n\nimport { type AuthenticateUseCase } from \"./use-cases/authentication/AuthenticateUseCase\";\nimport { useCasesTypes } from \"./use-cases/di/useCasesTypes\";\n\ntype DefaultLedgerKeyringProtocolConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  baseUrl: string;\n};\n\nexport class DefaultLedgerKeyringProtocol implements LedgerKeyringProtocol {\n  name: string;\n  private _container: Container;\n\n  constructor({\n    dmk,\n    sessionId,\n    baseUrl,\n  }: DefaultLedgerKeyringProtocolConstructorArgs) {\n    this.name = \"Ledger Keyring Protocol\";\n    this._container = makeContainer({ dmk, sessionId, baseUrl });\n  }\n\n  authenticate(\n    keypair: Keypair,\n    applicationId: number,\n    clientName: string,\n    permissions: Permissions,\n    trustchainId?: string,\n    jwt?: JWT,\n  ): AuthenticateDAReturnType {\n    return this._container\n      .get<AuthenticateUseCase>(useCasesTypes.AuthenticateUseCase)\n      .execute(\n        keypair,\n        applicationId,\n        clientName,\n        permissions,\n        trustchainId,\n        jwt,\n      );\n  }\n\n  // TODO Better return type for error management instead of exceptions\n  encryptData(encryptionKey: Uint8Array, data: Uint8Array): Uint8Array {\n    // TODO move implem in a use case\n\n    // Derive the shared secret using ECDH with an ephemeral keypair\n    const privateKey = new KeypairFromBytes(encryptionKey);\n    const ephemeralKeypair = CryptoUtils.randomKeypair();\n    const sharedSecret = privateKey\n      .ecdh(ephemeralKeypair.pubKeyToU8a())\n      .slice(1);\n\n    // Key derivation using HMAC-SHA256\n    const key = CryptoUtils.hmac(new Uint8Array(), sharedSecret);\n\n    // Generate a random IV (nonce)\n    const iv = CryptoUtils.randomBytes(16);\n\n    // Encrypt data\n    const ciphertext = CryptoUtils.encrypt(key, iv, data);\n    const encryptedData = ciphertext.subarray(0, -AES_BLOCK_SIZE);\n    const tag = ciphertext.subarray(-AES_BLOCK_SIZE);\n\n    // Serialize the result\n    return new ByteArrayBuilder()\n      .add8BitUIntToData(0) // Version of the format\n      .addBufferToData(ephemeralKeypair.pubKeyToU8a())\n      .addBufferToData(iv)\n      .addBufferToData(tag)\n      .addBufferToData(encryptedData)\n      .build();\n  }\n\n  decryptData(encryptionKey: Uint8Array, data: Uint8Array): Maybe<Uint8Array> {\n    // TODO move implem in a use case\n\n    const parser = new ByteArrayParser(data);\n    if (parser.extract8BitUInt() !== 0) {\n      // Unsupported serialization version\n      return Nothing;\n    }\n    return Maybe.sequence([\n      Maybe.fromNullable(parser.extractFieldByLength(33)),\n      Maybe.fromNullable(parser.extractFieldByLength(16)),\n      Maybe.fromNullable(parser.extractFieldByLength(16)),\n      Maybe.fromNullable(\n        parser.extractFieldByLength(parser.getUnparsedRemainingLength()),\n      ),\n    ]).map((parsed) => {\n      const ephemeralPublicKey = parsed[0]!;\n      const iv = parsed[1]!;\n      const tag = parsed[2]!;\n      const encryptedData = parsed[3]!;\n\n      // Derive the shared secret using ECDH with an ephemeral keypair\n      const privateKey = new KeypairFromBytes(encryptionKey);\n      const sharedSecret = privateKey.ecdh(ephemeralPublicKey).slice(1);\n\n      // Key derivation using HMAC-SHA256\n      const key = CryptoUtils.hmac(new Uint8Array(), sharedSecret);\n\n      // Decrypt the data\n      const ciphertext = new Uint8Array([...encryptedData, ...tag]);\n      const cleartext = CryptoUtils.decrypt(key, iv, ciphertext);\n      return cleartext;\n    });\n  }\n}\n"],
-  "mappings": "AAIA,OACE,oBAAAA,EACA,mBAAAC,MACK,kCAEP,OAAS,SAAAC,EAAO,WAAAC,MAAe,YAG/B,OAAS,oBAAAC,MAAwB,mCAOjC,OAAS,iBAAAC,MAAqB,eAC9B,OAAS,kBAAAC,EAAgB,eAAAC,MAAmB,yBAG5C,OAAS,iBAAAC,MAAqB,+BAQvB,MAAMC,CAA8D,CACzE,KACQ,WAER,YAAY,CACV,IAAAC,EACA,UAAAC,EACA,QAAAC,CACF,EAAgD,CAC9C,KAAK,KAAO,0BACZ,KAAK,WAAaP,EAAc,CAAE,IAAAK,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,CAC7D,CAEA,aACEC,EACAC,EACAC,EACAC,EACAC,EACAC,EAC0B,CAC1B,OAAO,KAAK,WACT,IAAyBV,EAAc,mBAAmB,EAC1D,QACCK,EACAC,EACAC,EACAC,EACAC,EACAC,CACF,CACJ,CAGA,YAAYC,EAA2BC,EAA8B,CAInE,MAAMC,EAAa,IAAIjB,EAAiBe,CAAa,EAC/CG,EAAmBf,EAAY,cAAc,EAC7CgB,EAAeF,EAClB,KAAKC,EAAiB,YAAY,CAAC,EACnC,MAAM,CAAC,EAGJE,EAAMjB,EAAY,KAAK,IAAI,WAAcgB,CAAY,EAGrDE,EAAKlB,EAAY,YAAY,EAAE,EAG/BmB,EAAanB,EAAY,QAAQiB,EAAKC,EAAIL,CAAI,EAC9CO,EAAgBD,EAAW,SAAS,EAAG,CAACpB,CAAc,EACtDsB,EAAMF,EAAW,SAAS,CAACpB,CAAc,EAG/C,OAAO,IAAIN,EAAiB,EACzB,kBAAkB,CAAC,EACnB,gBAAgBsB,EAAiB,YAAY,CAAC,EAC9C,gBAAgBG,CAAE,EAClB,gBAAgBG,CAAG,EACnB,gBAAgBD,CAAa,EAC7B,MAAM,CACX,CAEA,YAAYR,EAA2BC,EAAqC,CAG1E,MAAMS,EAAS,IAAI5B,EAAgBmB,CAAI,EACvC,OAAIS,EAAO,gBAAgB,IAAM,EAExB1B,EAEFD,EAAM,SAAS,CACpBA,EAAM,aAAa2B,EAAO,qBAAqB,EAAE,CAAC,EAClD3B,EAAM,aAAa2B,EAAO,qBAAqB,EAAE,CAAC,EAClD3B,EAAM,aAAa2B,EAAO,qBAAqB,EAAE,CAAC,EAClD3B,EAAM,aACJ2B,EAAO,qBAAqBA,EAAO,2BAA2B,CAAC,CACjE,CACF,CAAC,EAAE,IAAKC,GAAW,CACjB,MAAMC,EAAqBD,EAAO,CAAC,EAC7BL,EAAKK,EAAO,CAAC,EACbF,EAAME,EAAO,CAAC,EACdH,EAAgBG,EAAO,CAAC,EAIxBP,EADa,IAAInB,EAAiBe,CAAa,EACrB,KAAKY,CAAkB,EAAE,MAAM,CAAC,EAG1DP,EAAMjB,EAAY,KAAK,IAAI,WAAcgB,CAAY,EAGrDG,EAAa,IAAI,WAAW,CAAC,GAAGC,EAAe,GAAGC,CAAG,CAAC,EAE5D,OADkBrB,EAAY,QAAQiB,EAAKC,EAAIC,CAAU,CAE3D,CAAC,CACH,CACF",
-  "names": ["ByteArrayBuilder", "ByteArrayParser", "Maybe", "Nothing", "KeypairFromBytes", "makeContainer", "AES_BLOCK_SIZE", "CryptoUtils", "useCasesTypes", "DefaultLedgerKeyringProtocol", "dmk", "sessionId", "baseUrl", "keypair", "applicationId", "clientName", "permissions", "trustchainId", "jwt", "encryptionKey", "data", "privateKey", "ephemeralKeypair", "sharedSecret", "key", "iv", "ciphertext", "encryptedData", "tag", "parser", "parsed", "ephemeralPublicKey"]
+  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\n\nimport { type AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type LedgerKeyringProtocol } from \"@api/LedgerKeyringProtocol\";\nimport { type LKRPEnv } from \"@api/model/Env\";\nimport { makeContainer } from \"@internal/di\";\n\nimport {\n  type AuthenticateUseCase,\n  type AuthenticateUsecaseInput,\n} from \"./use-cases/authentication/AuthenticateUseCase\";\nimport { type DecryptDataUseCase } from \"./use-cases/authentication/DecryptDataUseCase\";\nimport { type EncryptDataUseCase } from \"./use-cases/authentication/EncryptDataUseCase\";\nimport { useCasesTypes } from \"./use-cases/di/useCasesTypes\";\n\ntype DefaultLedgerKeyringProtocolConstructorArgs = {\n  dmk: DeviceManagementKit;\n  applicationId: number;\n  cryptoService: CryptoService;\n  env?: LKRPEnv;\n  baseUrl?: string;\n};\n\nexport class DefaultLedgerKeyringProtocol implements LedgerKeyringProtocol {\n  name: string;\n  private _container: Container;\n\n  constructor({\n    dmk,\n    applicationId,\n    cryptoService,\n    env,\n    baseUrl,\n  }: DefaultLedgerKeyringProtocolConstructorArgs) {\n    this.name = \"Ledger Keyring Protocol\";\n    this._container = makeContainer({\n      dmk,\n      applicationId,\n      cryptoService,\n      env,\n      baseUrl,\n    });\n  }\n\n  authenticate(input: AuthenticateUsecaseInput): AuthenticateDAReturnType {\n    return this._container\n      .get<AuthenticateUseCase>(useCasesTypes.AuthenticateUseCase)\n      .execute(input);\n  }\n\n  encryptData(\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\n    return this._container\n      .get<EncryptDataUseCase>(useCasesTypes.EncryptDataUseCase)\n      .execute(encryptionKey, data);\n  }\n\n  decryptData(\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\n    return this._container\n      .get<DecryptDataUseCase>(useCasesTypes.DecryptDataUseCase)\n      .execute(encryptionKey, data);\n  }\n}\n"],
+  "mappings": "AAOA,OAAS,iBAAAA,MAAqB,eAQ9B,OAAS,iBAAAC,MAAqB,+BAUvB,MAAMC,CAA8D,CACzE,KACQ,WAER,YAAY,CACV,IAAAC,EACA,cAAAC,EACA,cAAAC,EACA,IAAAC,EACA,QAAAC,CACF,EAAgD,CAC9C,KAAK,KAAO,0BACZ,KAAK,WAAaP,EAAc,CAC9B,IAAAG,EACA,cAAAC,EACA,cAAAC,EACA,IAAAC,EACA,QAAAC,CACF,CAAC,CACH,CAEA,aAAaC,EAA2D,CACtE,OAAO,KAAK,WACT,IAAyBP,EAAc,mBAAmB,EAC1D,QAAQO,CAAK,CAClB,CAEA,YACEC,EACAC,EACqB,CACrB,OAAO,KAAK,WACT,IAAwBT,EAAc,kBAAkB,EACxD,QAAQQ,EAAeC,CAAI,CAChC,CAEA,YACED,EACAC,EACqB,CACrB,OAAO,KAAK,WACT,IAAwBT,EAAc,kBAAkB,EACxD,QAAQQ,EAAeC,CAAI,CAChC,CACF",
+  "names": ["makeContainer", "useCasesTypes", "DefaultLedgerKeyringProtocol", "dmk", "applicationId", "cryptoService", "env", "baseUrl", "input", "encryptionKey", "data"]
 }

package/lib/esm/internal/app-binder/LedgerKeyringProtocolBinder.js

@@ -1,2 +1,2 @@
-var d=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var c=(r,e,i,t)=>{for(var n=t>1?void 0:t?l(e,i):e,s=r.length-1,m;s>=0;s--)(m=r[s])&&(n=(t?m(e,i,n):m(n))||n);return t&&n&&d(e,i,n),n},o=(r,e)=>(i,t)=>e(i,t,r);import{SendCommandInAppDeviceAction as w,UserInteractionRequired as k}from"@ledgerhq/device-management-kit";import{inject as a,injectable as D}from"inversify";import{externalTypes as u}from"../externalTypes";import{lkrpDatasourceTypes as h}from"../lkrp-datasource/di/lkrpDatasourceTypes";import{GetVersionCommand as A}from"./command/GetVersionCommand";import{AuthenticateDeviceAction as I}from"./device-action/AuthenticateDeviceAction";let p=class{constructor(e,i,t){this.dmk=e;this.sessionId=i;this.lkrpDataSource=t}authenticate(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new I({input:{lkrpDataSource:this.lkrpDataSource,applicationId:e.applicationId,clientName:e.clientName,permissions:e.permissions,keypair:e.keypair,trustchainId:e.trustchainId??null,jwt:e.jwt??null}})})}getVersion(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new w({input:{command:new A,appName:"Ledger Sync",requiredUserInteraction:k.None,skipOpenApp:e.skipOpenApp}})})}getAppName(){throw new Error("Not implemented")}getSeedId(){throw new Error("Not implemented")}init(){throw new Error("Not implemented")}parseStream(){throw new Error("Not implemented")}signBlock(){throw new Error("Not implemented")}setTrustedMember(){throw new Error("Not implemented")}};p=c([D(),o(0,a(u.Dmk)),o(1,a(u.SessionId)),o(2,a(h.LKRPDataSource))],p);export{p as LedgerKeyringProtocolBinder};
+var d=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var u=(n,e,r,i)=>{for(var t=i>1?void 0:i?y(e,r):e,c=n.length-1,s;c>=0;c--)(s=n[c])&&(t=(i?s(e,r,t):s(t))||t);return i&&t&&d(e,r,t),t},o=(n,e)=>(r,i)=>e(r,i,n);import{SendCommandInAppDeviceAction as h,UserInteractionRequired as D}from"@ledgerhq/device-management-kit";import{inject as p,injectable as k}from"inversify";import{externalTypes as m}from"../externalTypes";import{lkrpDatasourceTypes as v}from"../lkrp-datasource/di/lkrpDatasourceTypes";import{GetVersionCommand as l}from"./command/GetVersionCommand";import{AuthenticateWithDeviceDeviceAction as A}from"./device-action/AuthenticateWithDeviceDeviceAction";import{AuthenticateWithKeypairDeviceAction as S}from"./device-action/AuthenticateWithKeypairDeviceAction";let a=class{constructor(e,r,i,t){this.dmk=e;this.applicationId=r;this.cryptoService=i;this.lkrpDataSource=t}authenticateWithKeypair(e){return new S({input:{lkrpDataSource:this.lkrpDataSource,appId:this.applicationId,cryptoService:this.cryptoService,keyPair:e.keyPair,trustchainId:e.trustchainId}}).execute()}authenticateWithDevice(e){return this.dmk.executeDeviceAction({sessionId:e.sessionId,deviceAction:new A({input:{lkrpDataSource:this.lkrpDataSource,appId:this.applicationId,cryptoService:this.cryptoService,clientName:e.clientName,permissions:e.permissions,keyPair:e.keyPair}})})}getVersion(e){return this.dmk.executeDeviceAction({sessionId:e.sessionId,deviceAction:new h({input:{command:new l,appName:"Ledger Sync",requiredUserInteraction:D.None,skipOpenApp:e.skipOpenApp}})})}getAppName(){throw new Error("Not implemented")}getSeedId(){throw new Error("Not implemented")}init(){throw new Error("Not implemented")}parseStream(){throw new Error("Not implemented")}signBlock(){throw new Error("Not implemented")}setTrustedMember(){throw new Error("Not implemented")}};a=u([k(),o(0,p(m.Dmk)),o(1,p(m.ApplicationId)),o(2,p(m.CryptoService)),o(3,p(v.LKRPDataSource))],a);export{a as LedgerKeyringProtocolBinder};
 //# sourceMappingURL=LedgerKeyringProtocolBinder.js.map

package/lib/esm/internal/app-binder/LedgerKeyringProtocolBinder.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/app-binder/LedgerKeyringProtocolBinder.ts"],
-  "sourcesContent": ["import {\n  DeviceManagementKit,\n  type DeviceSessionId,\n  SendCommandInAppDeviceAction,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { GetVersionDAReturnType } from \"@api/app-binder/GetVersionDeviceActionTypes\";\nimport { JWT, Keypair, Permissions } from \"@api/app-binder/LKRPTypes\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { lkrpDatasourceTypes } from \"@internal/lkrp-datasource/di/lkrpDatasourceTypes\";\n\nimport { GetVersionCommand } from \"./command/GetVersionCommand\";\nimport { AuthenticateDeviceAction } from \"./device-action/AuthenticateDeviceAction\";\n\n@injectable()\nexport class LedgerKeyringProtocolBinder {\n  constructor(\n    @inject(externalTypes.Dmk) private readonly dmk: DeviceManagementKit,\n\n    @inject(externalTypes.SessionId)\n    private readonly sessionId: DeviceSessionId,\n\n    @inject(lkrpDatasourceTypes.LKRPDataSource)\n    private readonly lkrpDataSource: LKRPDataSource,\n  ) {}\n\n  authenticate(args: {\n    keypair: Keypair;\n    applicationId: number;\n    clientName: string;\n    permissions: Permissions;\n    trustchainId?: string;\n    jwt?: JWT;\n  }): AuthenticateDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new AuthenticateDeviceAction({\n        input: {\n          lkrpDataSource: this.lkrpDataSource,\n          applicationId: args.applicationId,\n          clientName: args.clientName,\n          permissions: args.permissions,\n          keypair: args.keypair,\n          trustchainId: args.trustchainId ?? null,\n          jwt: args.jwt ?? null,\n        },\n      }),\n    });\n  }\n\n  getVersion(args: { skipOpenApp: boolean }): GetVersionDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new SendCommandInAppDeviceAction({\n        input: {\n          command: new GetVersionCommand(),\n          appName: \"Ledger Sync\",\n          requiredUserInteraction: UserInteractionRequired.None,\n          skipOpenApp: args.skipOpenApp,\n        },\n      }),\n    });\n  }\n\n  getAppName(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  getSeedId(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  init(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  parseStream(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  signBlock(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  setTrustedMember(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n}\n"],
-  "mappings": "iOAAA,OAGE,gCAAAA,EACA,2BAAAC,MACK,kCACP,OAAS,UAAAC,EAAQ,cAAAC,MAAkB,YAKnC,OAAS,iBAAAC,MAAqB,0BAE9B,OAAS,uBAAAC,MAA2B,mDAEpC,OAAS,qBAAAC,MAAyB,8BAClC,OAAS,4BAAAC,MAAgC,2CAGlC,IAAMC,EAAN,KAAkC,CACvC,YAC8CC,EAG3BC,EAGAC,EACjB,CAP4C,SAAAF,EAG3B,eAAAC,EAGA,oBAAAC,CAChB,CAEH,aAAaC,EAOgB,CAC3B,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIC,EAAyB,CACzC,MAAO,CACL,eAAgB,KAAK,eACrB,cAAeD,EAAK,cACpB,WAAYA,EAAK,WACjB,YAAaA,EAAK,YAClB,QAASA,EAAK,QACd,aAAcA,EAAK,cAAgB,KACnC,IAAKA,EAAK,KAAO,IACnB,CACF,CAAC,CACH,CAAC,CACH,CAEA,WAAWA,EAAwD,CACjE,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAIE,EAA6B,CAC7C,MAAO,CACL,QAAS,IAAIC,EACb,QAAS,cACT,wBAAyBC,EAAwB,KACjD,YAAaJ,EAAK,WACpB,CACF,CAAC,CACH,CAAC,CACH,CAEA,YAAsB,CACpB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,MAAgB,CACd,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,aAAuB,CACrB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,kBAA4B,CAC1B,MAAM,IAAI,MAAM,iBAAiB,CACnC,CACF,EAxEaJ,EAANS,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAc,GAAG,GAExBF,EAAA,EAAAC,EAAOC,EAAc,SAAS,GAG9BF,EAAA,EAAAC,EAAOE,EAAoB,cAAc,IAPjCd",
-  "names": ["SendCommandInAppDeviceAction", "UserInteractionRequired", "inject", "injectable", "externalTypes", "lkrpDatasourceTypes", "GetVersionCommand", "AuthenticateDeviceAction", "LedgerKeyringProtocolBinder", "dmk", "sessionId", "lkrpDataSource", "args", "AuthenticateDeviceAction", "SendCommandInAppDeviceAction", "GetVersionCommand", "UserInteractionRequired", "__decorateClass", "injectable", "__decorateParam", "inject", "externalTypes", "lkrpDatasourceTypes"]
+  "sourcesContent": ["import {\n  DeviceManagementKit,\n  type DeviceSessionId,\n  SendCommandInAppDeviceAction,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { GetVersionDAReturnType } from \"@api/app-binder/GetVersionDeviceActionTypes\";\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { KeyPair } from \"@api/crypto/KeyPair\";\nimport { Permissions } from \"@api/model/Permissions\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { lkrpDatasourceTypes } from \"@internal/lkrp-datasource/di/lkrpDatasourceTypes\";\n\nimport { GetVersionCommand } from \"./command/GetVersionCommand\";\nimport { AuthenticateWithDeviceDeviceAction } from \"./device-action/AuthenticateWithDeviceDeviceAction\";\nimport { AuthenticateWithKeypairDeviceAction } from \"./device-action/AuthenticateWithKeypairDeviceAction\";\n\n@injectable()\nexport class LedgerKeyringProtocolBinder {\n  constructor(\n    @inject(externalTypes.Dmk) private readonly dmk: DeviceManagementKit,\n\n    @inject(externalTypes.ApplicationId)\n    private readonly applicationId: number,\n\n    @inject(externalTypes.CryptoService)\n    private readonly cryptoService: CryptoService,\n\n    @inject(lkrpDatasourceTypes.LKRPDataSource)\n    private readonly lkrpDataSource: LKRPDataSource,\n  ) {}\n\n  authenticateWithKeypair(args: {\n    keyPair: KeyPair;\n    trustchainId: string;\n  }): AuthenticateDAReturnType {\n    return new AuthenticateWithKeypairDeviceAction({\n      input: {\n        lkrpDataSource: this.lkrpDataSource,\n        appId: this.applicationId,\n        cryptoService: this.cryptoService,\n        keyPair: args.keyPair,\n        trustchainId: args.trustchainId,\n      },\n    }).execute();\n  }\n\n  authenticateWithDevice(args: {\n    keyPair: KeyPair;\n    clientName: string;\n    permissions: Permissions;\n    sessionId: DeviceSessionId;\n  }): AuthenticateDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: args.sessionId,\n      deviceAction: new AuthenticateWithDeviceDeviceAction({\n        input: {\n          lkrpDataSource: this.lkrpDataSource,\n          appId: this.applicationId,\n          cryptoService: this.cryptoService,\n          clientName: args.clientName,\n          permissions: args.permissions,\n          keyPair: args.keyPair,\n        },\n      }),\n    });\n  }\n\n  getVersion(args: {\n    skipOpenApp: boolean;\n    sessionId: DeviceSessionId;\n  }): GetVersionDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: args.sessionId,\n      deviceAction: new SendCommandInAppDeviceAction({\n        input: {\n          command: new GetVersionCommand(),\n          appName: \"Ledger Sync\",\n          requiredUserInteraction: UserInteractionRequired.None,\n          skipOpenApp: args.skipOpenApp,\n        },\n      }),\n    });\n  }\n\n  getAppName(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  getSeedId(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  init(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  parseStream(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  signBlock(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  setTrustedMember(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n}\n"],
+  "mappings": "iOAAA,OAGE,gCAAAA,EACA,2BAAAC,MACK,kCACP,OAAS,UAAAC,EAAQ,cAAAC,MAAkB,YAOnC,OAAS,iBAAAC,MAAqB,0BAE9B,OAAS,uBAAAC,MAA2B,mDAEpC,OAAS,qBAAAC,MAAyB,8BAClC,OAAS,sCAAAC,MAA0C,qDACnD,OAAS,uCAAAC,MAA2C,sDAG7C,IAAMC,EAAN,KAAkC,CACvC,YAC8CC,EAG3BC,EAGAC,EAGAC,EACjB,CAV4C,SAAAH,EAG3B,mBAAAC,EAGA,mBAAAC,EAGA,oBAAAC,CAChB,CAEH,wBAAwBC,EAGK,CAC3B,OAAO,IAAIC,EAAoC,CAC7C,MAAO,CACL,eAAgB,KAAK,eACrB,MAAO,KAAK,cACZ,cAAe,KAAK,cACpB,QAASD,EAAK,QACd,aAAcA,EAAK,YACrB,CACF,CAAC,EAAE,QAAQ,CACb,CAEA,uBAAuBA,EAKM,CAC3B,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAWA,EAAK,UAChB,aAAc,IAAIE,EAAmC,CACnD,MAAO,CACL,eAAgB,KAAK,eACrB,MAAO,KAAK,cACZ,cAAe,KAAK,cACpB,WAAYF,EAAK,WACjB,YAAaA,EAAK,YAClB,QAASA,EAAK,OAChB,CACF,CAAC,CACH,CAAC,CACH,CAEA,WAAWA,EAGgB,CACzB,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAWA,EAAK,UAChB,aAAc,IAAIG,EAA6B,CAC7C,MAAO,CACL,QAAS,IAAIC,EACb,QAAS,cACT,wBAAyBC,EAAwB,KACjD,YAAaL,EAAK,WACpB,CACF,CAAC,CACH,CAAC,CACH,CAEA,YAAsB,CACpB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,MAAgB,CACd,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,aAAuB,CACrB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,kBAA4B,CAC1B,MAAM,IAAI,MAAM,iBAAiB,CACnC,CACF,EA1FaL,EAANW,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAc,GAAG,GAExBF,EAAA,EAAAC,EAAOC,EAAc,aAAa,GAGlCF,EAAA,EAAAC,EAAOC,EAAc,aAAa,GAGlCF,EAAA,EAAAC,EAAOE,EAAoB,cAAc,IAVjChB",
+  "names": ["SendCommandInAppDeviceAction", "UserInteractionRequired", "inject", "injectable", "externalTypes", "lkrpDatasourceTypes", "GetVersionCommand", "AuthenticateWithDeviceDeviceAction", "AuthenticateWithKeypairDeviceAction", "LedgerKeyringProtocolBinder", "dmk", "applicationId", "cryptoService", "lkrpDataSource", "args", "AuthenticateWithKeypairDeviceAction", "AuthenticateWithDeviceDeviceAction", "SendCommandInAppDeviceAction", "GetVersionCommand", "UserInteractionRequired", "__decorateClass", "injectable", "__decorateParam", "inject", "externalTypes", "lkrpDatasourceTypes"]
 }

package/lib/esm/internal/app-binder/command/GetAppNameCommand.js

@@ -1,2 +1,2 @@
-import{ApduBuilder as t,ApduParser as m,CommandResultFactory as o,InvalidStatusWordError as n}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as a}from"@ledgerhq/signer-utils";import{Maybe as d}from"purify-ts";import{LEDGER_SYNC_ERRORS as s,LedgerKeyringProtocolErrorFactory as i}from"./utils/ledgerKeyringProtocolErrors";class C{errorHelper=new a(s,i);getApdu(){const e={cla:224,ins:3,p1:0,p2:0};return new t(e).build()}parseResponse(e){return d.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const r=new m(e).encodeToString(e.data);return r?o({data:{name:r}}):o({error:new n("Name is missing")})})}}export{C as GetAppNameCommand};
+import{ApduBuilder as t,ApduParser as m,CommandResultFactory as o,InvalidStatusWordError as n}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as a}from"@ledgerhq/signer-utils";import{Maybe as d}from"purify-ts";import{LEDGER_SYNC_ERRORS as s,LedgerKeyringProtocolErrorFactory as l}from"./utils/ledgerKeyringProtocolErrors";class C{name="getAppName";errorHelper=new a(s,l);getApdu(){const e={cla:224,ins:3,p1:0,p2:0};return new t(e).build()}parseResponse(e){return d.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const r=new m(e).encodeToString(e.data);return r?o({data:{name:r}}):o({error:new n("Name is missing")})})}}export{C as GetAppNameCommand};
 //# sourceMappingURL=GetAppNameCommand.js.map

package/lib/esm/internal/app-binder/command/GetAppNameCommand.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/GetAppNameCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  type GetAppNameCommandArgs,\n  type GetAppNameCommandResponse,\n} from \"@api/app-binder/GetAppNameCommandTypes\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport class GetAppNameCommand\n  implements\n    Command<\n      GetAppNameCommandResponse,\n      GetAppNameCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    GetAppNameCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const getAppNameArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x03,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(getAppNameArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetAppNameCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const name = parser.encodeToString(apduResponse.data);\n\n      if (!name) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(`Name is missing`),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { name },\n      });\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAOtB,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAEA,MAAMC,CAOb,CACmB,YAAc,IAAIJ,EAGjCE,EAAoBC,CAAiC,EAEvD,SAAgB,CACd,MAAME,EAAkC,CACtC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAGA,OADgB,IAAIT,EAAYS,CAAc,EAC/B,MAAM,CACvB,CAEA,cACEC,EAC2E,CAC3E,OAAOL,EAAM,aACX,KAAK,YAAY,SAASK,CAAY,CACxC,EAAE,cAAc,IAAM,CAGpB,MAAMC,EAFS,IAAIV,EAAWS,CAAY,EAEtB,eAAeA,EAAa,IAAI,EAEpD,OAAKC,EAMET,EAAqB,CAC1B,KAAM,CAAE,KAAAS,CAAK,CACf,CAAC,EAPQT,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,iBAAiB,CACrD,CAAC,CAML,CAAC,CACH,CACF",
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport type GetAppNameCommandResponse = {\n  readonly name: string;\n};\n\nexport type GetAppNameCommandArgs = undefined;\n\nexport class GetAppNameCommand\n  implements\n    Command<\n      GetAppNameCommandResponse,\n      GetAppNameCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  readonly name = \"getAppName\";\n  private readonly errorHelper = new CommandErrorHelper<\n    GetAppNameCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const getAppNameArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x03,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(getAppNameArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetAppNameCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const name = parser.encodeToString(apduResponse.data);\n\n      if (!name) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(`Name is missing`),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { name },\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAQA,MAAMC,CAOb,CACW,KAAO,aACC,YAAc,IAAIJ,EAGjCE,EAAoBC,CAAiC,EAEvD,SAAgB,CACd,MAAME,EAAkC,CACtC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAGA,OADgB,IAAIT,EAAYS,CAAc,EAC/B,MAAM,CACvB,CAEA,cACEC,EAC2E,CAC3E,OAAOL,EAAM,aACX,KAAK,YAAY,SAASK,CAAY,CACxC,EAAE,cAAc,IAAM,CAGpB,MAAMC,EAFS,IAAIV,EAAWS,CAAY,EAEtB,eAAeA,EAAa,IAAI,EAEpD,OAAKC,EAMET,EAAqB,CAC1B,KAAM,CAAE,KAAAS,CAAK,CACf,CAAC,EAPQT,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,iBAAiB,CACrD,CAAC,CAML,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "LEDGER_SYNC_ERRORS", "LedgerKeyringProtocolErrorFactory", "GetAppNameCommand", "getAppNameArgs", "apduResponse", "name"]
 }

package/lib/esm/internal/app-binder/command/GetSeedIdCommand.js

@@ -1,2 +1,2 @@
-import{ApduBuilder as a,ApduParser as g,CommandResultFactory as o,InvalidStatusWordError as l}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as c}from"@ledgerhq/signer-utils";import{Maybe as d}from"purify-ts";import{eitherSeqRecord as n}from"../../utils/eitherSeqRecord";import{bytesToHex as s}from"../../utils/hex";import{LEDGER_SYNC_ERRORS as p,LedgerKeyringProtocolErrorFactory as u}from"./utils/ledgerKeyringProtocolErrors";class S{constructor(i){this.args=i}errorHelper=new c(p,u);getApdu(){const{challengeTLV:i}=this.args,t={cla:224,ins:5,p1:0,p2:0};return new a(t).addHexaStringToData(i).build()}parseResponse(i){return d.fromNullable(this.errorHelper.getError(i)).orDefaultLazy(()=>{const t=new g(i),r=(e,m)=>d.fromNullable(e).toEither(new l(m));return n({credential:()=>n({version:()=>r(t.extract8BitUInt(),"Version is missing"),curveId:()=>r(t.extract8BitUInt(),"Curve ID is missing"),signAlgorithm:()=>r(t.extract8BitUInt(),"Sign algorithm is missing"),publicKey:()=>r(t.extract8BitUInt(),"Public key length is missing").chain(e=>r(t.extractFieldByLength(e),"Public key is missing")).map(s)}),signature:()=>r(t.extract8BitUInt(),"Signature length is missing").chain(e=>r(t.extractFieldByLength(e),"Signature is missing")).map(s),attestation:()=>n({id:()=>r(t.extractFieldByLength(1),"Attestation Id is missing"),version:()=>r(t.extract8BitUInt(),"Attestation version is missing"),curveId:()=>r(t.extract8BitUInt(),"Attestation curve ID is missing"),signAlgorithm:()=>r(t.extract8BitUInt(),"Attestation sign algorithm is missing"),publicKey:()=>r(t.extract8BitUInt(),"Attestation key length is missing").chain(e=>r(t.extractFieldByLength(e),"Attestation key is missing")),signature:()=>r(t.extract8BitUInt(),"Attestation signature length is missing").chain(e=>r(t.extractFieldByLength(e),"Attestation signature is missing"))}).map(e=>s(Uint8Array.from([...e.id,e.version,e.curveId,e.signAlgorithm,e.publicKey.length,...e.publicKey,e.signature.length,...e.signature])))}).caseOf({Left:e=>o({error:e}),Right:e=>o({data:e})})})}}export{S as GetSeedIdCommand};
+import{ApduBuilder as g,ApduParser as m,bufferToHexaString as n,CommandResultFactory as o,InvalidStatusWordError as l}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as c}from"@ledgerhq/signer-utils";import{Maybe as a}from"purify-ts";import{eitherSeqRecord as s}from"../../utils/eitherSeqRecord";import{LEDGER_SYNC_ERRORS as u,LedgerKeyringProtocolErrorFactory as p}from"./utils/ledgerKeyringProtocolErrors";class S{constructor(i){this.args=i}name="getSeedId";errorHelper=new c(u,p);getApdu(){const{challengeTLV:i}=this.args,r={cla:224,ins:5,p1:0,p2:0};return new g(r).addHexaStringToData(i).build()}parseResponse(i){return a.fromNullable(this.errorHelper.getError(i)).orDefaultLazy(()=>{const r=new m(i),t=(e,d)=>a.fromNullable(e).toEither(new l(d));return s({credential:()=>s({version:()=>t(r.extract8BitUInt(),"Version is missing"),curveId:()=>t(r.extract8BitUInt(),"Curve ID is missing"),signAlgorithm:()=>t(r.extract8BitUInt(),"Sign algorithm is missing"),publicKey:()=>t(r.extract8BitUInt(),"Public key length is missing").chain(e=>t(r.extractFieldByLength(e),"Public key is missing")).map(e=>n(e,!1))}),signature:()=>t(r.extract8BitUInt(),"Signature length is missing").chain(e=>t(r.extractFieldByLength(e),"Signature is missing")).map(e=>n(e,!1)),attestation:()=>s({id:()=>t(r.extractFieldByLength(1),"Attestation Id is missing"),version:()=>t(r.extract8BitUInt(),"Attestation version is missing"),curveId:()=>t(r.extract8BitUInt(),"Attestation curve ID is missing"),signAlgorithm:()=>t(r.extract8BitUInt(),"Attestation sign algorithm is missing"),publicKey:()=>t(r.extract8BitUInt(),"Attestation key length is missing").chain(e=>t(r.extractFieldByLength(e),"Attestation key is missing")),signature:()=>t(r.extract8BitUInt(),"Attestation signature length is missing").chain(e=>t(r.extractFieldByLength(e),"Attestation signature is missing"))}).map(e=>n(Uint8Array.from([...e.id,e.version,e.curveId,e.signAlgorithm,e.publicKey.length,...e.publicKey,e.signature.length,...e.signature]),!1))}).caseOf({Left:e=>o({error:e}),Right:e=>o({data:e})})})}}export{S as GetSeedIdCommand};
 //# sourceMappingURL=GetSeedIdCommand.js.map

package/lib/esm/internal/app-binder/command/GetSeedIdCommand.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/GetSeedIdCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  type GetSeedIdCommandArgs,\n  type GetSeedIdCommandResponse,\n} from \"@api/app-binder/GetSeedIdCommandTypes\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\nimport { bytesToHex } from \"@internal/utils/hex\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport class GetSeedIdCommand\n  implements\n    Command<\n      GetSeedIdCommandResponse,\n      GetSeedIdCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    GetSeedIdCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  constructor(private readonly args: GetSeedIdCommandArgs) {}\n  getApdu(): Apdu {\n    const { challengeTLV } = this.args;\n    const getSeedIdArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x05,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    return new ApduBuilder(getSeedIdArgs)\n      .addHexaStringToData(challengeTLV)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetSeedIdCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const required = <T>(value: T | undefined, errorMsg: string) =>\n        Maybe.fromNullable(value).toEither(\n          new InvalidStatusWordError(errorMsg),\n        );\n\n      return eitherSeqRecord({\n        credential: () =>\n          eitherSeqRecord({\n            version: () =>\n              required(parser.extract8BitUInt(), \"Version is missing\"),\n            curveId: () =>\n              required(parser.extract8BitUInt(), \"Curve ID is missing\"),\n            signAlgorithm: () =>\n              required(parser.extract8BitUInt(), \"Sign algorithm is missing\"),\n            publicKey: () =>\n              required(parser.extract8BitUInt(), \"Public key length is missing\")\n                .chain((length) =>\n                  required(\n                    parser.extractFieldByLength(length),\n                    \"Public key is missing\",\n                  ),\n                )\n                .map(bytesToHex),\n          }),\n\n        signature: () =>\n          required(parser.extract8BitUInt(), \"Signature length is missing\")\n            .chain((length) =>\n              required(\n                parser.extractFieldByLength(length),\n                \"Signature is missing\",\n              ),\n            )\n            .map(bytesToHex),\n\n        attestation: () =>\n          eitherSeqRecord({\n            id: () =>\n              required(\n                parser.extractFieldByLength(0x01),\n                \"Attestation Id is missing\",\n              ),\n            version: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation version is missing\",\n              ),\n            curveId: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation curve ID is missing\",\n              ),\n            signAlgorithm: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation sign algorithm is missing\",\n              ),\n            publicKey: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation key length is missing\",\n              ).chain((length) =>\n                required(\n                  parser.extractFieldByLength(length),\n                  \"Attestation key is missing\",\n                ),\n              ),\n            signature: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation signature length is missing\",\n              ).chain((length) =>\n                required(\n                  parser.extractFieldByLength(length),\n                  \"Attestation signature is missing\",\n                ),\n              ),\n          }).map((attestation) =>\n            bytesToHex(\n              Uint8Array.from([\n                ...attestation.id,\n                attestation.version,\n                attestation.curveId,\n                attestation.signAlgorithm,\n                attestation.publicKey.length,\n                ...attestation.publicKey,\n                attestation.signature.length,\n                ...attestation.signature,\n              ]),\n            ),\n          ),\n      }).caseOf({\n        Left: (error) => CommandResultFactory({ error }),\n        Right: (data) => CommandResultFactory({ data }),\n      });\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAMtB,OAAS,mBAAAC,MAAuB,kCAChC,OAAS,cAAAC,MAAkB,sBAE3B,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAEA,MAAMC,CAOb,CAME,YAA6BC,EAA4B,CAA5B,UAAAA,CAA6B,CALzC,YAAc,IAAIP,EAGjCI,EAAoBC,CAAiC,EAGvD,SAAgB,CACd,KAAM,CAAE,aAAAG,CAAa,EAAI,KAAK,KACxBC,EAAiC,CACrC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAEA,OAAO,IAAIb,EAAYa,CAAa,EACjC,oBAAoBD,CAAY,EAChC,MAAM,CACX,CAEA,cACEE,EAC0E,CAC1E,OAAOT,EAAM,aACX,KAAK,YAAY,SAASS,CAAY,CACxC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAId,EAAWa,CAAY,EAEpCE,EAAW,CAAIC,EAAsBC,IACzCb,EAAM,aAAaY,CAAK,EAAE,SACxB,IAAId,EAAuBe,CAAQ,CACrC,EAEF,OAAOZ,EAAgB,CACrB,WAAY,IACVA,EAAgB,CACd,QAAS,IACPU,EAASD,EAAO,gBAAgB,EAAG,oBAAoB,EACzD,QAAS,IACPC,EAASD,EAAO,gBAAgB,EAAG,qBAAqB,EAC1D,cAAe,IACbC,EAASD,EAAO,gBAAgB,EAAG,2BAA2B,EAChE,UAAW,IACTC,EAASD,EAAO,gBAAgB,EAAG,8BAA8B,EAC9D,MAAOI,GACNH,EACED,EAAO,qBAAqBI,CAAM,EAClC,uBACF,CACF,EACC,IAAIZ,CAAU,CACrB,CAAC,EAEH,UAAW,IACTS,EAASD,EAAO,gBAAgB,EAAG,6BAA6B,EAC7D,MAAOI,GACNH,EACED,EAAO,qBAAqBI,CAAM,EAClC,sBACF,CACF,EACC,IAAIZ,CAAU,EAEnB,YAAa,IACXD,EAAgB,CACd,GAAI,IACFU,EACED,EAAO,qBAAqB,CAAI,EAChC,2BACF,EACF,QAAS,IACPC,EACED,EAAO,gBAAgB,EACvB,gCACF,EACF,QAAS,IACPC,EACED,EAAO,gBAAgB,EACvB,iCACF,EACF,cAAe,IACbC,EACED,EAAO,gBAAgB,EACvB,uCACF,EACF,UAAW,IACTC,EACED,EAAO,gBAAgB,EACvB,mCACF,EAAE,MAAOI,GACPH,EACED,EAAO,qBAAqBI,CAAM,EAClC,4BACF,CACF,EACF,UAAW,IACTH,EACED,EAAO,gBAAgB,EACvB,yCACF,EAAE,MAAOI,GACPH,EACED,EAAO,qBAAqBI,CAAM,EAClC,kCACF,CACF,CACJ,CAAC,EAAE,IAAKC,GACNb,EACE,WAAW,KAAK,CACd,GAAGa,EAAY,GACfA,EAAY,QACZA,EAAY,QACZA,EAAY,cACZA,EAAY,UAAU,OACtB,GAAGA,EAAY,UACfA,EAAY,UAAU,OACtB,GAAGA,EAAY,SACjB,CAAC,CACH,CACF,CACJ,CAAC,EAAE,OAAO,CACR,KAAOC,GAAUnB,EAAqB,CAAE,MAAAmB,CAAM,CAAC,EAC/C,MAAQC,GAASpB,EAAqB,CAAE,KAAAoB,CAAK,CAAC,CAChD,CAAC,CACH,CAAC,CACH,CACF",
-  "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "eitherSeqRecord", "bytesToHex", "LEDGER_SYNC_ERRORS", "LedgerKeyringProtocolErrorFactory", "GetSeedIdCommand", "args", "challengeTLV", "getSeedIdArgs", "apduResponse", "parser", "required", "value", "errorMsg", "length", "attestation", "error", "data"]
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  bufferToHexaString,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport type GetSeedIdCommandResponse = {\n  readonly credential: {\n    readonly version: number;\n    readonly curveId: number;\n    readonly signAlgorithm: number;\n    readonly publicKey: string;\n  };\n  readonly signature: string;\n  readonly attestation: string;\n};\n\nexport type GetSeedIdCommandArgs = {\n  readonly challengeTLV: string;\n};\n\nexport class GetSeedIdCommand\n  implements\n    Command<\n      GetSeedIdCommandResponse,\n      GetSeedIdCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  readonly name = \"getSeedId\";\n  private readonly errorHelper = new CommandErrorHelper<\n    GetSeedIdCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  constructor(private readonly args: GetSeedIdCommandArgs) {}\n  getApdu(): Apdu {\n    const { challengeTLV } = this.args;\n    const getSeedIdArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x05,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    return new ApduBuilder(getSeedIdArgs)\n      .addHexaStringToData(challengeTLV)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetSeedIdCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const required = <T>(value: T | undefined, errorMsg: string) =>\n        Maybe.fromNullable(value).toEither(\n          new InvalidStatusWordError(errorMsg),\n        );\n\n      return eitherSeqRecord({\n        credential: () =>\n          eitherSeqRecord({\n            version: () =>\n              required(parser.extract8BitUInt(), \"Version is missing\"),\n            curveId: () =>\n              required(parser.extract8BitUInt(), \"Curve ID is missing\"),\n            signAlgorithm: () =>\n              required(parser.extract8BitUInt(), \"Sign algorithm is missing\"),\n            publicKey: () =>\n              required(parser.extract8BitUInt(), \"Public key length is missing\")\n                .chain((length) =>\n                  required(\n                    parser.extractFieldByLength(length),\n                    \"Public key is missing\",\n                  ),\n                )\n                .map((str) => bufferToHexaString(str, false)),\n          }),\n\n        signature: () =>\n          required(parser.extract8BitUInt(), \"Signature length is missing\")\n            .chain((length) =>\n              required(\n                parser.extractFieldByLength(length),\n                \"Signature is missing\",\n              ),\n            )\n            .map((str) => bufferToHexaString(str, false)),\n\n        attestation: () =>\n          eitherSeqRecord({\n            id: () =>\n              required(\n                parser.extractFieldByLength(0x01),\n                \"Attestation Id is missing\",\n              ),\n            version: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation version is missing\",\n              ),\n            curveId: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation curve ID is missing\",\n              ),\n            signAlgorithm: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation sign algorithm is missing\",\n              ),\n            publicKey: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation key length is missing\",\n              ).chain((length) =>\n                required(\n                  parser.extractFieldByLength(length),\n                  \"Attestation key is missing\",\n                ),\n              ),\n            signature: () =>\n              required(\n                parser.extract8BitUInt(),\n                \"Attestation signature length is missing\",\n              ).chain((length) =>\n                required(\n                  parser.extractFieldByLength(length),\n                  \"Attestation signature is missing\",\n                ),\n              ),\n          }).map((attestation) =>\n            bufferToHexaString(\n              Uint8Array.from([\n                ...attestation.id,\n                attestation.version,\n                attestation.curveId,\n                attestation.signAlgorithm,\n                attestation.publicKey.length,\n                ...attestation.publicKey,\n                attestation.signature.length,\n                ...attestation.signature,\n              ]),\n              false,\n            ),\n          ),\n      }).caseOf({\n        Left: (error) => CommandResultFactory({ error }),\n        Right: (data) => CommandResultFactory({ data }),\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAEA,sBAAAC,EAGA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OAAS,mBAAAC,MAAuB,kCAEhC,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAiBA,MAAMC,CAOb,CAOE,YAA6BC,EAA4B,CAA5B,UAAAA,CAA6B,CANjD,KAAO,YACC,YAAc,IAAIN,EAGjCG,EAAoBC,CAAiC,EAGvD,SAAgB,CACd,KAAM,CAAE,aAAAG,CAAa,EAAI,KAAK,KACxBC,EAAiC,CACrC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAEA,OAAO,IAAIb,EAAYa,CAAa,EACjC,oBAAoBD,CAAY,EAChC,MAAM,CACX,CAEA,cACEE,EAC0E,CAC1E,OAAOR,EAAM,aACX,KAAK,YAAY,SAASQ,CAAY,CACxC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAId,EAAWa,CAAY,EAEpCE,EAAW,CAAIC,EAAsBC,IACzCZ,EAAM,aAAaW,CAAK,EAAE,SACxB,IAAIb,EAAuBc,CAAQ,CACrC,EAEF,OAAOX,EAAgB,CACrB,WAAY,IACVA,EAAgB,CACd,QAAS,IACPS,EAASD,EAAO,gBAAgB,EAAG,oBAAoB,EACzD,QAAS,IACPC,EAASD,EAAO,gBAAgB,EAAG,qBAAqB,EAC1D,cAAe,IACbC,EAASD,EAAO,gBAAgB,EAAG,2BAA2B,EAChE,UAAW,IACTC,EAASD,EAAO,gBAAgB,EAAG,8BAA8B,EAC9D,MAAOI,GACNH,EACED,EAAO,qBAAqBI,CAAM,EAClC,uBACF,CACF,EACC,IAAKC,GAAQlB,EAAmBkB,EAAK,EAAK,CAAC,CAClD,CAAC,EAEH,UAAW,IACTJ,EAASD,EAAO,gBAAgB,EAAG,6BAA6B,EAC7D,MAAOI,GACNH,EACED,EAAO,qBAAqBI,CAAM,EAClC,sBACF,CACF,EACC,IAAKC,GAAQlB,EAAmBkB,EAAK,EAAK,CAAC,EAEhD,YAAa,IACXb,EAAgB,CACd,GAAI,IACFS,EACED,EAAO,qBAAqB,CAAI,EAChC,2BACF,EACF,QAAS,IACPC,EACED,EAAO,gBAAgB,EACvB,gCACF,EACF,QAAS,IACPC,EACED,EAAO,gBAAgB,EACvB,iCACF,EACF,cAAe,IACbC,EACED,EAAO,gBAAgB,EACvB,uCACF,EACF,UAAW,IACTC,EACED,EAAO,gBAAgB,EACvB,mCACF,EAAE,MAAOI,GACPH,EACED,EAAO,qBAAqBI,CAAM,EAClC,4BACF,CACF,EACF,UAAW,IACTH,EACED,EAAO,gBAAgB,EACvB,yCACF,EAAE,MAAOI,GACPH,EACED,EAAO,qBAAqBI,CAAM,EAClC,kCACF,CACF,CACJ,CAAC,EAAE,IAAKE,GACNnB,EACE,WAAW,KAAK,CACd,GAAGmB,EAAY,GACfA,EAAY,QACZA,EAAY,QACZA,EAAY,cACZA,EAAY,UAAU,OACtB,GAAGA,EAAY,UACfA,EAAY,UAAU,OACtB,GAAGA,EAAY,SACjB,CAAC,EACD,EACF,CACF,CACJ,CAAC,EAAE,OAAO,CACR,KAAOC,GAAUnB,EAAqB,CAAE,MAAAmB,CAAM,CAAC,EAC/C,MAAQC,GAASpB,EAAqB,CAAE,KAAAoB,CAAK,CAAC,CAChD,CAAC,CACH,CAAC,CACH,CACF",
+  "names": ["ApduBuilder", "ApduParser", "bufferToHexaString", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "eitherSeqRecord", "LEDGER_SYNC_ERRORS", "LedgerKeyringProtocolErrorFactory", "GetSeedIdCommand", "args", "challengeTLV", "getSeedIdArgs", "apduResponse", "parser", "required", "value", "errorMsg", "length", "str", "attestation", "error", "data"]
 }

package/lib/esm/internal/app-binder/command/GetSeedIdCommand.test.js

@@ -1,4 +1,4 @@
-import{CommandResultFactory as n,InvalidStatusWordError as c}from"@ledgerhq/device-management-kit";import{hexToBytes as a}from"../../utils/hex";import{GetSeedIdCommand as s}from"./GetSeedIdCommand";describe("GetSeedIdCommand",()=>{const o="01020304";it("should build the correct APDU",()=>{const t=new s({challengeTLV:o}).getApdu(),e=a(o);expect(t.getRawApdu()).toEqual(Uint8Array.from([224,5,0,0,e.length,...e]))}),it("should parse the response correctly",()=>{const r=new s({challengeTLV:o}),t=a(`
+import{CommandResultFactory as s,InvalidStatusWordError as c}from"@ledgerhq/device-management-kit";import{hexaStringToBuffer as n}from"@ledgerhq/device-management-kit";import{GetSeedIdCommand as r}from"./GetSeedIdCommand";describe("GetSeedIdCommand",()=>{const o="01020304";describe("name",()=>{it("should be 'getSeedId'",()=>{const e=new r({challengeTLV:o});expect(e.name).toBe("getSeedId")})}),it("should build the correct APDU",()=>{const a=new r({challengeTLV:o}).getApdu(),t=n(o);expect(a.getRawApdu()).toEqual(Uint8Array.from([224,5,0,0,t.length,...t]))}),it("should parse the response correctly",()=>{const e=new r({challengeTLV:o}),a=n(`
         01 02 03
         06
           05 06 07 08 09 0a
@@ -11,7 +11,7 @@ import{CommandResultFactory as n,InvalidStatusWordError as c}from"@ledgerhq/devi
         05
           2e 2f 30 31 32
         12 13 14
-      `.replace(/\s+/g,"")),e=r.parseResponse({statusCode:Uint8Array.from([144,0]),data:t});expect(e).toStrictEqual(n({data:{credential:{version:1,curveId:2,signAlgorithm:3,publicKey:"05060708090a"},signature:"161718191a",attestation:"1b0102030720212223242526052e2f303132"}}))}),it("should parsing error response",()=>{const r=new s({challengeTLV:o}),t=a(`
+      `.replace(/\s+/g,"")),t=e.parseResponse({statusCode:Uint8Array.from([144,0]),data:a});expect(t).toStrictEqual(s({data:{credential:{version:1,curveId:2,signAlgorithm:3,publicKey:"05060708090a"},signature:"161718191a",attestation:"1b0102030720212223242526052e2f303132"}}))}),it("should parsing error response",()=>{const e=new r({challengeTLV:o}),a=n(`
         01 02 03
         06
           05
@@ -23,5 +23,5 @@ import{CommandResultFactory as n,InvalidStatusWordError as c}from"@ledgerhq/devi
           20 21 22 23 24 25 26
         05
           2e 2f 30 31 32
-      `.replace(/\s+/g,"")),e=r.parseResponse({statusCode:Uint8Array.from([144,0]),data:t});expect(e).toStrictEqual(n({error:expect.any(c)}))})});
+      `.replace(/\s+/g,"")),t=e.parseResponse({statusCode:Uint8Array.from([144,0]),data:a});expect(t).toStrictEqual(s({error:expect.any(c)}))})});
 //# sourceMappingURL=GetSeedIdCommand.test.js.map

package/lib/esm/internal/app-binder/command/GetSeedIdCommand.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/GetSeedIdCommand.test.ts"],
-  "sourcesContent": ["import {\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { hexToBytes } from \"@internal/utils/hex\";\n\nimport { GetSeedIdCommand } from \"./GetSeedIdCommand\";\n\ndescribe(\"GetSeedIdCommand\", () => {\n  const mockedChallenge = \"01020304\";\n\n  it(\"should build the correct APDU\", () => {\n    // GIVEN\n    const command = new GetSeedIdCommand({\n      challengeTLV: mockedChallenge,\n    });\n\n    // WHEN\n    const apdu = command.getApdu();\n\n    // THEN\n    const challengeBytes = hexToBytes(mockedChallenge);\n    expect(apdu.getRawApdu()).toEqual(\n      Uint8Array.from([\n        0xe0, // CLA\n        0x05, // INS\n        0x00, // P1\n        0x00, // P2\n        challengeBytes.length, // Lc\n        ...challengeBytes, // CData\n      ]),\n    );\n  });\n\n  it(\"should parse the response correctly\", () => {\n    // GIVEN\n    const command = new GetSeedIdCommand({\n      challengeTLV: mockedChallenge,\n    });\n    const mockedResponse = hexToBytes(\n      `\n        01 02 03\n        06\n          05 06 07 08 09 0a\n        05\n          16 17 18 19 1a\n        1b\n        01 02 03\n        07\n          20 21 22 23 24 25 26\n        05\n          2e 2f 30 31 32\n        12 13 14\n      `.replace(/\\s+/g, \"\"), // (the last three bytes should be ignored)\n    );\n\n    // WHEN\n    const result = command.parseResponse({\n      statusCode: Uint8Array.from([0x90, 0x00]),\n      data: mockedResponse,\n    });\n\n    // THEN\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        data: {\n          credential: {\n            version: 1,\n            curveId: 2,\n            signAlgorithm: 3,\n            publicKey: \"05060708090a\",\n          },\n          signature: \"161718191a\",\n          attestation: \"1b0102030720212223242526052e2f303132\",\n        },\n      }),\n    );\n  });\n\n  it(\"should parsing error response\", () => {\n    // GIVEN\n    const command = new GetSeedIdCommand({\n      challengeTLV: mockedChallenge,\n    });\n    const mockedResponse = hexToBytes(\n      `\n        01 02 03\n        06\n          05\n        05\n          16 17 18 19 1a\n        1b\n        01 02 03\n        07\n          20 21 22 23 24 25 26\n        05\n          2e 2f 30 31 32\n      `.replace(/\\s+/g, \"\"),\n    );\n\n    // WHEN\n    const result = command.parseResponse({\n      statusCode: Uint8Array.from([0x90, 0x00]),\n      data: mockedResponse,\n    });\n\n    // THEN\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        error: expect.any(InvalidStatusWordError), // (That's not an assignment to `any` maybe an eslint bug)\n      }),\n    );\n  });\n});\n"],
-  "mappings": "AAAA,OACE,wBAAAA,EACA,0BAAAC,MACK,kCAEP,OAAS,cAAAC,MAAkB,sBAE3B,OAAS,oBAAAC,MAAwB,qBAEjC,SAAS,mBAAoB,IAAM,CACjC,MAAMC,EAAkB,WAExB,GAAG,gCAAiC,IAAM,CAOxC,MAAMC,EALU,IAAIF,EAAiB,CACnC,aAAcC,CAChB,CAAC,EAGoB,QAAQ,EAGvBE,EAAiBJ,EAAWE,CAAe,EACjD,OAAOC,EAAK,WAAW,CAAC,EAAE,QACxB,WAAW,KAAK,CACd,IACA,EACA,EACA,EACAC,EAAe,OACf,GAAGA,CACL,CAAC,CACH,CACF,CAAC,EAED,GAAG,sCAAuC,IAAM,CAE9C,MAAMC,EAAU,IAAIJ,EAAiB,CACnC,aAAcC,CAChB,CAAC,EACKI,EAAiBN,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAaE,QAAQ,OAAQ,EAAE,CACtB,EAGMO,EAASF,EAAQ,cAAc,CACnC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAMC,CACR,CAAC,EAGD,OAAOC,CAAM,EAAE,cACbT,EAAqB,CACnB,KAAM,CACJ,WAAY,CACV,QAAS,EACT,QAAS,EACT,cAAe,EACf,UAAW,cACb,EACA,UAAW,aACX,YAAa,sCACf,CACF,CAAC,CACH,CACF,CAAC,EAED,GAAG,gCAAiC,IAAM,CAExC,MAAMO,EAAU,IAAIJ,EAAiB,CACnC,aAAcC,CAChB,CAAC,EACKI,EAAiBN,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAYE,QAAQ,OAAQ,EAAE,CACtB,EAGMO,EAASF,EAAQ,cAAc,CACnC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAMC,CACR,CAAC,EAGD,OAAOC,CAAM,EAAE,cACbT,EAAqB,CAEnB,MAAO,OAAO,IAAIC,CAAsB,CAC1C,CAAC,CACH,CACF,CAAC,CACH,CAAC",
-  "names": ["CommandResultFactory", "InvalidStatusWordError", "hexToBytes", "GetSeedIdCommand", "mockedChallenge", "apdu", "challengeBytes", "command", "mockedResponse", "result"]
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\n\nimport { GetSeedIdCommand } from \"./GetSeedIdCommand\";\n\ndescribe(\"GetSeedIdCommand\", () => {\n  const mockedChallenge = \"01020304\";\n\n  describe(\"name\", () => {\n    it(\"should be 'getSeedId'\", () => {\n      const command = new GetSeedIdCommand({\n        challengeTLV: mockedChallenge,\n      });\n      expect(command.name).toBe(\"getSeedId\");\n    });\n  });\n\n  it(\"should build the correct APDU\", () => {\n    // GIVEN\n    const command = new GetSeedIdCommand({\n      challengeTLV: mockedChallenge,\n    });\n\n    // WHEN\n    const apdu = command.getApdu();\n\n    // THEN\n    const challengeBytes = hexaStringToBuffer(mockedChallenge)!;\n    expect(apdu.getRawApdu()).toEqual(\n      Uint8Array.from([\n        0xe0, // CLA\n        0x05, // INS\n        0x00, // P1\n        0x00, // P2\n        challengeBytes.length, // Lc\n        ...challengeBytes, // CData\n      ]),\n    );\n  });\n\n  it(\"should parse the response correctly\", () => {\n    // GIVEN\n    const command = new GetSeedIdCommand({\n      challengeTLV: mockedChallenge,\n    });\n    const mockedResponse = hexaStringToBuffer(\n      `\n        01 02 03\n        06\n          05 06 07 08 09 0a\n        05\n          16 17 18 19 1a\n        1b\n        01 02 03\n        07\n          20 21 22 23 24 25 26\n        05\n          2e 2f 30 31 32\n        12 13 14\n      `.replace(/\\s+/g, \"\"), // (the last three bytes should be ignored)\n    )!;\n\n    // WHEN\n    const result = command.parseResponse({\n      statusCode: Uint8Array.from([0x90, 0x00]),\n      data: mockedResponse,\n    });\n\n    // THEN\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        data: {\n          credential: {\n            version: 1,\n            curveId: 2,\n            signAlgorithm: 3,\n            publicKey: \"05060708090a\",\n          },\n          signature: \"161718191a\",\n          attestation: \"1b0102030720212223242526052e2f303132\",\n        },\n      }),\n    );\n  });\n\n  it(\"should parsing error response\", () => {\n    // GIVEN\n    const command = new GetSeedIdCommand({\n      challengeTLV: mockedChallenge,\n    });\n    const mockedResponse = hexaStringToBuffer(\n      `\n        01 02 03\n        06\n          05\n        05\n          16 17 18 19 1a\n        1b\n        01 02 03\n        07\n          20 21 22 23 24 25 26\n        05\n          2e 2f 30 31 32\n      `.replace(/\\s+/g, \"\"),\n    )!;\n\n    // WHEN\n    const result = command.parseResponse({\n      statusCode: Uint8Array.from([0x90, 0x00]),\n      data: mockedResponse,\n    });\n\n    // THEN\n    expect(result).toStrictEqual(\n      CommandResultFactory({\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        error: expect.any(InvalidStatusWordError), // (That's not an assignment to `any` maybe an eslint bug)\n      }),\n    );\n  });\n});\n"],
+  "mappings": "AAAA,OACE,wBAAAA,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,kCAEnC,OAAS,oBAAAC,MAAwB,qBAEjC,SAAS,mBAAoB,IAAM,CACjC,MAAMC,EAAkB,WAExB,SAAS,OAAQ,IAAM,CACrB,GAAG,wBAAyB,IAAM,CAChC,MAAMC,EAAU,IAAIF,EAAiB,CACnC,aAAcC,CAChB,CAAC,EACD,OAAOC,EAAQ,IAAI,EAAE,KAAK,WAAW,CACvC,CAAC,CACH,CAAC,EAED,GAAG,gCAAiC,IAAM,CAOxC,MAAMC,EALU,IAAIH,EAAiB,CACnC,aAAcC,CAChB,CAAC,EAGoB,QAAQ,EAGvBG,EAAiBL,EAAmBE,CAAe,EACzD,OAAOE,EAAK,WAAW,CAAC,EAAE,QACxB,WAAW,KAAK,CACd,IACA,EACA,EACA,EACAC,EAAe,OACf,GAAGA,CACL,CAAC,CACH,CACF,CAAC,EAED,GAAG,sCAAuC,IAAM,CAE9C,MAAMF,EAAU,IAAIF,EAAiB,CACnC,aAAcC,CAChB,CAAC,EACKI,EAAiBN,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAaE,QAAQ,OAAQ,EAAE,CACtB,EAGMO,EAASJ,EAAQ,cAAc,CACnC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAMG,CACR,CAAC,EAGD,OAAOC,CAAM,EAAE,cACbT,EAAqB,CACnB,KAAM,CACJ,WAAY,CACV,QAAS,EACT,QAAS,EACT,cAAe,EACf,UAAW,cACb,EACA,UAAW,aACX,YAAa,sCACf,CACF,CAAC,CACH,CACF,CAAC,EAED,GAAG,gCAAiC,IAAM,CAExC,MAAMK,EAAU,IAAIF,EAAiB,CACnC,aAAcC,CAChB,CAAC,EACKI,EAAiBN,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAYE,QAAQ,OAAQ,EAAE,CACtB,EAGMO,EAASJ,EAAQ,cAAc,CACnC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAMG,CACR,CAAC,EAGD,OAAOC,CAAM,EAAE,cACbT,EAAqB,CAEnB,MAAO,OAAO,IAAIC,CAAsB,CAC1C,CAAC,CACH,CACF,CAAC,CACH,CAAC",
+  "names": ["CommandResultFactory", "InvalidStatusWordError", "hexaStringToBuffer", "GetSeedIdCommand", "mockedChallenge", "command", "apdu", "challengeBytes", "mockedResponse", "result"]
 }

package/lib/esm/internal/app-binder/command/GetVersionCommand.js

@@ -1,2 +1,2 @@
-import{ApduBuilder as t,ApduParser as s,CommandResultFactory as o,InvalidStatusWordError as d}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Maybe as i}from"purify-ts";import{LEDGER_SYNC_ERRORS as p,LedgerKeyringProtocolErrorFactory as a}from"./utils/ledgerKeyringProtocolErrors";class c{errorHelper=new m(p,a);getApdu(){const r={cla:224,ins:3,p1:0,p2:0};return new t(r).build()}parseResponse(r){return i.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{const e=new s(r).encodeToString(r.data);return e?o({data:{version:e}}):o({error:new d("Version is missing")})})}}export{c as GetVersionCommand};
+import{ApduBuilder as t,ApduParser as s,CommandResultFactory as o,InvalidStatusWordError as d}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Maybe as i}from"purify-ts";import{LEDGER_SYNC_ERRORS as p,LedgerKeyringProtocolErrorFactory as a}from"./utils/ledgerKeyringProtocolErrors";class c{name="getVersion";errorHelper=new m(p,a);getApdu(){const r={cla:224,ins:3,p1:0,p2:0};return new t(r).build()}parseResponse(r){return i.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{const e=new s(r).encodeToString(r.data);return e?o({data:{version:e}}):o({error:new d("Version is missing")})})}}export{c as GetVersionCommand};
 //# sourceMappingURL=GetVersionCommand.js.map

package/lib/esm/internal/app-binder/command/GetVersionCommand.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/GetVersionCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  type GetVersionCommandArgs,\n  type GetVersionCommandResponse,\n} from \"@api/app-binder/GetVersionCommandTypes\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport class GetVersionCommand\n  implements\n    Command<\n      GetVersionCommandResponse,\n      GetVersionCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    GetVersionCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const getVersionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x03,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(getVersionArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetVersionCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const version = parser.encodeToString(apduResponse.data);\n\n      if (!version) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(`Version is missing`),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { version },\n      });\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAOtB,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAEA,MAAMC,CAOb,CACmB,YAAc,IAAIJ,EAGjCE,EAAoBC,CAAiC,EAEvD,SAAgB,CACd,MAAME,EAAkC,CACtC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAGA,OADgB,IAAIT,EAAYS,CAAc,EAC/B,MAAM,CACvB,CAEA,cACEC,EAC2E,CAC3E,OAAOL,EAAM,aACX,KAAK,YAAY,SAASK,CAAY,CACxC,EAAE,cAAc,IAAM,CAGpB,MAAMC,EAFS,IAAIV,EAAWS,CAAY,EAEnB,eAAeA,EAAa,IAAI,EAEvD,OAAKC,EAMET,EAAqB,CAC1B,KAAM,CAAE,QAAAS,CAAQ,CAClB,CAAC,EAPQT,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,oBAAoB,CACxD,CAAC,CAML,CAAC,CACH,CACF",
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport { type GetVersionCommandResponse } from \"@api/app-binder/GetVersionCommandTypes\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport type GetVersionCommandArgs = undefined;\n\nexport class GetVersionCommand\n  implements\n    Command<\n      GetVersionCommandResponse,\n      GetVersionCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  readonly name = \"getVersion\";\n  private readonly errorHelper = new CommandErrorHelper<\n    GetVersionCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const getVersionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x03,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(getVersionArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetVersionCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const version = parser.encodeToString(apduResponse.data);\n\n      if (!version) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(`Version is missing`),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { version },\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAItB,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAIA,MAAMC,CAOb,CACW,KAAO,aACC,YAAc,IAAIJ,EAGjCE,EAAoBC,CAAiC,EAEvD,SAAgB,CACd,MAAME,EAAkC,CACtC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAGA,OADgB,IAAIT,EAAYS,CAAc,EAC/B,MAAM,CACvB,CAEA,cACEC,EAC2E,CAC3E,OAAOL,EAAM,aACX,KAAK,YAAY,SAASK,CAAY,CACxC,EAAE,cAAc,IAAM,CAGpB,MAAMC,EAFS,IAAIV,EAAWS,CAAY,EAEnB,eAAeA,EAAa,IAAI,EAEvD,OAAKC,EAMET,EAAqB,CAC1B,KAAM,CAAE,QAAAS,CAAQ,CAClB,CAAC,EAPQT,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,oBAAoB,CACxD,CAAC,CAML,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "LEDGER_SYNC_ERRORS", "LedgerKeyringProtocolErrorFactory", "GetVersionCommand", "getVersionArgs", "apduResponse", "version"]
 }

package/lib/esm/internal/app-binder/command/InitCommand.js

@@ -1,2 +1,2 @@
-import{ApduBuilder as o,ApduParser as t,CommandResultFactory as e,InvalidStatusWordError as n}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as d}from"@ledgerhq/signer-utils";import{Maybe as m}from"purify-ts";import{LEDGER_SYNC_ERRORS as a,LedgerKeyringProtocolErrorFactory as s}from"./utils/ledgerKeyringProtocolErrors";class C{constructor(r){this.args=r}errorHelper=new d(a,s);getApdu(){const{publicKey:r}=this.args;return new o({cla:224,ins:6,p1:0,p2:0}).addBufferToData(r).build()}parseResponse(r){return m.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>new t(r).getUnparsedRemainingLength()!==0?e({error:new n("Unexpected response data for SetTrustedMemberCommand")}):e({data:void 0}))}}export{C as InitCommand};
+import{ApduBuilder as o,ApduParser as n,CommandResultFactory as e,InvalidStatusWordError as t}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as d}from"@ledgerhq/signer-utils";import{Maybe as a}from"purify-ts";import{LEDGER_SYNC_ERRORS as m,LedgerKeyringProtocolErrorFactory as p}from"./utils/ledgerKeyringProtocolErrors";class C{constructor(r){this.args=r}name="init";errorHelper=new d(m,p);getApdu(){const{publicKey:r}=this.args;return new o({cla:224,ins:6,p1:0,p2:0}).addBufferToData(r).build()}parseResponse(r){return a.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>new n(r).getUnparsedRemainingLength()!==0?e({error:new t("Unexpected response data for SetTrustedMemberCommand")}):e({data:void 0}))}}export{C as InitCommand};
 //# sourceMappingURL=InitCommand.js.map

package/lib/esm/internal/app-binder/command/InitCommand.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/InitCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  type InitCommandArgs,\n  type InitCommandResponse,\n} from \"@api/app-binder/InitCommandTypes\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport class InitCommand\n  implements\n    Command<\n      InitCommandResponse,\n      InitCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  constructor(private readonly args: InitCommandArgs) {}\n\n  private readonly errorHelper = new CommandErrorHelper<\n    void,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const { publicKey } = this.args;\n\n    return new ApduBuilder({ cla: 0xe0, ins: 0x06, p1: 0x00, p2: 0x00 })\n      .addBufferToData(publicKey)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<InitCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n      if (parser.getUnparsedRemainingLength() !== 0) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\n            \"Unexpected response data for SetTrustedMemberCommand\",\n          ),\n        });\n      }\n      return CommandResultFactory({ data: undefined });\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EACA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAOtB,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAEA,MAAMC,CAOb,CACE,YAA6BC,EAAuB,CAAvB,UAAAA,CAAwB,CAEpC,YAAc,IAAIL,EAGjCE,EAAoBC,CAAiC,EAEvD,SAAgB,CACd,KAAM,CAAE,UAAAG,CAAU,EAAI,KAAK,KAE3B,OAAO,IAAIV,EAAY,CAAE,IAAK,IAAM,IAAK,EAAM,GAAI,EAAM,GAAI,CAAK,CAAC,EAChE,gBAAgBU,CAAS,EACzB,MAAM,CACX,CAEA,cACEC,EACqE,CACrE,OAAON,EAAM,aACX,KAAK,YAAY,SAASM,CAAY,CACxC,EAAE,cAAc,IACC,IAAIV,EAAWU,CAAY,EAC/B,2BAA2B,IAAM,EACnCT,EAAqB,CAC1B,MAAO,IAAIC,EACT,sDACF,CACF,CAAC,EAEID,EAAqB,CAAE,KAAM,MAAU,CAAC,CAChD,CACH,CACF",
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport type InitCommandResponse = void;\n\nexport type InitCommandArgs = {\n  publicKey: Uint8Array;\n};\n\nexport class InitCommand\n  implements\n    Command<\n      InitCommandResponse,\n      InitCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  readonly name = \"init\";\n  constructor(private readonly args: InitCommandArgs) {}\n\n  private readonly errorHelper = new CommandErrorHelper<\n    void,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const { publicKey } = this.args;\n\n    return new ApduBuilder({ cla: 0xe0, ins: 0x06, p1: 0x00, p2: 0x00 })\n      .addBufferToData(publicKey)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<InitCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n      if (parser.getUnparsedRemainingLength() !== 0) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\n            \"Unexpected response data for SetTrustedMemberCommand\",\n          ),\n        });\n      }\n      return CommandResultFactory({ data: undefined });\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EACA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,sBAAAC,EAEA,qCAAAC,MACK,sCAQA,MAAMC,CAOb,CAEE,YAA6BC,EAAuB,CAAvB,UAAAA,CAAwB,CAD5C,KAAO,OAGC,YAAc,IAAIL,EAGjCE,EAAoBC,CAAiC,EAEvD,SAAgB,CACd,KAAM,CAAE,UAAAG,CAAU,EAAI,KAAK,KAE3B,OAAO,IAAIV,EAAY,CAAE,IAAK,IAAM,IAAK,EAAM,GAAI,EAAM,GAAI,CAAK,CAAC,EAChE,gBAAgBU,CAAS,EACzB,MAAM,CACX,CAEA,cACEC,EACqE,CACrE,OAAON,EAAM,aACX,KAAK,YAAY,SAASM,CAAY,CACxC,EAAE,cAAc,IACC,IAAIV,EAAWU,CAAY,EAC/B,2BAA2B,IAAM,EACnCT,EAAqB,CAC1B,MAAO,IAAIC,EACT,sDACF,CACF,CAAC,EAEID,EAAqB,CAAE,KAAM,MAAU,CAAC,CAChD,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "LEDGER_SYNC_ERRORS", "LedgerKeyringProtocolErrorFactory", "InitCommand", "args", "publicKey", "apduResponse"]
 }

package/lib/esm/internal/app-binder/command/InitCommand.test.js

@@ -1,2 +1,2 @@
-import{ApduResponse as i,InvalidStatusWordError as m,isSuccessCommandResult as s}from"@ledgerhq/device-management-kit";import{describe as c,expect as e,it as n}from"vitest";import{InitCommand as a}from"./InitCommand";const p=Uint8Array.from([2,...Array(32).fill(0)]),x=Uint8Array.from([240,202,204,26]),d=()=>({publicKey:p});c("InitCommand",()=>{c("getApdu()",()=>{n("builds correct APDU",()=>{const o=new a(d()).getApdu(),r=Uint8Array.from([224,6,0,0,33,2,...new Array(32).fill(0)]);e(o.getRawApdu()).toEqual(r)})}),c("parseResponse()",()=>{n("returns success when no data and SW=0x9000",()=>{const t=new a(d()),o=new i({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),r=t.parseResponse(o);e(s(r)).toBe(!0),s(r)&&e(r.data).toBeUndefined()}),n("errors on unexpected trailing data",()=>{const t=new a(d()),o=new i({statusCode:Uint8Array.from([144,0]),data:x}),r=t.parseResponse(o);e(s(r)).toBe(!1),s(r)||(e(r.error).toBeInstanceOf(m),e(r.error.originalError.message).toMatch("Unexpected response data"))}),n("maps SW errors to CommandResult error",()=>{const t=new a(d()),o=new i({statusCode:Uint8Array.from([106,134]),data:new Uint8Array([])}),r=t.parseResponse(o);if(e(s(r)).toBe(!1),!s(r))if("errorCode"in r.error)e(r.error.errorCode).toEqual("6a86");else throw new Error("Unexpected error type: missing errorCode")})})});
+import{ApduResponse as i,InvalidStatusWordError as m,isSuccessCommandResult as n}from"@ledgerhq/device-management-kit";import{describe as c,expect as r,it as s}from"vitest";import{InitCommand as a}from"./InitCommand";const p=Uint8Array.from([2,...Array(32).fill(0)]),u=Uint8Array.from([240,202,204,26]),d=()=>({publicKey:p});c("InitCommand",()=>{c("name",()=>{s("should be 'init'",()=>{const o=new a(d());r(o.name).toBe("init")})}),c("getApdu()",()=>{s("builds correct APDU",()=>{const t=new a(d()).getApdu(),e=Uint8Array.from([224,6,0,0,33,2,...new Array(32).fill(0)]);r(t.getRawApdu()).toEqual(e)})}),c("parseResponse()",()=>{s("returns success when no data and SW=0x9000",()=>{const o=new a(d()),t=new i({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),e=o.parseResponse(t);r(n(e)).toBe(!0),n(e)&&r(e.data).toBeUndefined()}),s("errors on unexpected trailing data",()=>{const o=new a(d()),t=new i({statusCode:Uint8Array.from([144,0]),data:u}),e=o.parseResponse(t);r(n(e)).toBe(!1),n(e)||(r(e.error).toBeInstanceOf(m),r(e.error.originalError.message).toMatch("Unexpected response data"))}),s("maps SW errors to CommandResult error",()=>{const o=new a(d()),t=new i({statusCode:Uint8Array.from([106,134]),data:new Uint8Array([])}),e=o.parseResponse(t);if(r(n(e)).toBe(!1),!n(e))if("errorCode"in e.error)r(e.error.errorCode).toEqual("6a86");else throw new Error("Unexpected error type: missing errorCode")})})});
 //# sourceMappingURL=InitCommand.test.js.map

package/lib/esm/internal/app-binder/command/InitCommand.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/InitCommand.test.ts"],
-  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-unsafe-assignment */\nimport {\n  ApduResponse,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { describe, expect, it } from \"vitest\";\n\nimport type { InitCommandArgs } from \"@api/app-binder/InitCommandTypes\";\n\nimport { InitCommand } from \"./InitCommand\";\n\nconst DUMMY_PUBKEY_HEX = Uint8Array.from([0x02, ...Array(32).fill(0x00)]);\nconst PLACEHOLDER_BYTES = Uint8Array.from([0xf0, 0xca, 0xcc, 0x1a]);\n\nconst makeArgs = (): InitCommandArgs => ({ publicKey: DUMMY_PUBKEY_HEX });\n\ndescribe(\"InitCommand\", () => {\n  describe(\"getApdu()\", () => {\n    it(\"builds correct APDU\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n\n      // when\n      const apdu = cmd.getApdu();\n      const expected = Uint8Array.from([\n        0xe0,\n        0x06,\n        0x00,\n        0x00,\n        0x21,\n        0x02,\n        ...new Array(32).fill(0),\n      ]);\n\n      // then\n      expect(apdu.getRawApdu()).toEqual(expected);\n    });\n  });\n\n  describe(\"parseResponse()\", () => {\n    it(\"returns success when no data and SW=0x9000\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      });\n\n      // when\n      const result = cmd.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(true);\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toBeUndefined();\n      }\n    });\n\n    it(\"errors on unexpected trailing data\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: PLACEHOLDER_BYTES,\n      });\n\n      // when\n      const result = cmd.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n      if (!isSuccessCommandResult(result)) {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect((result.error.originalError as Error).message).toMatch(\n          \"Unexpected response data\",\n        );\n      }\n    });\n\n    it(\"maps SW errors to CommandResult error\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6a, 0x86]),\n        data: new Uint8Array([]),\n      });\n\n      // when\n      const result = cmd.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n      if (!isSuccessCommandResult(result)) {\n        if (\"errorCode\" in result.error) {\n          expect(result.error.errorCode).toEqual(\"6a86\");\n        } else {\n          throw new Error(\"Unexpected error type: missing errorCode\");\n        }\n      }\n    });\n  });\n});\n"],
-  "mappings": "AACA,OACE,gBAAAA,EACA,0BAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,YAAAC,EAAU,UAAAC,EAAQ,MAAAC,MAAU,SAIrC,OAAS,eAAAC,MAAmB,gBAE5B,MAAMC,EAAmB,WAAW,KAAK,CAAC,EAAM,GAAG,MAAM,EAAE,EAAE,KAAK,CAAI,CAAC,CAAC,EAClEC,EAAoB,WAAW,KAAK,CAAC,IAAM,IAAM,IAAM,EAAI,CAAC,EAE5DC,EAAW,KAAwB,CAAE,UAAWF,CAAiB,GAEvEJ,EAAS,cAAe,IAAM,CAC5BA,EAAS,YAAa,IAAM,CAC1BE,EAAG,sBAAuB,IAAM,CAK9B,MAAMK,EAHM,IAAIJ,EAAYG,EAAS,CAAC,EAGrB,QAAQ,EACnBE,EAAW,WAAW,KAAK,CAC/B,IACA,EACA,EACA,EACA,GACA,EACA,GAAG,IAAI,MAAM,EAAE,EAAE,KAAK,CAAC,CACzB,CAAC,EAGDP,EAAOM,EAAK,WAAW,CAAC,EAAE,QAAQC,CAAQ,CAC5C,CAAC,CACH,CAAC,EAEDR,EAAS,kBAAmB,IAAM,CAChCE,EAAG,6CAA8C,IAAM,CAErD,MAAMO,EAAM,IAAIN,EAAYG,EAAS,CAAC,EAChCI,EAAW,IAAIb,EAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKc,EAASF,EAAI,cAAcC,CAAQ,EAGzCT,EAAOF,EAAuBY,CAAM,CAAC,EAAE,KAAK,EAAI,EAC5CZ,EAAuBY,CAAM,GAC/BV,EAAOU,EAAO,IAAI,EAAE,cAAc,CAEtC,CAAC,EAEDT,EAAG,qCAAsC,IAAM,CAE7C,MAAMO,EAAM,IAAIN,EAAYG,EAAS,CAAC,EAChCI,EAAW,IAAIb,EAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAMQ,CACR,CAAC,EAGKM,EAASF,EAAI,cAAcC,CAAQ,EAGzCT,EAAOF,EAAuBY,CAAM,CAAC,EAAE,KAAK,EAAK,EAC5CZ,EAAuBY,CAAM,IAChCV,EAAOU,EAAO,KAAK,EAAE,eAAeb,CAAsB,EAC1DG,EAAQU,EAAO,MAAM,cAAwB,OAAO,EAAE,QACpD,0BACF,EAEJ,CAAC,EAEDT,EAAG,wCAAyC,IAAM,CAEhD,MAAMO,EAAM,IAAIN,EAAYG,EAAS,CAAC,EAChCI,EAAW,IAAIb,EAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,GAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKc,EAASF,EAAI,cAAcC,CAAQ,EAIzC,GADAT,EAAOF,EAAuBY,CAAM,CAAC,EAAE,KAAK,EAAK,EAC7C,CAACZ,EAAuBY,CAAM,EAChC,GAAI,cAAeA,EAAO,MACxBV,EAAOU,EAAO,MAAM,SAAS,EAAE,QAAQ,MAAM,MAE7C,OAAM,IAAI,MAAM,0CAA0C,CAGhE,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["ApduResponse", "InvalidStatusWordError", "isSuccessCommandResult", "describe", "expect", "it", "InitCommand", "DUMMY_PUBKEY_HEX", "PLACEHOLDER_BYTES", "makeArgs", "apdu", "expected", "cmd", "response", "result"]
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-unsafe-assignment */\nimport {\n  ApduResponse,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { describe, expect, it } from \"vitest\";\n\nimport { InitCommand, type InitCommandArgs } from \"./InitCommand\";\n\nconst DUMMY_PUBKEY_HEX = Uint8Array.from([0x02, ...Array(32).fill(0x00)]);\nconst PLACEHOLDER_BYTES = Uint8Array.from([0xf0, 0xca, 0xcc, 0x1a]);\n\nconst makeArgs = (): InitCommandArgs => ({ publicKey: DUMMY_PUBKEY_HEX });\n\ndescribe(\"InitCommand\", () => {\n  describe(\"name\", () => {\n    it(\"should be 'init'\", () => {\n      const cmd = new InitCommand(makeArgs());\n      expect(cmd.name).toBe(\"init\");\n    });\n  });\n\n  describe(\"getApdu()\", () => {\n    it(\"builds correct APDU\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n\n      // when\n      const apdu = cmd.getApdu();\n      const expected = Uint8Array.from([\n        0xe0,\n        0x06,\n        0x00,\n        0x00,\n        0x21,\n        0x02,\n        ...new Array(32).fill(0),\n      ]);\n\n      // then\n      expect(apdu.getRawApdu()).toEqual(expected);\n    });\n  });\n\n  describe(\"parseResponse()\", () => {\n    it(\"returns success when no data and SW=0x9000\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      });\n\n      // when\n      const result = cmd.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(true);\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toBeUndefined();\n      }\n    });\n\n    it(\"errors on unexpected trailing data\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: PLACEHOLDER_BYTES,\n      });\n\n      // when\n      const result = cmd.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n      if (!isSuccessCommandResult(result)) {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect((result.error.originalError as Error).message).toMatch(\n          \"Unexpected response data\",\n        );\n      }\n    });\n\n    it(\"maps SW errors to CommandResult error\", () => {\n      // given\n      const cmd = new InitCommand(makeArgs());\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6a, 0x86]),\n        data: new Uint8Array([]),\n      });\n\n      // when\n      const result = cmd.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n      if (!isSuccessCommandResult(result)) {\n        if (\"errorCode\" in result.error) {\n          expect(result.error.errorCode).toEqual(\"6a86\");\n        } else {\n          throw new Error(\"Unexpected error type: missing errorCode\");\n        }\n      }\n    });\n  });\n});\n"],
+  "mappings": "AACA,OACE,gBAAAA,EACA,0BAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,YAAAC,EAAU,UAAAC,EAAQ,MAAAC,MAAU,SAErC,OAAS,eAAAC,MAAyC,gBAElD,MAAMC,EAAmB,WAAW,KAAK,CAAC,EAAM,GAAG,MAAM,EAAE,EAAE,KAAK,CAAI,CAAC,CAAC,EAClEC,EAAoB,WAAW,KAAK,CAAC,IAAM,IAAM,IAAM,EAAI,CAAC,EAE5DC,EAAW,KAAwB,CAAE,UAAWF,CAAiB,GAEvEJ,EAAS,cAAe,IAAM,CAC5BA,EAAS,OAAQ,IAAM,CACrBE,EAAG,mBAAoB,IAAM,CAC3B,MAAMK,EAAM,IAAIJ,EAAYG,EAAS,CAAC,EACtCL,EAAOM,EAAI,IAAI,EAAE,KAAK,MAAM,CAC9B,CAAC,CACH,CAAC,EAEDP,EAAS,YAAa,IAAM,CAC1BE,EAAG,sBAAuB,IAAM,CAK9B,MAAMM,EAHM,IAAIL,EAAYG,EAAS,CAAC,EAGrB,QAAQ,EACnBG,EAAW,WAAW,KAAK,CAC/B,IACA,EACA,EACA,EACA,GACA,EACA,GAAG,IAAI,MAAM,EAAE,EAAE,KAAK,CAAC,CACzB,CAAC,EAGDR,EAAOO,EAAK,WAAW,CAAC,EAAE,QAAQC,CAAQ,CAC5C,CAAC,CACH,CAAC,EAEDT,EAAS,kBAAmB,IAAM,CAChCE,EAAG,6CAA8C,IAAM,CAErD,MAAMK,EAAM,IAAIJ,EAAYG,EAAS,CAAC,EAChCI,EAAW,IAAIb,EAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKc,EAASJ,EAAI,cAAcG,CAAQ,EAGzCT,EAAOF,EAAuBY,CAAM,CAAC,EAAE,KAAK,EAAI,EAC5CZ,EAAuBY,CAAM,GAC/BV,EAAOU,EAAO,IAAI,EAAE,cAAc,CAEtC,CAAC,EAEDT,EAAG,qCAAsC,IAAM,CAE7C,MAAMK,EAAM,IAAIJ,EAAYG,EAAS,CAAC,EAChCI,EAAW,IAAIb,EAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAMQ,CACR,CAAC,EAGKM,EAASJ,EAAI,cAAcG,CAAQ,EAGzCT,EAAOF,EAAuBY,CAAM,CAAC,EAAE,KAAK,EAAK,EAC5CZ,EAAuBY,CAAM,IAChCV,EAAOU,EAAO,KAAK,EAAE,eAAeb,CAAsB,EAC1DG,EAAQU,EAAO,MAAM,cAAwB,OAAO,EAAE,QACpD,0BACF,EAEJ,CAAC,EAEDT,EAAG,wCAAyC,IAAM,CAEhD,MAAMK,EAAM,IAAIJ,EAAYG,EAAS,CAAC,EAChCI,EAAW,IAAIb,EAAa,CAChC,WAAY,WAAW,KAAK,CAAC,IAAM,GAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,EAGKc,EAASJ,EAAI,cAAcG,CAAQ,EAIzC,GADAT,EAAOF,EAAuBY,CAAM,CAAC,EAAE,KAAK,EAAK,EAC7C,CAACZ,EAAuBY,CAAM,EAChC,GAAI,cAAeA,EAAO,MACxBV,EAAOU,EAAO,MAAM,SAAS,EAAE,QAAQ,MAAM,MAE7C,OAAM,IAAI,MAAM,0CAA0C,CAGhE,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["ApduResponse", "InvalidStatusWordError", "isSuccessCommandResult", "describe", "expect", "it", "InitCommand", "DUMMY_PUBKEY_HEX", "PLACEHOLDER_BYTES", "makeArgs", "cmd", "apdu", "expected", "response", "result"]
 }

package/lib/esm/internal/app-binder/command/ParseBlockSignatureCommand.js

@@ -1,2 +1,2 @@
-import{ApduBuilder as t,ApduParser as s,CommandResultFactory as a,InvalidStatusWordError as m}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as d}from"@ledgerhq/signer-utils";import{Maybe as p}from"purify-ts";import{LEDGER_SYNC_ERRORS as i,LedgerKeyringProtocolErrorFactory as l}from"./utils/ledgerKeyringProtocolErrors";class P{constructor(r){this.args=r}errorHelper=new d(i,l);getApdu(){const{signature:r}=this.args;return new t({cla:224,ins:8,p1:2,p2:0}).addBufferToData(r).build()}parseResponse(r){return p.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{const e=new s(r),n=e.getUnparsedRemainingLength(),o=e.extractFieldByLength(n);return o?a({data:o}):a({error:new m("No data returned by ParseBlockSignatureCommand")})})}}export{P as ParseBlockSignatureCommand};
+import{ApduBuilder as t,ApduParser as s,CommandResultFactory as a,InvalidStatusWordError as d}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Maybe as p}from"purify-ts";import{LEDGER_SYNC_ERRORS as i,LedgerKeyringProtocolErrorFactory as l}from"./utils/ledgerKeyringProtocolErrors";class P{constructor(r){this.args=r}name="parseBlockSignature";errorHelper=new m(i,l);getApdu(){const{signature:r}=this.args;return new t({cla:224,ins:8,p1:2,p2:0}).addBufferToData(r).build()}parseResponse(r){return p.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{const e=new s(r),n=e.getUnparsedRemainingLength(),o=e.extractFieldByLength(n);return o?a({data:o}):a({error:new d("No data returned by ParseBlockSignatureCommand")})})}}export{P as ParseBlockSignatureCommand};
 //# sourceMappingURL=ParseBlockSignatureCommand.js.map