@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol 0.0.0-develop-20250903001157 → 0.0.0-e2e-speculos-20250904104129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol",
-  "version": "0.0.0-develop-20250903001157",
+  "version": "0.0.0-e2e-speculos-20250904104129",
   "license": "Apache-2.0",
   "private": false,
   "exports": {
@@ -20,21 +20,20 @@
   ],
   "dependencies": {
     "@noble/ciphers": "^1.3.0",
-    "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
+    "@noble/secp256k1": "^2.3.0",
     "inversify": "7.5.1",
     "purify-ts": "2.1.0",
     "reflect-metadata": "0.2.2",
-    "rxjs": "7.8.2",
     "xstate": "5.19.2",
-    "@ledgerhq/device-management-kit": "0.0.0-develop-20250903001157",
-    "@ledgerhq/signer-utils": "0.0.0-develop-20250903001157"
+    "@ledgerhq/device-management-kit": "0.0.0-e2e-speculos-20250904104129",
+    "@ledgerhq/signer-utils": "0.0.0-e2e-speculos-20250904104129"
   },
   "devDependencies": {
-    "@ledgerhq/eslint-config-dsdk": "0.0.2",
     "@ledgerhq/ldmk-tool": "0.0.1",
-    "@ledgerhq/prettier-config-dsdk": "0.0.2",
+    "@ledgerhq/eslint-config-dsdk": "0.0.2",
     "@ledgerhq/tsconfig-dsdk": "1.0.1",
+    "@ledgerhq/prettier-config-dsdk": "0.0.2",
     "@ledgerhq/vitest-config-dmk": "0.0.0"
   },
   "scripts": {

package/lib/cjs/api/crypto/CryptoService.js

@@ -1,2 +0,0 @@
-"use strict";var a=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var K=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var c=(t,r)=>{for(var e in r)a(t,e,{get:r[e],enumerable:!0})},P=(t,r,e,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let y of K(r))!A.call(t,y)&&y!==e&&a(t,y,{get:()=>r[y],enumerable:!(i=p(r,y))||i.enumerable});return t};var U=t=>P(a({},"__esModule",{value:!0}),t);var s={};c(s,{Curve:()=>m,EncryptionAlgo:()=>o,HashAlgo:()=>n});module.exports=U(s);var m=(e=>(e[e.K256=0]="K256",e[e.P256=1]="P256",e))(m||{}),o=(r=>(r[r.AES256_GCM=0]="AES256_GCM",r))(o||{}),n=(r=>(r[r.SHA256=0]="SHA256",r))(n||{});0&&(module.exports={Curve,EncryptionAlgo,HashAlgo});
-//# sourceMappingURL=CryptoService.js.map

package/lib/cjs/api/crypto/CryptoService.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/api/crypto/CryptoService.ts"],
-  "sourcesContent": ["import { type Key } from \"./Key\";\nimport { type KeyPair } from \"./KeyPair\";\n\nexport enum Curve {\n  K256, // secp256k1\n  P256, // P-256\n}\n\nexport enum EncryptionAlgo {\n  AES256_GCM,\n}\n\nexport enum HashAlgo {\n  SHA256,\n}\n\nexport interface CryptoService {\n  // Generate a random buffer\n  randomBytes(len: number): Uint8Array;\n\n  // Compute a hash\n  hash(bytes: Uint8Array, algo: HashAlgo): Uint8Array;\n\n  // Compute a HMAC\n  hmac(key: Uint8Array, message: Uint8Array, algo: HashAlgo): Uint8Array;\n\n  // Generate a new random keypair\n  createKeyPair(curve: Curve): Promise<KeyPair>;\n\n  // Import a keypair\n  importKeyPair(privateKey: Uint8Array, curve: Curve): KeyPair;\n\n  // Generate a new random symmetric key\n  createSymmetricKey(algo: EncryptionAlgo): Promise<Key>;\n\n  // Import a symmetric key\n  importSymmetricKey(keyMaterial: Uint8Array, algo: EncryptionAlgo): Key;\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,WAAAE,EAAA,mBAAAC,EAAA,aAAAC,IAAA,eAAAC,EAAAL,GAGO,IAAKE,OACVA,IAAA,eACAA,IAAA,eAFUA,OAAA,IAKAC,OACVA,IAAA,2BADUA,OAAA,IAIAC,OACVA,IAAA,mBADUA,OAAA",
-  "names": ["CryptoService_exports", "__export", "Curve", "EncryptionAlgo", "HashAlgo", "__toCommonJS"]
-}

package/lib/cjs/api/crypto/Key.js

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

package/lib/cjs/api/crypto/Key.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/api/crypto/Key.ts"],
-  "sourcesContent": ["export const AES256_KEY_SIZE = 32;\nexport const AES256_BLOCK_SIZE = 16;\n\nexport interface Key {\n  encrypt(iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;\n  decrypt(iv: Uint8Array, encryptedData: Uint8Array): Promise<Uint8Array>;\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,EAAA,oBAAAC,IAAA,eAAAC,EAAAJ,GAAO,MAAMG,EAAkB,GAClBD,EAAoB",
-  "names": ["Key_exports", "__export", "AES256_BLOCK_SIZE", "AES256_KEY_SIZE", "__toCommonJS"]
-}

package/lib/cjs/api/crypto/KeyPair.js

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

package/lib/cjs/api/crypto/KeyPair.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/api/crypto/KeyPair.ts"],
-  "sourcesContent": ["export enum SigFormat {\n  COMPACT,\n  DER,\n}\n\nexport interface KeyPair {\n  id: string;\n  sign(data: Uint8Array, format?: SigFormat): Promise<Uint8Array>;\n  verify(\n    data: Uint8Array,\n    signature: Uint8Array,\n    format?: SigFormat,\n  ): Promise<boolean>;\n  deriveSharedSecret(peerPublicKey: Uint8Array): Promise<Uint8Array>;\n  getPublicKey(): Uint8Array;\n  getPublicKeyToHex(): string;\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,eAAAE,IAAA,eAAAC,EAAAH,GAAO,IAAKE,OACVA,IAAA,qBACAA,IAAA,aAFUA,OAAA",
-  "names": ["KeyPair_exports", "__export", "SigFormat", "__toCommonJS"]
-}

package/lib/cjs/api/crypto/noble/NobleCryptoService.js

@@ -1,2 +0,0 @@
-"use strict";var a=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var A=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var l=(t,r)=>{for(var e in r)a(t,e,{get:r[e],enumerable:!0})},f=(t,r,e,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of A(r))!u.call(t,i)&&i!==e&&a(t,i,{get:()=>r[i],enumerable:!(o=h(r,i))||o.enumerable});return t};var K=t=>f(a({},"__esModule",{value:!0}),t);var g={};l(g,{NobleCryptoService:()=>U});module.exports=K(g);var s=require("@noble/ciphers/webcrypto"),c=require("@noble/hashes/hmac"),y=require("@noble/hashes/sha256"),m=require("../../crypto/CryptoService"),n=require("./NobleKey"),p=require("./NobleKeyPair");class U{randomBytes(r){return(0,s.randomBytes)(r)}hash(r,e){switch(e){case m.HashAlgo.SHA256:return(0,y.sha256)(r);default:throw new Error("Unsupported hash algorithm",e)}}hmac(r,e,o){switch(o){case m.HashAlgo.SHA256:return(0,c.hmac)(y.sha256,r,e);default:throw new Error("Unsupported hash algorithm",o)}}async createKeyPair(r){return await p.NobleKeyPair.generate(r)}importKeyPair(r,e){return p.NobleKeyPair.from(r,e)}async createSymmetricKey(r){return await n.NobleKey.generate(r)}importSymmetricKey(r,e){return n.NobleKey.from(r,e)}}0&&(module.exports={NobleCryptoService});
-//# sourceMappingURL=NobleCryptoService.js.map

package/lib/cjs/api/crypto/noble/NobleCryptoService.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/api/crypto/noble/NobleCryptoService.ts"],
-  "sourcesContent": ["import { randomBytes } from \"@noble/ciphers/webcrypto\";\nimport { hmac } from \"@noble/hashes/hmac\";\nimport { sha256 } from \"@noble/hashes/sha256\";\n\nimport {\n  type CryptoService,\n  type Curve,\n  type EncryptionAlgo,\n  HashAlgo,\n} from \"@api/crypto/CryptoService\";\nimport { type Key } from \"@api/crypto/Key\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\n\nimport { NobleKey } from \"./NobleKey\";\nimport { NobleKeyPair } from \"./NobleKeyPair\";\n\nexport class NobleCryptoService implements CryptoService {\n  randomBytes(len: number): Uint8Array {\n    return randomBytes(len);\n  }\n\n  hash(bytes: Uint8Array, algo: HashAlgo): Uint8Array {\n    switch (algo) {\n      case HashAlgo.SHA256:\n        return sha256(bytes);\n      default:\n        throw new Error(\"Unsupported hash algorithm\", algo);\n    }\n  }\n\n  hmac(key: Uint8Array, message: Uint8Array, algo: HashAlgo): Uint8Array {\n    switch (algo) {\n      case HashAlgo.SHA256:\n        return hmac(sha256, key, message);\n      default:\n        throw new Error(\"Unsupported hash algorithm\", algo);\n    }\n  }\n\n  async createKeyPair(curve: Curve): Promise<KeyPair> {\n    return await NobleKeyPair.generate(curve);\n  }\n\n  importKeyPair(privateKey: Uint8Array, curve: Curve): KeyPair {\n    return NobleKeyPair.from(privateKey, curve);\n  }\n\n  async createSymmetricKey(algo: EncryptionAlgo): Promise<Key> {\n    return await NobleKey.generate(algo);\n  }\n\n  importSymmetricKey(keyMaterial: Uint8Array, algo: EncryptionAlgo): Key {\n    return NobleKey.from(keyMaterial, algo);\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAA4B,oCAC5BC,EAAqB,8BACrBC,EAAuB,gCAEvBC,EAKO,qCAIPC,EAAyB,sBACzBC,EAA6B,0BAEtB,MAAMP,CAA4C,CACvD,YAAYQ,EAAyB,CACnC,SAAO,eAAYA,CAAG,CACxB,CAEA,KAAKC,EAAmBC,EAA4B,CAClD,OAAQA,EAAM,CACZ,KAAK,WAAS,OACZ,SAAO,UAAOD,CAAK,EACrB,QACE,MAAM,IAAI,MAAM,6BAA8BC,CAAI,CACtD,CACF,CAEA,KAAKC,EAAiBC,EAAqBF,EAA4B,CACrE,OAAQA,EAAM,CACZ,KAAK,WAAS,OACZ,SAAO,QAAK,SAAQC,EAAKC,CAAO,EAClC,QACE,MAAM,IAAI,MAAM,6BAA8BF,CAAI,CACtD,CACF,CAEA,MAAM,cAAcG,EAAgC,CAClD,OAAO,MAAM,eAAa,SAASA,CAAK,CAC1C,CAEA,cAAcC,EAAwBD,EAAuB,CAC3D,OAAO,eAAa,KAAKC,EAAYD,CAAK,CAC5C,CAEA,MAAM,mBAAmBH,EAAoC,CAC3D,OAAO,MAAM,WAAS,SAASA,CAAI,CACrC,CAEA,mBAAmBK,EAAyBL,EAA2B,CACrE,OAAO,WAAS,KAAKK,EAAaL,CAAI,CACxC,CACF",
-  "names": ["NobleCryptoService_exports", "__export", "NobleCryptoService", "__toCommonJS", "import_webcrypto", "import_hmac", "import_sha256", "import_CryptoService", "import_NobleKey", "import_NobleKeyPair", "len", "bytes", "algo", "key", "message", "curve", "privateKey", "keyMaterial"]
-}

package/lib/cjs/api/crypto/noble/NobleCryptoService.test.js

@@ -1,2 +0,0 @@
-"use strict";var c=require("@ledgerhq/device-management-kit"),o=require("../../crypto/CryptoService"),n=require("./NobleCryptoService"),a=require("./NobleKey"),i=require("./NobleKeyPair");describe("NobleCryptoService",()=>{let r;beforeEach(()=>{r=new n.NobleCryptoService}),it("should generate random bytes of correct length",()=>{const t=r.randomBytes(32);expect(t.length).toBe(32)}),it("should hash data correctly with SHA256",()=>{const e=new TextEncoder().encode("test"),t=r.hash(e,o.HashAlgo.SHA256);expect(t).toEqual((0,c.hexaStringToBuffer)("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"))}),it("should compute HMAC correctly with SHA256",()=>{const e=new Uint8Array(32).fill(97),t=new TextEncoder().encode("test message"),s=r.hmac(e,t,o.HashAlgo.SHA256);expect(s).toEqual((0,c.hexaStringToBuffer)("0b19ad8fef1660f7a191465effeea922079633ada962f52cb60103d9935cc460"))}),it("should create a key pair",async()=>{const e=await r.createKeyPair(o.Curve.K256);expect(e instanceof i.NobleKeyPair).toBeTruthy()}),it("should import a key pair",()=>{const e=new Uint8Array(32).fill(1),t=r.importKeyPair(e,o.Curve.K256);expect(t instanceof i.NobleKeyPair).toBeTruthy()}),it("should create a symmetric key",async()=>{const e=await r.createSymmetricKey(o.EncryptionAlgo.AES256_GCM);expect(e instanceof a.NobleKey).toBeTruthy()}),it("should import a symmetric key",()=>{const e=new Uint8Array(32).fill(1),t=r.importSymmetricKey(e,o.EncryptionAlgo.AES256_GCM);expect(t instanceof a.NobleKey).toBeTruthy()})});
-//# sourceMappingURL=NobleCryptoService.test.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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,IAAAA,EAAmC,2CAEnCC,EAAgD,qCAEhDC,EAAmC,gCACnCC,EAAyB,sBACzBC,EAA6B,0BAE7B,SAAS,qBAAsB,IAAM,CACnC,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAgB,IAAI,oBACtB,CAAC,EAED,GAAG,iDAAkD,IAAM,CAEzD,MAAMC,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,EAAM,WAAS,MAAM,EAC3D,OAAOC,CAAU,EAAE,WACjB,sBACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMC,EAAM,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EAClCC,EAAU,IAAI,YAAY,EAAE,OAAO,cAAc,EACjDC,EAAaN,EAAc,KAAKI,EAAKC,EAAS,WAAS,MAAM,EACnE,OAAOC,CAAU,EAAE,WACjB,sBACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,2BAA4B,SAAY,CACzC,MAAMC,EAAU,MAAMP,EAAc,cAAc,QAAM,IAAI,EAC5D,OAAOO,aAAmB,cAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,2BAA4B,IAAM,CACnC,MAAMC,EAAa,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACtCD,EAAUP,EAAc,cAAcQ,EAAY,QAAM,IAAI,EAClE,OAAOD,aAAmB,cAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,gCAAiC,SAAY,CAC9C,MAAME,EAAe,MAAMT,EAAc,mBACvC,iBAAe,UACjB,EACA,OAAOS,aAAwB,UAAQ,EAAE,WAAW,CACtD,CAAC,EAED,GAAG,gCAAiC,IAAM,CACxC,MAAMC,EAAc,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACvCD,EAAeT,EAAc,mBACjCU,EACA,iBAAe,UACjB,EACA,OAAOD,aAAwB,UAAQ,EAAE,WAAW,CACtD,CAAC,CACH,CAAC",
-  "names": ["import_device_management_kit", "import_CryptoService", "import_NobleCryptoService", "import_NobleKey", "import_NobleKeyPair", "cryptoService", "bytes", "data", "hashResult", "key", "message", "hmacResult", "keyPair", "privateKey", "symmetricKey", "keyMaterial"]
-}

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

@@ -1,2 +0,0 @@
-"use strict";var p=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var A=Object.getOwnPropertyNames;var E=Object.prototype.hasOwnProperty;var h=(e,r)=>{for(var t in r)p(e,t,{get:r[t],enumerable:!0})},U=(e,r,t,y)=>{if(r&&typeof r=="object"||typeof r=="function")for(let n of A(r))!E.call(e,n)&&n!==t&&p(e,n,{get:()=>r[n],enumerable:!(y=m(r,n))||y.enumerable});return e};var l=e=>U(p({},"__esModule",{value:!0}),e);var S={};h(S,{NobleKey:()=>c});module.exports=l(S);var s=require("@noble/ciphers/aes"),a=require("@noble/ciphers/webcrypto"),i=require("../../crypto/CryptoService"),o=require("../../crypto/Key");class c{constructor(r){this.key=r}static async generate(r=i.EncryptionAlgo.AES256_GCM){if(r!==i.EncryptionAlgo.AES256_GCM)throw new Error(`Unsupported encryption algorithm ${r}`);return new c((0,a.randomBytes)(o.AES256_KEY_SIZE))}static from(r,t=i.EncryptionAlgo.AES256_GCM){if(t!==i.EncryptionAlgo.AES256_GCM)throw new Error(`Unsupported encryption algorithm ${t}`);return new c(r)}async encrypt(r,t){return(0,s.gcm)(this.key,r.slice(0,o.AES256_BLOCK_SIZE)).encrypt(t)}async decrypt(r,t){return(0,s.gcm)(this.key,r.slice(0,o.AES256_BLOCK_SIZE)).decrypt(t)}}0&&(module.exports={NobleKey});
-//# sourceMappingURL=NobleKey.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,cAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAoB,8BACpBC,EAA4B,oCAE5BC,EAA+B,qCAC/BC,EAA6D,2BAEtD,MAAML,CAAwB,CAoB3B,YAAoBM,EAAiB,CAAjB,SAAAA,CAAkB,CAnB9C,aAAa,SACXC,EAAuB,iBAAe,WACnB,CACnB,GAAIA,IAAS,iBAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCA,CAAI,EAAE,EAE5D,OAAO,IAAIP,KAAS,eAAY,iBAAe,CAAC,CAClD,CAEA,OAAO,KACLQ,EACAD,EAAuB,iBAAe,WAC5B,CACV,GAAIA,IAAS,iBAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCA,CAAI,EAAE,EAE5D,OAAO,IAAIP,EAASQ,CAAW,CACjC,CAIA,MAAM,QAAQC,EAAgBC,EAAuC,CAEnE,SADe,OAAI,KAAK,IAAKD,EAAG,MAAM,EAAG,mBAAiB,CAAC,EAC7C,QAAQC,CAAI,CAC5B,CAEA,MAAM,QACJD,EACAE,EACqB,CAErB,SADe,OAAI,KAAK,IAAKF,EAAG,MAAM,EAAG,mBAAiB,CAAC,EAC7C,QAAQE,CAAa,CACrC,CACF",
-  "names": ["NobleKey_exports", "__export", "NobleKey", "__toCommonJS", "import_aes", "import_webcrypto", "import_CryptoService", "import_Key", "key", "algo", "keyMaterial", "iv", "data", "encryptedData"]
-}

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

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

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

@@ -1,7 +0,0 @@
-{
-  "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,IAAAA,EAAmD,2BAEnDC,EAAyB,sBAEzB,SAAS,WAAY,IAAM,CACzB,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,4CAA6C,SAAY,CAC1D,MAAMC,EAAM,MAAM,WAAS,SAAS,EAC9BC,EAAK,IAAI,WAAW,mBAAiB,EAAE,KAAK,CAAI,EAChDC,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,WAAW,iBAAe,EAAE,KAAK,CAAI,EACvDJ,EAAM,WAAS,KAAKI,CAAW,EAC/BH,EAAK,IAAI,WAAW,mBAAiB,EAAE,KAAK,CAAI,EAChDC,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": ["import_Key", "import_NobleKey", "testData", "key", "iv", "encryptedData", "decryptedData", "keyMaterial"]
-}

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

@@ -1,2 +0,0 @@
-"use strict";var s=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var l=(a,r)=>{for(var e in r)s(a,e,{get:r[e],enumerable:!0})},K=(a,r,e,t)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of m(r))!g.call(a,i)&&i!==e&&s(a,i,{get:()=>r[i],enumerable:!(t=v(r,i))||t.enumerable});return a};var f=a=>K(s({},"__esModule",{value:!0}),a);var b={};l(b,{NobleKeyPair:()=>n});module.exports=f(b);var c=require("@ledgerhq/device-management-kit"),y=require("@noble/curves/nist.js"),p=require("@noble/curves/secp256k1.js"),u=require("../../crypto/CryptoService"),o=require("../../crypto/KeyPair");class n{constructor(r,e,t){this.curve=r;this.privateKey=e;this.publicKey=t}static async generate(r){const e=n.getCurve(r),{secretKey:t,publicKey:i}=e.keygen();return new n(e,t,i)}static from(r,e){const t=n.getCurve(e),i=t.getPublicKey(r);return new n(t,r,i)}static getCurve(r){switch(r){case u.Curve.K256:return p.secp256k1;case u.Curve.P256:return y.p256;default:throw new Error(`Unsupported curve ${r}`)}}get id(){return(0,c.bufferToHexaString)(this.privateKey)}async sign(r,e){return this.curve.sign(r,this.privateKey).toBytes(e===o.SigFormat.DER?"der":"compact")}async verify(r,e,t){return this.curve.verify(e,r,this.publicKey,{format:t===o.SigFormat.DER?"der":"compact"})}async deriveSharedSecret(r,e=!0){return this.curve.getSharedSecret(this.privateKey,r,e)}getPublicKey(){return this.publicKey}getPublicKeyToHex(){return(0,c.bufferToHexaString)(this.publicKey,!1)}}0&&(module.exports={NobleKeyPair});
-//# sourceMappingURL=NobleKeyPair.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,2CAEnCC,EAAqB,iCACrBC,EAA0B,sCAE1BC,EAAsB,qCACtBC,EAAwC,+BAEjC,MAAMN,CAAgC,CAwBnC,YACEO,EACAC,EACAC,EACR,CAHQ,WAAAF,EACA,gBAAAC,EACA,eAAAC,CACP,CA3BH,aAAa,SAASF,EAAqC,CACzD,MAAMG,EAAYV,EAAa,SAASO,CAAK,EACvC,CAAE,UAAAI,EAAW,UAAAF,CAAU,EAAIC,EAAU,OAAO,EAClD,OAAO,IAAIV,EAAaU,EAAWC,EAAWF,CAAS,CACzD,CAEA,OAAO,KAAKD,EAAwBD,EAA4B,CAC9D,MAAMG,EAAYV,EAAa,SAASO,CAAK,EACvCE,EAAYC,EAAU,aAAaF,CAAU,EACnD,OAAO,IAAIR,EAAaU,EAAWF,EAAYC,CAAS,CAC1D,CAEA,OAAe,SAASF,EAAuB,CAC7C,OAAQA,EAAO,CACb,KAAK,QAAM,KACT,OAAO,YACT,KAAK,QAAM,KACT,OAAO,OACT,QACE,MAAM,IAAI,MAAM,qBAAqBA,CAAK,EAAE,CAChD,CACF,CAQA,IAAI,IAAK,CACP,SAAO,sBAAmB,KAAK,UAAU,CAC3C,CAEA,MAAM,KAAKK,EAAkBC,EAAyC,CACpE,OAAO,KAAK,MACT,KAAKD,EAAM,KAAK,UAAU,EAC1B,QAAQC,IAAW,YAAU,IAAM,MAAQ,SAAS,CACzD,CAEA,MAAM,OACJD,EACAE,EACAD,EACkB,CAClB,OAAO,KAAK,MAAM,OAAOC,EAAWF,EAAM,KAAK,UAAW,CACxD,OAAQC,IAAW,YAAU,IAAM,MAAQ,SAC7C,CAAC,CACH,CAEA,MAAM,mBACJE,EACAC,EAAwB,GACH,CACrB,OAAO,KAAK,MAAM,gBAChB,KAAK,WACLD,EACAC,CACF,CACF,CAEA,cAA2B,CACzB,OAAO,KAAK,SACd,CAEA,mBAA4B,CAC1B,SAAO,sBAAmB,KAAK,UAAW,EAAK,CACjD,CACF",
-  "names": ["NobleKeyPair_exports", "__export", "NobleKeyPair", "__toCommonJS", "import_device_management_kit", "import_nist", "import_secp256k1", "import_CryptoService", "import_KeyPair", "curve", "privateKey", "publicKey", "curveImpl", "secretKey", "data", "format", "signature", "peerPublicKey", "isCompressed"]
-}

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

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

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

@@ -1,7 +0,0 @@
-{
-  "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,IAAAA,EAAsB,qCACtBC,EAA0B,+BAE1BC,EAA6B,0BAE7B,SAAS,eAAgB,IAAM,CAC7B,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,qDAAsD,SAAY,CAEnE,MAAMC,GADU,MAAM,eAAa,SAAS,QAAM,IAAI,GAC5B,aAAa,EACvC,OAAOA,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,EAAU,eAAa,KAAKD,EAAY,QAAM,IAAI,EACxD,OAAOC,EAAQ,aAAa,CAAC,EAAE,YAAY,CAC7C,CAAC,EAED,GAAG,wCAAyC,SAAY,CACtD,MAAMA,EAAU,MAAM,eAAa,SAAS,QAAM,IAAI,EAChDC,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,MAAM,eAAa,SAAS,QAAM,IAAI,EAChDC,EAAY,MAAMD,EAAQ,KAAKH,EAAU,YAAU,GAAG,EACtDK,EAAa,MAAMF,EAAQ,OAAOH,EAAUI,EAAW,YAAU,GAAG,EAC1E,OAAOC,CAAU,EAAE,WAAW,CAChC,CAAC,EAED,GAAG,wDAAyD,SAAY,CACtE,MAAMF,EAAU,MAAM,eAAa,SAAS,QAAM,IAAI,EAChDG,EAAe,MAAM,eAAa,SAAS,QAAM,IAAI,EACrDC,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,MAAM,eAAa,SAAS,QAAM,IAAI,GACzB,kBAAkB,EAC/C,OAAO,OAAOA,CAAY,EAAE,KAAK,QAAQ,EACzC,OAAOA,EAAa,MAAM,EAAE,gBAAgB,CAAC,CAC/C,CAAC,CACH,CAAC",
-  "names": ["import_CryptoService", "import_KeyPair", "import_NobleKeyPair", "testData", "publicKey", "privateKey", "keyPair", "signature", "isVerified", "otherKeyPair", "sharedSecret1", "sharedSecret2", "hexPublicKey"]
-}

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

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

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/api/model/Env.ts"],
-  "sourcesContent": ["export enum LKRPEnv {\n  PROD = \"prod\",\n  STAGING = \"staging\",\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,aAAAE,IAAA,eAAAC,EAAAH,GAAO,IAAKE,OACVA,EAAA,KAAO,OACPA,EAAA,QAAU,UAFAA,OAAA",
-  "names": ["Env_exports", "__export", "LKRPEnv", "__toCommonJS"]
-}

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

@@ -1,2 +0,0 @@
-"use strict";var a=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var c=(o,e)=>{for(var r in e)a(o,r,{get:e[r],enumerable:!0})},g=(o,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of i(e))!u.call(o,t)&&t!==r&&a(o,t,{get:()=>e[t],enumerable:!(n=d(e,t))||n.enumerable});return o};var l=o=>g(a({},"__esModule",{value:!0}),o);var R={};c(R,{LKRPDataSourceError:()=>y,LKRPMissingDataError:()=>P,LKRPOutdatedTrustchainError:()=>E,LKRPParsingError:()=>K,LKRPTrustchainNotReady:()=>L,LKRPUnauthorizedError:()=>p,LKRPUnknownError:()=>m,LKRPUnsupportedCommandError:()=>x});module.exports=l(R);var s=require("@ledgerhq/device-management-kit");class y extends s.GeneralDmkError{constructor(r){super(r.message);this.err=r;this.status=r.status,this.message=r.message}_tag="LedgerKeyringProtocolError";message;status}class p extends s.GeneralDmkError{constructor(r=null,n=`Current keypair is not a member of the trustchain${r?` ${r}`:""}.`){super(n);this.trustchainId=r;this.message=n}_tag="LedgerKeyringProtocolError"}class E extends s.GeneralDmkError{constructor(r="The trustchain is outdated."){super(r);this.message=r}_tag="LedgerKeyringProtocolError"}class L extends s.GeneralDmkError{constructor(r="Ledger Sync must be initialized from Ledger Live with this device."){super(r);this.message=r}_tag="LedgerKeyringProtocolError"}class K extends s.GeneralDmkError{constructor(r){super(r);this.err=r}_tag="LedgerKeyringProtocolError"}class P extends s.GeneralDmkError{constructor(r){super(r);this.err=r}_tag="LedgerKeyringProtocolError"}class x extends s.GeneralDmkError{constructor(r){const n=r&&typeof r=="object"&&"type"in r&&typeof r.type=="number"&&`0x${r.type.toString(16).padStart(2,"0")}`;let t="Unsupported command";n&&(t+=`: ${n}`);super(t);this.command=r;this.message=t}_tag="LedgerKeyringProtocolError";message}class m extends s.GeneralDmkError{constructor(r){super(r);this.message=r}_tag="LedgerKeyringProtocolError"}0&&(module.exports={LKRPDataSourceError,LKRPMissingDataError,LKRPOutdatedTrustchainError,LKRPParsingError,LKRPTrustchainNotReady,LKRPUnauthorizedError,LKRPUnknownError,LKRPUnsupportedCommandError});
-//# sourceMappingURL=Errors.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,EAAA,yBAAAC,EAAA,gCAAAC,EAAA,qBAAAC,EAAA,2BAAAC,EAAA,0BAAAC,EAAA,qBAAAC,EAAA,gCAAAC,IAAA,eAAAC,EAAAV,GAAA,IAAAW,EAAgC,2CAOzB,MAAMT,UAA4B,iBAAgB,CAKvD,YACWU,EAIT,CACA,MAAMA,EAAI,OAAO,EALR,SAAAA,EAMT,KAAK,OAASA,EAAI,OAClB,KAAK,QAAUA,EAAI,OACrB,CAbS,KAAO,6BACA,QACA,MAYlB,CAEO,MAAML,UAA8B,iBAAgB,CAEzD,YACWM,EAA8B,KAC9BC,EAAkB,oDAAoDD,EAAe,IAAIA,CAAY,GAAK,EAAE,IACrH,CACA,MAAMC,CAAO,EAHJ,kBAAAD,EACA,aAAAC,CAGX,CANS,KAAO,4BAOlB,CAEO,MAAMV,UAAoC,iBAAgB,CAE/D,YAAqBU,EAAU,8BAA+B,CAC5D,MAAMA,CAAO,EADM,aAAAA,CAErB,CAHS,KAAO,4BAIlB,CAEO,MAAMR,UAA+B,iBAAgB,CAE1D,YACWQ,EAAU,qEACnB,CACA,MAAMA,CAAO,EAFJ,aAAAA,CAGX,CALkB,KAAO,4BAM3B,CAEO,MAAMT,UAAyB,iBAAgB,CAEpD,YAAqBO,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMT,UAA6B,iBAAgB,CAExD,YAAqBS,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMH,UAAoC,iBAAgB,CAG/D,YAAqBM,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,IAAID,EAAU,sBACVE,IAAaF,GAAW,KAAKE,CAAW,IAE5C,MAAMF,CAAO,EAVM,aAAAC,EAYnB,KAAK,QAAUD,CACjB,CAfkB,KAAO,6BAChB,OAeX,CAEO,MAAMN,UAAyB,iBAAgB,CAEpD,YAAqBM,EAAiB,CACpC,MAAMA,CAAO,EADM,aAAAA,CAErB,CAHkB,KAAO,4BAI3B",
-  "names": ["Errors_exports", "__export", "LKRPDataSourceError", "LKRPMissingDataError", "LKRPOutdatedTrustchainError", "LKRPParsingError", "LKRPTrustchainNotReady", "LKRPUnauthorizedError", "LKRPUnknownError", "LKRPUnsupportedCommandError", "__toCommonJS", "import_device_management_kit", "err", "trustchainId", "message", "command", "commandType"]
-}

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

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

package/lib/cjs/api/model/JWT.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/api/model/JWT.ts"],
-  "sourcesContent": ["export type JWT = {\n  access_token: string;\n  permissions: {\n    [trustchainId: string]: {\n      [path: string]: string[];\n    };\n  };\n};\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["JWT_exports", "__toCommonJS"]
-}

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

@@ -1,2 +0,0 @@
-"use strict";var E=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var O=Object.prototype.hasOwnProperty;var p=(N,C)=>{for(var A in C)E(N,A,{get:C[A],enumerable:!0})},t=(N,C,A,_)=>{if(C&&typeof C=="object"||typeof C=="function")for(let f of x(C))!O.call(N,f)&&f!==A&&E(N,f,{get:()=>C[f],enumerable:!(_=R(C,f))||_.enumerable});return N};var u=N=>t(E({},"__esModule",{value:!0}),N);var B={};p(B,{Permissions:()=>D});module.exports=u(B);var D=(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))(D||{});0&&(module.exports={Permissions});
-//# sourceMappingURL=Permissions.js.map

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

@@ -1,7 +0,0 @@
-{
-  "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": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,iBAAAE,IAAA,eAAAC,EAAAH,GAGO,IAAKE,OACVA,IAAA,MAAQ,YAAR,QACAA,IAAA,YAAc,GAAd,cACAA,IAAA,WAAa,GAAb,aACAA,IAAA,cAAgB,GAAhB,gBAJUA,OAAA",
-  "names": ["Permissions_exports", "__export", "Permissions", "__toCommonJS"]
-}

package/lib/cjs/internal/app-binder/device-action/AuthenticateWithDeviceDeviceAction.js

@@ -1,2 +0,0 @@
-"use strict";var D=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var k=(s,i)=>{for(var o in i)D(s,o,{get:i[o],enumerable:!0})},M=(s,i,o,y)=>{if(i&&typeof i=="object"||typeof i=="function")for(let r of I(i))!f.call(s,r)&&r!==o&&D(s,r,{get:()=>i[r],enumerable:!(y=v(i,r))||y.enumerable});return s};var w=s=>M(D({},"__esModule",{value:!0}),s);var W={};k(W,{AuthenticateWithDeviceDeviceAction:()=>K});module.exports=w(W);var u=require("@ledgerhq/device-management-kit"),c=require("purify-ts"),n=require("xstate"),A=require("../../../api/app-binder/AuthenticateDeviceActionTypes"),m=require("../../../api/model/Errors"),E=require("../../app-binder/task/AuthenticateTask"),S=require("../../app-binder/task/ExtractEncryptionKeyTask"),T=require("../../app-binder/task/SignChallengeWithDeviceTask"),d=require("../../utils/eitherSeqRecord"),a=require("../../utils/required"),h=require("./utils/raiseAndAssign"),g=require("./AddToTrustchainDeviceAction");const l="Ledger Sync";class K extends u.XStateDeviceAction{makeStateMachine(i){const{deviceAuth:o,getTrustchain:y,extractEncryptionKey:r}=this.extractDependencies(i);return(0,n.setup)({types:{input:{},context:{},output:{}},actors:{openAppStateMachine:new u.OpenAppDeviceAction({input:{appName:l}}).makeStateMachine(i),deviceAuth:(0,n.fromPromise)(o),getTrustchain:(0,n.fromPromise)(y),addToTrustchainStateMachine:new g.AddToTrustchainDeviceAction({input:(0,c.Left)(new m.LKRPMissingDataError("Missing input for GetEncryptionKey"))}).makeStateMachine(i),extractEncryptionKey:(0,n.fromPromise)(r)},actions:{assignErrorFromEvent:(0,h.raiseAndAssign)(({event:t})=>(0,c.Left)(new m.LKRPUnknownError(String(t.error))))},guards:{isTrustchainMember:({context:t})=>t._internalState.toMaybe().map(e=>e.wasAddedToTrustchain||e.trustchain?.getAppStream(t.input.appId).mapOrDefault(p=>p.hasMember(t.input.keypair.getPublicKeyToHex()),!1)).extract()??!1}}).createMachine({id:"AuthenticateWithDeviceDeviceAction",context:({input:t})=>({input:t,intermediateValue:{requiredUserInteraction:u.UserInteractionRequired.None},_internalState:(0,c.Right)({trustchainId:null,jwt:null,trustchain:null,encryptionKey:null,wasAddedToTrustchain:!1})}),initial:"OpenApp",states:{OpenApp:{on:{success:"DeviceAuth",error:"Error"},invoke:{id:"openApp",src:"openAppStateMachine",onSnapshot:{actions:(0,n.assign)({intermediateValue:({event:t})=>({step:A.AuthenticateDAStep.OpenApp,...t.snapshot.context.intermediateValue})})},input:{appName:l},onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,h.raiseAndAssign)(({event:t})=>t.output.map(()=>({raise:"success"})))}}},DeviceAuth:{entry:(0,n.assign)({intermediateValue:{step:A.AuthenticateDAStep.Authenticate,requiredUserInteraction:A.AuthenticateDAState.Authenticate}}),on:{success:"GetTrustchain",error:"Error"},invoke:{id:"deviceAuth",src:"deviceAuth",input:({context:t})=>t.input,onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,h.raiseAndAssign)(({event:t})=>t.output.chain(e=>e.trustchainId.caseOf({Nothing:()=>(0,c.Left)(new m.LKRPTrustchainNotReady),Just:p=>(0,c.Right)({raise:"success",assign:{jwt:e.jwt,trustchainId:p}})})))}}},GetTrustchain:{entry:(0,n.assign)({intermediateValue:{step:A.AuthenticateDAStep.GetTrustchain,requiredUserInteraction:u.UserInteractionRequired.None}}),on:{success:"CheckIsMembers",error:"Error"},invoke:{id:"getTrustchain",src:"getTrustchain",input:({context:t})=>t._internalState.chain(e=>(0,d.eitherSeqRecord)({lkrpDataSource:t.input.lkrpDataSource,trustchainId:()=>(0,a.required)(e.trustchainId,"Missing Trustchain ID for GetTrustchain"),jwt:()=>(0,a.required)(e.jwt,"Missing JWT for GetTrustchain")})),onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,h.raiseAndAssign)(({event:t})=>t.output.map(e=>({raise:"success",assign:{trustchain:e}})))}}},CheckIsMembers:{always:[{target:"ExtractEncryptionKey",guard:"isTrustchainMember"},{target:"AddToTrustchain"}]},AddToTrustchain:{on:{success:"GetTrustchain",error:"Error"},invoke:{id:"AddToTrustchain",src:"addToTrustchainStateMachine",onSnapshot:{actions:(0,n.assign)({intermediateValue:({event:t})=>t.snapshot.context.intermediateValue})},input:({context:t})=>t._internalState.mapLeft(()=>new m.LKRPMissingDataError("Missing data in the input for AddToTrustchain")).chain(e=>(0,d.eitherSeqRecord)({lkrpDataSource:t.input.lkrpDataSource,cryptoService:t.input.cryptoService,keypair:t.input.keypair,clientName:t.input.clientName,permissions:t.input.permissions,jwt:()=>(0,a.required)(e.jwt,"Missing JWT for AddToTrustchain"),appId:t.input.appId,trustchain:()=>(0,a.required)(e.trustchain,"Missing Trustchain for AddToTrustchain")})),onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,h.raiseAndAssign)(({event:t})=>t.output.map(()=>({raise:"success",assign:{wasAddedToTrustchain:!0}})))}}},ExtractEncryptionKey:{entry:(0,n.assign)({intermediateValue:{step:A.AuthenticateDAStep.ExtractEncryptionKey,requiredUserInteraction:u.UserInteractionRequired.None}}),on:{success:"Success",error:"Error"},invoke:{id:"ExtractEncryptionKey",src:"extractEncryptionKey",input:({context:t})=>({cryptoService:t.input.cryptoService,keypair:t.input.keypair,stream:t._internalState.chain(({trustchain:e})=>(0,a.required)(e?.getAppStream(t.input.appId).extract(),"Missing application stream for ExtractEncryptionKey"))}),onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,h.raiseAndAssign)(({event:t})=>t.output.map(e=>({raise:"success",assign:{encryptionKey:e}})))}}},Success:{type:"final"},Error:{type:"final"}},output:({context:t})=>t._internalState.chain(e=>(0,d.eitherSeqRecord)({trustchainId:()=>(0,a.required)(e.trustchainId,"Missing Trustchain ID in the output"),jwt:()=>(0,a.required)(e.jwt,"Missing JWT in the output"),applicationPath:()=>(0,a.required)(e.trustchain?.getAppStream(t.input.appId).chain(p=>p.getPath()).extract(),"Missing application path in the output"),encryptionKey:()=>(0,a.required)(e.encryptionKey,"Missing encryption key in the output")}))})}extractDependencies(i){const o=new E.AuthenticateTask,y=new S.ExtractEncryptionKeyTask;return{deviceAuth:({input:r})=>o.run(r.lkrpDataSource,new T.SignChallengeWithDeviceTask(i)),getTrustchain:r=>c.EitherAsync.liftEither(r.input).chain(({lkrpDataSource:t,trustchainId:e,jwt:p})=>t.getTrustchainById(e,p)).run(),extractEncryptionKey:async({input:r})=>c.EitherAsync.liftEither(r.stream).chain(t=>y.run(r.cryptoService,r.keypair,t))}}}0&&(module.exports={AuthenticateWithDeviceDeviceAction});
-//# sourceMappingURL=AuthenticateWithDeviceDeviceAction.js.map

package/lib/cjs/internal/app-binder/device-action/AuthenticateWithDeviceDeviceAction.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/internal/app-binder/device-action/AuthenticateWithDeviceDeviceAction.ts"],
-  "sourcesContent": ["import {\n  type DeviceActionStateMachine,\n  type InternalApi,\n  OpenAppDeviceAction,\n  type StateMachineTypes,\n  UserInteractionRequired,\n  XStateDeviceAction,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either, EitherAsync, Left, Right } from \"purify-ts\";\nimport { assign, fromPromise, setup } from \"xstate\";\n\nimport {\n  type AuthenticateDAError,\n  type AuthenticateDAIntermediateValue,\n  type AuthenticateDAOutput,\n  AuthenticateDAState,\n  AuthenticateDAStep,\n} from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport {\n  LKRPMissingDataError,\n  LKRPTrustchainNotReady,\n  LKRPUnknownError,\n} from \"@api/model/Errors\";\nimport { type JWT } from \"@api/model/JWT\";\nimport { AuthenticateTask } from \"@internal/app-binder/task/AuthenticateTask\";\nimport { ExtractEncryptionKeyTask } from \"@internal/app-binder/task/ExtractEncryptionKeyTask\";\nimport { SignChallengeWithDeviceTask } from \"@internal/app-binder/task/SignChallengeWithDeviceTask\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\nimport { type LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\nimport { required } from \"@internal/utils/required\";\n\nimport {\n  type AuthenticateWithDeviceDAInput,\n  type AuthenticateWithDeviceDAInternalState,\n} from \"./models/AuthenticateWithDeviceDeviceActionTypes\";\nimport { raiseAndAssign } from \"./utils/raiseAndAssign\";\nimport { AddToTrustchainDeviceAction } from \"./AddToTrustchainDeviceAction\";\n\nconst APP_NAME = \"Ledger Sync\";\n\nexport class AuthenticateWithDeviceDeviceAction extends XStateDeviceAction<\n  AuthenticateDAOutput,\n  AuthenticateWithDeviceDAInput,\n  AuthenticateDAError,\n  AuthenticateDAIntermediateValue,\n  AuthenticateWithDeviceDAInternalState\n> {\n  makeStateMachine(\n    internalApi: InternalApi,\n  ): DeviceActionStateMachine<\n    AuthenticateDAOutput,\n    AuthenticateWithDeviceDAInput,\n    AuthenticateDAError,\n    AuthenticateDAIntermediateValue,\n    AuthenticateWithDeviceDAInternalState\n  > {\n    type types = StateMachineTypes<\n      AuthenticateDAOutput,\n      AuthenticateWithDeviceDAInput,\n      AuthenticateDAError,\n      AuthenticateDAIntermediateValue,\n      AuthenticateWithDeviceDAInternalState\n    >;\n\n    const { deviceAuth, getTrustchain, extractEncryptionKey } =\n      this.extractDependencies(internalApi);\n\n    return setup({\n      types: {\n        input: {} as types[\"input\"],\n        context: {} as types[\"context\"],\n        output: {} as types[\"output\"],\n      },\n\n      actors: {\n        openAppStateMachine: new OpenAppDeviceAction({\n          input: { appName: APP_NAME },\n        }).makeStateMachine(internalApi),\n\n        deviceAuth: fromPromise(deviceAuth),\n\n        getTrustchain: fromPromise(getTrustchain),\n\n        addToTrustchainStateMachine: new AddToTrustchainDeviceAction({\n          input: Left(\n            new LKRPMissingDataError(\"Missing input for GetEncryptionKey\"),\n          ),\n        }).makeStateMachine(internalApi),\n\n        extractEncryptionKey: fromPromise(extractEncryptionKey),\n      },\n\n      actions: {\n        assignErrorFromEvent: raiseAndAssign(\n          ({ event }) =>\n            Left(\n              new LKRPUnknownError(\n                String((event as { error?: unknown }).error),\n              ),\n            ), // NOTE: it should never happen, the error is not typed anymore here\n        ),\n      },\n\n      guards: {\n        isTrustchainMember: ({ context }) =>\n          context._internalState\n            .toMaybe()\n            .map(\n              (state) =>\n                state.wasAddedToTrustchain ||\n                state.trustchain\n                  ?.getAppStream(context.input.appId)\n                  .mapOrDefault(\n                    (stream) =>\n                      stream.hasMember(\n                        context.input.keypair.getPublicKeyToHex(),\n                      ),\n                    false,\n                  ),\n            )\n            .extract() ?? false,\n      },\n    }).createMachine({\n      /** @xstate-layout N4IgpgJg5mDOIC5QEECuAXAFmAduglgMYCG6YA6vlgCJgBuRYtDhYyhBA9jgHQDyAB1zIBAgMQRuYHvhx1OAa2mchOEQIDaABgC6iUAM6wq+bvpAAPRAEYAzADYeATgAcAFltuntrdYBMAfYANCAAnogA7G6OttYREU5aWgERyQC+aSFoWLgEJGSUNPSMzIzsXLyCwqJiYABOdZx1PAIANqQAZk0Atjwq1Zq65obGFeZWCNbWAKw80-Z+Xvb2ni5OEdPWIeEI9tN+PC720RtuyU52GVkY2HhEpBRUmKWsL2wcppWq6mKwqISsWCwbR6JAgEYmMxgia2FwRHhaCIuaxaLz7ZbTLTBMKIFwuA7JLTePwJVxRCJXEDZW55B6FZ7FV6M94VfjfGr1Rp1EHDIyQnDjRAOA7WPGYiLHaxOab47Y2GVaHheOKiiVOAIBSnU3L3ApPN5vcqfHiGm4SKQyOSKaQQZnUnlgiFjaGIeZuQ62Py+PxSrQucVyhASxyuNzRRKI3wrLU3HX5R5FFhMO0fbgmu1mzlNFrtdBdOq9W1J+1DR1852gCbTTE8WyuWFReyIhJbHG7CK2OaxPx4tz+bzTGM5O7x+kGlOs01YX7-QHA0sGcufQVB7w8FYk6XS6YRaxuaaB9WKwlraJe+z4txDmm6hMMpOG1O8KeYWoNJoOxejZcuoMJBH2FEdbVlM+5uIGMyxOuixaJi0wOLY0xXpkVKxiOdL6syj6sgA4mA6AACp1KgsDoIQmDELI5o4NIsjyEoPAwIRxGkeRlE4J+4JLlClaIOsLg8I2sE+CqTYuIGLios47jRLCe7rL415xhhiYlBOxp4cxJFkRRVFZs0bSdD0jH4UR2lsbInFOj+vEIOs1jrru+IbBcWJrIGu4OfBdjKtKorWEp6F6qpTLFk+PCaWZrG6TgM4AnA86gl+-Irv4YbQWiGpNmSh4XnMCz7P5vhgYFtLBfealhbhpksTp7FvlyVncQKv5TPiCKwU2iKLIkfgQW4ErOOSThhiiixuC4pW3mOWHqWmADC2CEAoACSsAALJgN0ABG9SwGITXfjxljyhNzj7n48G2J6+J+oe8Q8AE6r7vYTgFR2U2jphD5zbwi1gMta2bTte0HdYSVcUdLW2TMSKCZ4N3TL1SHYjs-h4jwUqgXWCwUih2pBXe45VcayAQBABGcFFdVUZINGWvR0hkxTVO1RZHELpDKWtUcswokhiIyv5tgQV6IoXlEqL+j6TifSpFWhWU4XM5T1Psw12aGXmxkq6z5kxYd3Mw7zgkdnWEQ9k4VthhBUyKvYe62Kk5w+D2cvlcTSusrrasxXFc6GxWJ0ID6r3OH4iFhscZywf1UpKgs1gO2sF51u7ROzSTaY+2zfv6YHNnB6H8KIcS6oW69cIQddnaJ5JhLddG+NoWVGc-VnvAAKIWOgdTEBwnc4IQdShAIFQANJgKE1G0VaDHd73-foIPw+jxPU8F8dEyijW7gSqinhaA44Ftv6tdEk7l37DuH3N8Orcze3XvGgvfcD0PI9j58k-T-pOZGQWHgr8l4r0-uvUIm9obBx3l5GY8wUQOzrNKDyTZMbwIuNKdwb106P0qs-NMwD36ry-twH+-sEqQJXKHJw4dI7RDDEkfY913TrHVDKDwCwr44O+ng1gRoCE9zfsvD+a9v5Tw1tyTm1kt6IGLrWJGnpy5+Ern1NsKIzjriOHvJGfZ1QZBQjgTgtp4BggJg-Hhis+FPl5FDFcABaVsOx5izGPhbUayJYiDjvjeL6IVkwdzZAMGxRtg4DQkuleIRJUTHB6kSbhfjsLGhfMEoOVYUSYxVPMBYPhOoST2EqJ2MphQXlgn4eJCt-H4N4JFXO7EUmFwmBcRwgFRQDQWE2ECh4j4FI2EiDwA0kYBW8cpD2mcqk8H+oDDaW1dp1BMclVJNgHDwmWDHWEb0PDqlyjQrEV8BrrD8E08pnsrHe3JqrWpsh6kyMmPEBypdrpiVcHsauSRoJxDWHYREMxJrDMJrgyxLIX6CJASIkhOAf7XKgdvO58jvAOD9M8g8bZpQEgKt5aIex-THLGac40ABlWcCUoVUNiJ2RYGx5gBD7E2CI91OwW2eohAI1YJo4qfnigh746gkt-AESSj1E5JAri4bs1dPS1l3EifYcJYI7n0WkIAA */\n\n      id: \"AuthenticateWithDeviceDeviceAction\",\n      context: ({ input }): types[\"context\"] => ({\n        input,\n        intermediateValue: {\n          requiredUserInteraction: UserInteractionRequired.None,\n        },\n        _internalState: Right({\n          trustchainId: null,\n          jwt: null,\n          trustchain: null,\n          encryptionKey: null,\n          wasAddedToTrustchain: false,\n        }),\n      }),\n\n      initial: \"OpenApp\",\n      states: {\n        OpenApp: {\n          on: { success: \"DeviceAuth\", error: \"Error\" },\n          invoke: {\n            id: \"openApp\",\n            src: \"openAppStateMachine\",\n            onSnapshot: {\n              actions: assign({\n                intermediateValue: ({ event }) => ({\n                  step: AuthenticateDAStep.OpenApp,\n                  ...event.snapshot.context.intermediateValue,\n                }),\n              }),\n            },\n            input: { appName: APP_NAME },\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.map(() => ({ raise: \"success\" })),\n              ),\n            },\n          },\n        },\n\n        DeviceAuth: {\n          entry: assign({\n            intermediateValue: {\n              step: AuthenticateDAStep.Authenticate,\n              requiredUserInteraction: AuthenticateDAState.Authenticate,\n            },\n          }),\n          on: { success: \"GetTrustchain\", error: \"Error\" },\n          invoke: {\n            id: \"deviceAuth\",\n            src: \"deviceAuth\",\n            input: ({ context }) => context.input,\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.chain((payload) =>\n                  payload.trustchainId.caseOf({\n                    Nothing: () => Left(new LKRPTrustchainNotReady()),\n                    Just: (trustchainId) =>\n                      Right({\n                        raise: \"success\",\n                        assign: { jwt: payload.jwt, trustchainId },\n                      }),\n                  }),\n                ),\n              ),\n            },\n          },\n        },\n\n        GetTrustchain: {\n          entry: assign({\n            intermediateValue: {\n              step: AuthenticateDAStep.GetTrustchain,\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          on: { success: \"CheckIsMembers\", error: \"Error\" },\n          invoke: {\n            id: \"getTrustchain\",\n            src: \"getTrustchain\",\n            input: ({ context }) =>\n              context._internalState.chain((state) =>\n                eitherSeqRecord({\n                  lkrpDataSource: context.input.lkrpDataSource,\n                  trustchainId: () =>\n                    required(\n                      state.trustchainId,\n                      \"Missing Trustchain ID for GetTrustchain\",\n                    ),\n                  jwt: () =>\n                    required(state.jwt, \"Missing JWT for GetTrustchain\"),\n                }),\n              ),\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.map((trustchain) => ({\n                  raise: \"success\",\n                  assign: { trustchain },\n                })),\n              ),\n            },\n          },\n        },\n\n        CheckIsMembers: {\n          always: [\n            { target: \"ExtractEncryptionKey\", guard: \"isTrustchainMember\" },\n            { target: \"AddToTrustchain\" },\n          ],\n        },\n\n        AddToTrustchain: {\n          on: {\n            success: \"GetTrustchain\",\n            error: \"Error\",\n          },\n          invoke: {\n            id: \"AddToTrustchain\",\n            src: \"addToTrustchainStateMachine\",\n            onSnapshot: {\n              actions: assign({\n                intermediateValue: ({ event }) =>\n                  event.snapshot.context.intermediateValue,\n              }),\n            },\n            input: ({ context }) =>\n              context._internalState\n                .mapLeft(\n                  () =>\n                    new LKRPMissingDataError(\n                      \"Missing data in the input for AddToTrustchain\",\n                    ),\n                )\n                .chain((state) =>\n                  eitherSeqRecord({\n                    lkrpDataSource: context.input.lkrpDataSource,\n                    cryptoService: context.input.cryptoService,\n                    keypair: context.input.keypair,\n                    clientName: context.input.clientName,\n                    permissions: context.input.permissions,\n                    jwt: () =>\n                      required(state.jwt, \"Missing JWT for AddToTrustchain\"),\n                    appId: context.input.appId,\n                    trustchain: () =>\n                      required(\n                        state.trustchain,\n                        \"Missing Trustchain for AddToTrustchain\",\n                      ),\n                  }),\n                ),\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.map(() => ({\n                  raise: \"success\",\n                  assign: { wasAddedToTrustchain: true },\n                })),\n              ),\n            },\n          },\n        },\n\n        ExtractEncryptionKey: {\n          entry: assign({\n            intermediateValue: {\n              step: AuthenticateDAStep.ExtractEncryptionKey,\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          on: { success: \"Success\", error: \"Error\" },\n          invoke: {\n            id: \"ExtractEncryptionKey\",\n            src: \"extractEncryptionKey\",\n            input: ({ context }) => ({\n              cryptoService: context.input.cryptoService,\n              keypair: context.input.keypair,\n              stream: context._internalState.chain(({ trustchain }) =>\n                required(\n                  trustchain?.getAppStream(context.input.appId).extract(),\n                  \"Missing application stream for ExtractEncryptionKey\",\n                ),\n              ),\n            }),\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.map((encryptionKey) => ({\n                  raise: \"success\",\n                  assign: { encryptionKey },\n                })),\n              ),\n            },\n          },\n        },\n\n        Success: { type: \"final\" },\n\n        Error: { type: \"final\" },\n      },\n\n      output: ({ context }) =>\n        context._internalState.chain((state) =>\n          eitherSeqRecord({\n            trustchainId: () =>\n              required(\n                state.trustchainId,\n                \"Missing Trustchain ID in the output\",\n              ),\n            jwt: () => required(state.jwt, \"Missing JWT in the output\"),\n            applicationPath: () =>\n              required(\n                state.trustchain\n                  ?.getAppStream(context.input.appId)\n                  .chain((stream) => stream.getPath())\n                  .extract(),\n                \"Missing application path in the output\",\n              ),\n            encryptionKey: () =>\n              required(\n                state.encryptionKey,\n                \"Missing encryption key in the output\",\n              ),\n          }),\n        ),\n    });\n  }\n\n  extractDependencies(internalApi: InternalApi) {\n    const authentication = new AuthenticateTask();\n    const encryptionKeyExtraction = new ExtractEncryptionKeyTask();\n\n    return {\n      deviceAuth: ({ input }: { input: AuthenticateWithDeviceDAInput }) =>\n        authentication.run(\n          input.lkrpDataSource,\n          new SignChallengeWithDeviceTask(internalApi),\n        ),\n\n      getTrustchain: (args: {\n        input: Either<\n          AuthenticateDAError,\n          {\n            lkrpDataSource: LKRPDataSource;\n            trustchainId: string;\n            jwt: JWT;\n          }\n        >;\n      }) =>\n        EitherAsync.liftEither(args.input)\n          .chain(({ lkrpDataSource, trustchainId, jwt }) =>\n            lkrpDataSource.getTrustchainById(trustchainId, jwt),\n          )\n          .run(),\n\n      extractEncryptionKey: async ({\n        input,\n      }: {\n        input: {\n          cryptoService: CryptoService;\n          keypair: KeyPair;\n          stream: Either<AuthenticateDAError, LKRPBlockStream>;\n        };\n      }) =>\n        EitherAsync.liftEither(input.stream).chain((stream) =>\n          encryptionKeyExtraction.run(\n            input.cryptoService,\n            input.keypair,\n            stream,\n          ),\n        ),\n    };\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAOO,2CACPC,EAAsD,qBACtDC,EAA2C,kBAE3CC,EAMO,yDAGPC,EAIO,6BAEPC,EAAiC,sDACjCC,EAAyC,8DACzCC,EAA4C,iEAE5CC,EAAgC,2CAEhCC,EAAyB,oCAMzBC,EAA+B,kCAC/BC,EAA4C,yCAE5C,MAAMC,EAAW,cAEV,MAAMd,UAA2C,oBAMtD,CACA,iBACEe,EAOA,CASA,KAAM,CAAE,WAAAC,EAAY,cAAAC,EAAe,qBAAAC,CAAqB,EACtD,KAAK,oBAAoBH,CAAW,EAEtC,SAAO,SAAM,CACX,MAAO,CACL,MAAO,CAAC,EACR,QAAS,CAAC,EACV,OAAQ,CAAC,CACX,EAEA,OAAQ,CACN,oBAAqB,IAAI,sBAAoB,CAC3C,MAAO,CAAE,QAASD,CAAS,CAC7B,CAAC,EAAE,iBAAiBC,CAAW,EAE/B,cAAY,eAAYC,CAAU,EAElC,iBAAe,eAAYC,CAAa,EAExC,4BAA6B,IAAI,8BAA4B,CAC3D,SAAO,QACL,IAAI,uBAAqB,oCAAoC,CAC/D,CACF,CAAC,EAAE,iBAAiBF,CAAW,EAE/B,wBAAsB,eAAYG,CAAoB,CACxD,EAEA,QAAS,CACP,wBAAsB,kBACpB,CAAC,CAAE,MAAAC,CAAM,OACP,QACE,IAAI,mBACF,OAAQA,EAA8B,KAAK,CAC7C,CACF,CACJ,CACF,EAEA,OAAQ,CACN,mBAAoB,CAAC,CAAE,QAAAC,CAAQ,IAC7BA,EAAQ,eACL,QAAQ,EACR,IACEC,GACCA,EAAM,sBACNA,EAAM,YACF,aAAaD,EAAQ,MAAM,KAAK,EACjC,aACEE,GACCA,EAAO,UACLF,EAAQ,MAAM,QAAQ,kBAAkB,CAC1C,EACF,EACF,CACN,EACC,QAAQ,GAAK,EACpB,CACF,CAAC,EAAE,cAAc,CAGf,GAAI,qCACJ,QAAS,CAAC,CAAE,MAAAG,CAAM,KAAyB,CACzC,MAAAA,EACA,kBAAmB,CACjB,wBAAyB,0BAAwB,IACnD,EACA,kBAAgB,SAAM,CACpB,aAAc,KACd,IAAK,KACL,WAAY,KACZ,cAAe,KACf,qBAAsB,EACxB,CAAC,CACH,GAEA,QAAS,UACT,OAAQ,CACN,QAAS,CACP,GAAI,CAAE,QAAS,aAAc,MAAO,OAAQ,EAC5C,OAAQ,CACN,GAAI,UACJ,IAAK,sBACL,WAAY,CACV,WAAS,UAAO,CACd,kBAAmB,CAAC,CAAE,MAAAJ,CAAM,KAAO,CACjC,KAAM,qBAAmB,QACzB,GAAGA,EAAM,SAAS,QAAQ,iBAC5B,EACF,CAAC,CACH,EACA,MAAO,CAAE,QAASL,CAAS,EAC3B,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAK,CAAM,IAC/BA,EAAM,OAAO,IAAI,KAAO,CAAE,MAAO,SAAU,EAAE,CAC/C,CACF,CACF,CACF,EAEA,WAAY,CACV,SAAO,UAAO,CACZ,kBAAmB,CACjB,KAAM,qBAAmB,aACzB,wBAAyB,sBAAoB,YAC/C,CACF,CAAC,EACD,GAAI,CAAE,QAAS,gBAAiB,MAAO,OAAQ,EAC/C,OAAQ,CACN,GAAI,aACJ,IAAK,aACL,MAAO,CAAC,CAAE,QAAAC,CAAQ,IAAMA,EAAQ,MAChC,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAD,CAAM,IAC/BA,EAAM,OAAO,MAAOK,GAClBA,EAAQ,aAAa,OAAO,CAC1B,QAAS,OAAM,QAAK,IAAI,wBAAwB,EAChD,KAAOC,MACL,SAAM,CACJ,MAAO,UACP,OAAQ,CAAE,IAAKD,EAAQ,IAAK,aAAAC,CAAa,CAC3C,CAAC,CACL,CAAC,CACH,CACF,CACF,CACF,CACF,EAEA,cAAe,CACb,SAAO,UAAO,CACZ,kBAAmB,CACjB,KAAM,qBAAmB,cACzB,wBAAyB,0BAAwB,IACnD,CACF,CAAC,EACD,GAAI,CAAE,QAAS,iBAAkB,MAAO,OAAQ,EAChD,OAAQ,CACN,GAAI,gBACJ,IAAK,gBACL,MAAO,CAAC,CAAE,QAAAL,CAAQ,IAChBA,EAAQ,eAAe,MAAOC,MAC5B,mBAAgB,CACd,eAAgBD,EAAQ,MAAM,eAC9B,aAAc,OACZ,YACEC,EAAM,aACN,yCACF,EACF,IAAK,OACH,YAASA,EAAM,IAAK,+BAA+B,CACvD,CAAC,CACH,EACF,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAF,CAAM,IAC/BA,EAAM,OAAO,IAAKO,IAAgB,CAChC,MAAO,UACP,OAAQ,CAAE,WAAAA,CAAW,CACvB,EAAE,CACJ,CACF,CACF,CACF,EAEA,eAAgB,CACd,OAAQ,CACN,CAAE,OAAQ,uBAAwB,MAAO,oBAAqB,EAC9D,CAAE,OAAQ,iBAAkB,CAC9B,CACF,EAEA,gBAAiB,CACf,GAAI,CACF,QAAS,gBACT,MAAO,OACT,EACA,OAAQ,CACN,GAAI,kBACJ,IAAK,8BACL,WAAY,CACV,WAAS,UAAO,CACd,kBAAmB,CAAC,CAAE,MAAAP,CAAM,IAC1BA,EAAM,SAAS,QAAQ,iBAC3B,CAAC,CACH,EACA,MAAO,CAAC,CAAE,QAAAC,CAAQ,IAChBA,EAAQ,eACL,QACC,IACE,IAAI,uBACF,+CACF,CACJ,EACC,MAAOC,MACN,mBAAgB,CACd,eAAgBD,EAAQ,MAAM,eAC9B,cAAeA,EAAQ,MAAM,cAC7B,QAASA,EAAQ,MAAM,QACvB,WAAYA,EAAQ,MAAM,WAC1B,YAAaA,EAAQ,MAAM,YAC3B,IAAK,OACH,YAASC,EAAM,IAAK,iCAAiC,EACvD,MAAOD,EAAQ,MAAM,MACrB,WAAY,OACV,YACEC,EAAM,WACN,wCACF,CACJ,CAAC,CACH,EACJ,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAF,CAAM,IAC/BA,EAAM,OAAO,IAAI,KAAO,CACtB,MAAO,UACP,OAAQ,CAAE,qBAAsB,EAAK,CACvC,EAAE,CACJ,CACF,CACF,CACF,EAEA,qBAAsB,CACpB,SAAO,UAAO,CACZ,kBAAmB,CACjB,KAAM,qBAAmB,qBACzB,wBAAyB,0BAAwB,IACnD,CACF,CAAC,EACD,GAAI,CAAE,QAAS,UAAW,MAAO,OAAQ,EACzC,OAAQ,CACN,GAAI,uBACJ,IAAK,uBACL,MAAO,CAAC,CAAE,QAAAC,CAAQ,KAAO,CACvB,cAAeA,EAAQ,MAAM,cAC7B,QAASA,EAAQ,MAAM,QACvB,OAAQA,EAAQ,eAAe,MAAM,CAAC,CAAE,WAAAM,CAAW,OACjD,YACEA,GAAY,aAAaN,EAAQ,MAAM,KAAK,EAAE,QAAQ,EACtD,qDACF,CACF,CACF,GACA,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAD,CAAM,IAC/BA,EAAM,OAAO,IAAKQ,IAAmB,CACnC,MAAO,UACP,OAAQ,CAAE,cAAAA,CAAc,CAC1B,EAAE,CACJ,CACF,CACF,CACF,EAEA,QAAS,CAAE,KAAM,OAAQ,EAEzB,MAAO,CAAE,KAAM,OAAQ,CACzB,EAEA,OAAQ,CAAC,CAAE,QAAAP,CAAQ,IACjBA,EAAQ,eAAe,MAAOC,MAC5B,mBAAgB,CACd,aAAc,OACZ,YACEA,EAAM,aACN,qCACF,EACF,IAAK,OAAM,YAASA,EAAM,IAAK,2BAA2B,EAC1D,gBAAiB,OACf,YACEA,EAAM,YACF,aAAaD,EAAQ,MAAM,KAAK,EACjC,MAAOE,GAAWA,EAAO,QAAQ,CAAC,EAClC,QAAQ,EACX,wCACF,EACF,cAAe,OACb,YACED,EAAM,cACN,sCACF,CACJ,CAAC,CACH,CACJ,CAAC,CACH,CAEA,oBAAoBN,EAA0B,CAC5C,MAAMa,EAAiB,IAAI,mBACrBC,EAA0B,IAAI,2BAEpC,MAAO,CACL,WAAY,CAAC,CAAE,MAAAN,CAAM,IACnBK,EAAe,IACbL,EAAM,eACN,IAAI,8BAA4BR,CAAW,CAC7C,EAEF,cAAgBe,GAUd,cAAY,WAAWA,EAAK,KAAK,EAC9B,MAAM,CAAC,CAAE,eAAAC,EAAgB,aAAAN,EAAc,IAAAO,CAAI,IAC1CD,EAAe,kBAAkBN,EAAcO,CAAG,CACpD,EACC,IAAI,EAET,qBAAsB,MAAO,CAC3B,MAAAT,CACF,IAOE,cAAY,WAAWA,EAAM,MAAM,EAAE,MAAOD,GAC1CO,EAAwB,IACtBN,EAAM,cACNA,EAAM,QACND,CACF,CACF,CACJ,CACF,CACF",
-  "names": ["AuthenticateWithDeviceDeviceAction_exports", "__export", "AuthenticateWithDeviceDeviceAction", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_xstate", "import_AuthenticateDeviceActionTypes", "import_Errors", "import_AuthenticateTask", "import_ExtractEncryptionKeyTask", "import_SignChallengeWithDeviceTask", "import_eitherSeqRecord", "import_required", "import_raiseAndAssign", "import_AddToTrustchainDeviceAction", "APP_NAME", "internalApi", "deviceAuth", "getTrustchain", "extractEncryptionKey", "event", "context", "state", "stream", "input", "payload", "trustchainId", "trustchain", "encryptionKey", "authentication", "encryptionKeyExtraction", "args", "lkrpDataSource", "jwt"]
-}

package/lib/cjs/internal/app-binder/device-action/AuthenticateWithKeypairDeviceAction.js

@@ -1,2 +0,0 @@
-"use strict";var m=Object.defineProperty;var K=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var I=Object.prototype.hasOwnProperty;var g=(a,r)=>{for(var c in r)m(a,c,{get:r[c],enumerable:!0})},k=(a,r,c,e)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of d(r))!I.call(a,t)&&t!==c&&m(a,t,{get:()=>r[t],enumerable:!(e=K(r,t))||e.enumerable});return a};var f=a=>k(m({},"__esModule",{value:!0}),a);var v={};g(v,{AuthenticateWithKeypairDeviceAction:()=>T});module.exports=f(v);var u=require("@ledgerhq/device-management-kit"),p=require("purify-ts"),n=require("xstate"),A=require("../../../api/app-binder/AuthenticateDeviceActionTypes"),h=require("../../../api/model/Errors"),E=require("../../app-binder/task/AuthenticateTask"),D=require("../../app-binder/task/ExtractEncryptionKeyTask"),l=require("../../app-binder/task/SignChallengeWithKeypairTask"),S=require("../../utils/eitherSeqRecord"),s=require("../../utils/required"),y=require("./utils/raiseAndAssign");class T extends u.XStateDeviceAction{execute(){const r=this.makeStateMachine();return this._subscribeToStateMachine(r)}makeStateMachine(){const{keypairAuth:r,getTrustchain:c,extractEncryptionKey:e}=this.extractDependencies();return(0,n.setup)({types:{input:{},context:{},output:{}},actors:{keypairAuth:(0,n.fromPromise)(r),getTrustchain:(0,n.fromPromise)(c),extractEncryptionKey:(0,n.fromPromise)(e)},actions:{assignErrorFromEvent:(0,y.raiseAndAssign)(({event:t})=>(0,p.Left)(new h.LKRPUnknownError(String(t.error))))}}).createMachine({id:"AuthenticateWithKeypairDeviceAction",context:({input:t})=>({input:t,intermediateValue:{requiredUserInteraction:u.UserInteractionRequired.None},_internalState:(0,p.Right)({jwt:null,trustchain:null,encryptionKey:null})}),initial:"KeypairAuth",states:{KeypairAuth:{entry:(0,n.assign)({intermediateValue:{requiredUserInteraction:u.UserInteractionRequired.None,step:A.AuthenticateDAStep.Authenticate}}),on:{success:"GetTrustchain",error:"Error"},invoke:{id:"keypairAuth",src:"keypairAuth",input:({context:t})=>t.input,onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,y.raiseAndAssign)(({context:t,event:i})=>i.output.map(({jwt:o})=>({raise:"success",assign:{jwt:o}})).mapLeft(o=>o instanceof h.LKRPDataSourceError&&o.status==="UNAUTHORIZED"?new h.LKRPUnauthorizedError(t.input.trustchainId):o))}}},GetTrustchain:{entry:(0,n.assign)({intermediateValue:{requiredUserInteraction:u.UserInteractionRequired.None,step:A.AuthenticateDAStep.GetTrustchain}}),on:{success:"ExtractEncryptionKey",error:"Error"},invoke:{id:"getTrustchain",src:"getTrustchain",input:({context:t})=>({lkrpDataSource:t.input.lkrpDataSource,trustchainId:t.input.trustchainId,jwt:t._internalState.chain(({jwt:i})=>(0,s.required)(i,"Missing JWT for GetTrustchain"))}),onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,y.raiseAndAssign)(({event:t})=>t.output.map(i=>({raise:"success",assign:{trustchain:i}})))}}},ExtractEncryptionKey:{entry:(0,n.assign)({intermediateValue:{requiredUserInteraction:u.UserInteractionRequired.None,step:A.AuthenticateDAStep.ExtractEncryptionKey}}),on:{success:"Success",error:"Error"},invoke:{id:"ExtractEncryptionKey",src:"extractEncryptionKey",input:({context:t})=>({cryptoService:t.input.cryptoService,keypair:t.input.keypair,stream:t._internalState.chain(({trustchain:i})=>(0,s.required)(i?.getAppStream(t.input.appId).extract(),"Missing application stream for ExtractEncryptionKey"))}),onError:{actions:"assignErrorFromEvent"},onDone:{actions:(0,y.raiseAndAssign)(({event:t})=>t.output.map(i=>({raise:"success",assign:{encryptionKey:i}})))}}},Success:{type:"final"},Error:{type:"final"}},output:({context:t})=>t._internalState.chain(i=>(0,S.eitherSeqRecord)({trustchainId:t.input.trustchainId,jwt:()=>(0,s.required)(i.jwt,"Missing JWT in the output"),applicationPath:()=>(0,s.required)(i.trustchain?.getAppStream(t.input.appId).chain(o=>o.getPath()).extract(),"Missing application path in the output"),encryptionKey:()=>(0,s.required)(i.encryptionKey,"Missing encryption key in the output")}))})}extractDependencies(){const r=new E.AuthenticateTask,c=new D.ExtractEncryptionKeyTask;return{keypairAuth:({input:e})=>r.run(e.lkrpDataSource,new l.SignChallengeWithKeypairTask(e.cryptoService,e.keypair,e.trustchainId)),getTrustchain:({input:e})=>p.EitherAsync.liftEither(e.jwt).chain(t=>e.lkrpDataSource.getTrustchainById(e.trustchainId,t)).run(),extractEncryptionKey:async({input:e})=>p.EitherAsync.liftEither(e.stream).chain(t=>c.run(e.cryptoService,e.keypair,t))}}}0&&(module.exports={AuthenticateWithKeypairDeviceAction});
-//# sourceMappingURL=AuthenticateWithKeypairDeviceAction.js.map

package/lib/cjs/internal/app-binder/device-action/AuthenticateWithKeypairDeviceAction.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/internal/app-binder/device-action/AuthenticateWithKeypairDeviceAction.ts"],
-  "sourcesContent": ["import {\n  type DeviceActionStateMachine,\n  type ExecuteDeviceActionReturnType,\n  type StateMachineTypes,\n  UserInteractionRequired,\n  XStateDeviceAction,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either, EitherAsync, Left, Right } from \"purify-ts\";\nimport { assign, fromPromise, setup } from \"xstate\";\n\nimport {\n  type AuthenticateDAError,\n  type AuthenticateDAIntermediateValue,\n  type AuthenticateDAOutput,\n  AuthenticateDAStep,\n} from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport {\n  LKRPDataSourceError,\n  LKRPUnauthorizedError,\n  LKRPUnknownError,\n} from \"@api/model/Errors\";\nimport { type JWT } from \"@api/model/JWT\";\nimport { AuthenticateTask } from \"@internal/app-binder/task/AuthenticateTask\";\nimport { ExtractEncryptionKeyTask } from \"@internal/app-binder/task/ExtractEncryptionKeyTask\";\nimport { SignChallengeWithKeypairTask } from \"@internal/app-binder/task/SignChallengeWithKeypairTask\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\nimport { type LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\nimport { required } from \"@internal/utils/required\";\n\nimport {\n  type AuthenticateWithKeypairDAInput,\n  type AuthenticateWithKeypairDAInternalState,\n} from \"./models/AuthenticateWithKeypairDeviceActionTypes\";\nimport { raiseAndAssign } from \"./utils/raiseAndAssign\";\n\nexport class AuthenticateWithKeypairDeviceAction extends XStateDeviceAction<\n  AuthenticateDAOutput,\n  AuthenticateWithKeypairDAInput,\n  AuthenticateDAError,\n  AuthenticateDAIntermediateValue,\n  AuthenticateWithKeypairDAInternalState\n> {\n  execute(): ExecuteDeviceActionReturnType<\n    AuthenticateDAOutput,\n    AuthenticateDAError,\n    AuthenticateDAIntermediateValue\n  > {\n    const stateMachine = this.makeStateMachine();\n    return this._subscribeToStateMachine(stateMachine);\n  }\n\n  makeStateMachine(): DeviceActionStateMachine<\n    AuthenticateDAOutput,\n    AuthenticateWithKeypairDAInput,\n    AuthenticateDAError,\n    AuthenticateDAIntermediateValue,\n    AuthenticateWithKeypairDAInternalState\n  > {\n    type types = StateMachineTypes<\n      AuthenticateDAOutput,\n      AuthenticateWithKeypairDAInput,\n      AuthenticateDAError,\n      AuthenticateDAIntermediateValue,\n      AuthenticateWithKeypairDAInternalState\n    >;\n\n    const { keypairAuth, getTrustchain, extractEncryptionKey } =\n      this.extractDependencies();\n\n    return setup({\n      types: {\n        input: {} as types[\"input\"],\n        context: {} as types[\"context\"],\n        output: {} as types[\"output\"],\n      },\n\n      actors: {\n        keypairAuth: fromPromise(keypairAuth),\n        getTrustchain: fromPromise(getTrustchain),\n        extractEncryptionKey: fromPromise(extractEncryptionKey),\n      },\n\n      actions: {\n        assignErrorFromEvent: raiseAndAssign(\n          ({ event }) =>\n            Left(\n              new LKRPUnknownError(\n                String((event as { error?: unknown }).error),\n              ),\n            ), // NOTE: it should never happen, the error is not typed anymore here\n        ),\n      },\n    }).createMachine({\n      /** @xstate-layout N4IgpgJg5mDOIC5QEECuAXAFmAduglgMYCG6YA6vlgNJgCeADsfgE4AiYAbkWMoQQHscAOlqNmLNFgDEEIWGH4cnAQGsF68aymYA2gAYAuolAMBsKviEmQAD0QBGfQFZhADgDMAdgBMXh24AbG7Ozl4ePgA0IHSOnsI+PoEuzg4ALACcGT4BAL650Tq4BCRklDT0TKwc3IS8-FYiYlWSGJjSYCwsAizCDAA2pABmPQC2wpotOgbGSCBmFoI4NvYI2cLJbj4eAZnpgWlRMYhBwofByV6BHmke2V75hW3FRKQUVJjNEjU8fEuilQkOmksFQhDqsFgMxsC0s1jmqxubg2IT8XmcGQxaQcDkC0ViCA8+g8wgcXi89y8+jcGWCPjSjxARTwrzKHy+1S4vwaQgBWlaMk63RY0LmsKWK0QSJRzjRGKxOLxxwQgVxwkxGSJaWcHhuHmcDIKTOeLNK7wq-J+dT+jWEAHEwOgACosVCwdCETDMHCyeSKZRqBQwZ2u92e72i0zmOHLBGIA36YTeDG0hx+BzOQJHAm7YQuTVZfTorxpTJuRnMkpvcqfQGc2r1f4OkNuj1epQdLo9PqDdAjFjjYMu1vhpSR+bRiVxhA6kn6HEZ0vOfQXfEnLwJZI+fRpYLZLPaismqtsi0tK2N23N4dh9s+0HguBQowwyeNSUINz6RPhTXakJpG4JZroSO55jiSROIcRIZkeWAvGaNYcuwXLWjyIjXqGbbep2wrjuK77Tl+P53DczgAUBaQgZkrjYiEZLXJikFwdgprVuydYoQ2Nq8gAorY6AsMQ-C8TghAsIwSxiL6OAKEoKjqMI-GCcJ6CieJkmNGI+FvvCoCrE4TjCKEGSZNutKeJ4IFksiPhZIksqpIqO4sQh7Fnt8qGXnxAlCSJYkSQwUn0Lh3YDMMYxKb5qnqYFwV0DpiyEfpjjzg4CQGjStypG4pZeCBbjpcu35EkEu66rKrlsaetaWl5PEiMpflqQFmlCNJD4Qs+sxRklel2I4uoZBlATeHZma6iBWruEupnJtcgEPEalasuatXnvV6FRSp-kaUFWkhUKPSJTGH4OENI2eL4mLXB4U2ZuqkHBLiZH6s4+RGjgAgQHANgrYhHF1dx6Gvn1sYpQgAC0DggZDrhZAjiNIx4VUnmtyEXg1fJTG0oOndOaT5cqPghHmPiyjRHgHDuKPLceq1IZxmNbZhI53njU4Q4TrjomSVymdi5UgSTrghCEf5Zok6K0088HVejTObf8TUxa1+3tfQHPJQNax+O4Li5bKxJFtkwtfnmGS5Q4tLJpbYSowzgMbcD-wAMpgl1Wv9QZu6BEmo1UwcHiWdmUpgTTOS0vompkjLxpy2jjNA9yytdiwXvgzr+x+zsniB7cIfUaZGxkmSu7LoEXhfkt+RAA */\n\n      id: \"AuthenticateWithKeypairDeviceAction\",\n      context: ({ input }): types[\"context\"] => ({\n        input,\n        intermediateValue: {\n          requiredUserInteraction: UserInteractionRequired.None,\n        },\n        _internalState: Right({\n          jwt: null,\n          trustchain: null,\n          encryptionKey: null,\n        }),\n      }),\n\n      initial: \"KeypairAuth\",\n      states: {\n        KeypairAuth: {\n          entry: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n              step: AuthenticateDAStep.Authenticate,\n            },\n          }),\n          on: { success: \"GetTrustchain\", error: \"Error\" },\n          invoke: {\n            id: \"keypairAuth\",\n            src: \"keypairAuth\",\n            input: ({ context }) => context.input,\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ context, event }) =>\n                event.output\n                  .map(({ jwt }) => ({ raise: \"success\", assign: { jwt } }))\n                  .mapLeft((error) =>\n                    error instanceof LKRPDataSourceError &&\n                    error.status === \"UNAUTHORIZED\"\n                      ? new LKRPUnauthorizedError(context.input.trustchainId)\n                      : error,\n                  ),\n              ),\n            },\n          },\n        },\n\n        GetTrustchain: {\n          entry: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n              step: AuthenticateDAStep.GetTrustchain,\n            },\n          }),\n          on: { success: \"ExtractEncryptionKey\", error: \"Error\" },\n          invoke: {\n            id: \"getTrustchain\",\n            src: \"getTrustchain\",\n            input: ({ context }) => ({\n              lkrpDataSource: context.input.lkrpDataSource,\n              trustchainId: context.input.trustchainId,\n              jwt: context._internalState.chain(({ jwt }) =>\n                required(jwt, \"Missing JWT for GetTrustchain\"),\n              ),\n            }),\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.map((trustchain) => ({\n                  raise: \"success\",\n                  assign: { trustchain },\n                })),\n              ),\n            },\n          },\n        },\n\n        ExtractEncryptionKey: {\n          entry: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n              step: AuthenticateDAStep.ExtractEncryptionKey,\n            },\n          }),\n          on: { success: \"Success\", error: \"Error\" },\n          invoke: {\n            id: \"ExtractEncryptionKey\",\n            src: \"extractEncryptionKey\",\n            input: ({ context }) => ({\n              cryptoService: context.input.cryptoService,\n              keypair: context.input.keypair,\n              stream: context._internalState.chain(({ trustchain }) =>\n                required(\n                  trustchain?.getAppStream(context.input.appId).extract(),\n                  \"Missing application stream for ExtractEncryptionKey\",\n                ),\n              ),\n            }),\n            onError: { actions: \"assignErrorFromEvent\" },\n            onDone: {\n              actions: raiseAndAssign(({ event }) =>\n                event.output.map((encryptionKey) => ({\n                  raise: \"success\",\n                  assign: { encryptionKey },\n                })),\n              ),\n            },\n          },\n        },\n\n        Success: { type: \"final\" },\n\n        Error: { type: \"final\" },\n      },\n\n      output: ({ context }) =>\n        context._internalState.chain((state) =>\n          eitherSeqRecord({\n            trustchainId: context.input.trustchainId,\n            jwt: () => required(state.jwt, \"Missing JWT in the output\"),\n            applicationPath: () =>\n              required(\n                state.trustchain\n                  ?.getAppStream(context.input.appId)\n                  .chain((stream) => stream.getPath())\n                  .extract(),\n                \"Missing application path in the output\",\n              ),\n            encryptionKey: () =>\n              required(\n                state.encryptionKey,\n                \"Missing encryption key in the output\",\n              ),\n          }),\n        ),\n    });\n  }\n\n  extractDependencies() {\n    const authentication = new AuthenticateTask();\n    const encryptionKeyExtraction = new ExtractEncryptionKeyTask();\n\n    return {\n      keypairAuth: ({ input }: { input: AuthenticateWithKeypairDAInput }) =>\n        authentication.run(\n          input.lkrpDataSource,\n          new SignChallengeWithKeypairTask(\n            input.cryptoService,\n            input.keypair,\n            input.trustchainId,\n          ),\n        ),\n\n      getTrustchain: ({\n        input,\n      }: {\n        input: {\n          lkrpDataSource: LKRPDataSource;\n          trustchainId: string;\n          jwt: Either<AuthenticateDAError, JWT>;\n        };\n      }) =>\n        EitherAsync.liftEither(input.jwt)\n          .chain((jwt) =>\n            input.lkrpDataSource.getTrustchainById(input.trustchainId, jwt),\n          )\n          .run(),\n\n      extractEncryptionKey: async ({\n        input,\n      }: {\n        input: {\n          cryptoService: CryptoService;\n          keypair: KeyPair;\n          stream: Either<AuthenticateDAError, LKRPBlockStream>;\n        };\n      }) =>\n        EitherAsync.liftEither(input.stream).chain((stream) =>\n          encryptionKeyExtraction.run(\n            input.cryptoService,\n            input.keypair,\n            stream,\n          ),\n        ),\n    };\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAMO,2CACPC,EAAsD,qBACtDC,EAA2C,kBAE3CC,EAKO,yDAGPC,EAIO,6BAEPC,EAAiC,sDACjCC,EAAyC,8DACzCC,EAA6C,kEAE7CC,EAAgC,2CAEhCC,EAAyB,oCAMzBC,EAA+B,kCAExB,MAAMZ,UAA4C,oBAMvD,CACA,SAIE,CACA,MAAMa,EAAe,KAAK,iBAAiB,EAC3C,OAAO,KAAK,yBAAyBA,CAAY,CACnD,CAEA,kBAME,CASA,KAAM,CAAE,YAAAC,EAAa,cAAAC,EAAe,qBAAAC,CAAqB,EACvD,KAAK,oBAAoB,EAE3B,SAAO,SAAM,CACX,MAAO,CACL,MAAO,CAAC,EACR,QAAS,CAAC,EACV,OAAQ,CAAC,CACX,EAEA,OAAQ,CACN,eAAa,eAAYF,CAAW,EACpC,iBAAe,eAAYC,CAAa,EACxC,wBAAsB,eAAYC,CAAoB,CACxD,EAEA,QAAS,CACP,wBAAsB,kBACpB,CAAC,CAAE,MAAAC,CAAM,OACP,QACE,IAAI,mBACF,OAAQA,EAA8B,KAAK,CAC7C,CACF,CACJ,CACF,CACF,CAAC,EAAE,cAAc,CAGf,GAAI,sCACJ,QAAS,CAAC,CAAE,MAAAC,CAAM,KAAyB,CACzC,MAAAA,EACA,kBAAmB,CACjB,wBAAyB,0BAAwB,IACnD,EACA,kBAAgB,SAAM,CACpB,IAAK,KACL,WAAY,KACZ,cAAe,IACjB,CAAC,CACH,GAEA,QAAS,cACT,OAAQ,CACN,YAAa,CACX,SAAO,UAAO,CACZ,kBAAmB,CACjB,wBAAyB,0BAAwB,KACjD,KAAM,qBAAmB,YAC3B,CACF,CAAC,EACD,GAAI,CAAE,QAAS,gBAAiB,MAAO,OAAQ,EAC/C,OAAQ,CACN,GAAI,cACJ,IAAK,cACL,MAAO,CAAC,CAAE,QAAAC,CAAQ,IAAMA,EAAQ,MAChC,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,QAAAA,EAAS,MAAAF,CAAM,IACxCA,EAAM,OACH,IAAI,CAAC,CAAE,IAAAG,CAAI,KAAO,CAAE,MAAO,UAAW,OAAQ,CAAE,IAAAA,CAAI,CAAE,EAAE,EACxD,QAASC,GACRA,aAAiB,uBACjBA,EAAM,SAAW,eACb,IAAI,wBAAsBF,EAAQ,MAAM,YAAY,EACpDE,CACN,CACJ,CACF,CACF,CACF,EAEA,cAAe,CACb,SAAO,UAAO,CACZ,kBAAmB,CACjB,wBAAyB,0BAAwB,KACjD,KAAM,qBAAmB,aAC3B,CACF,CAAC,EACD,GAAI,CAAE,QAAS,uBAAwB,MAAO,OAAQ,EACtD,OAAQ,CACN,GAAI,gBACJ,IAAK,gBACL,MAAO,CAAC,CAAE,QAAAF,CAAQ,KAAO,CACvB,eAAgBA,EAAQ,MAAM,eAC9B,aAAcA,EAAQ,MAAM,aAC5B,IAAKA,EAAQ,eAAe,MAAM,CAAC,CAAE,IAAAC,CAAI,OACvC,YAASA,EAAK,+BAA+B,CAC/C,CACF,GACA,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAH,CAAM,IAC/BA,EAAM,OAAO,IAAKK,IAAgB,CAChC,MAAO,UACP,OAAQ,CAAE,WAAAA,CAAW,CACvB,EAAE,CACJ,CACF,CACF,CACF,EAEA,qBAAsB,CACpB,SAAO,UAAO,CACZ,kBAAmB,CACjB,wBAAyB,0BAAwB,KACjD,KAAM,qBAAmB,oBAC3B,CACF,CAAC,EACD,GAAI,CAAE,QAAS,UAAW,MAAO,OAAQ,EACzC,OAAQ,CACN,GAAI,uBACJ,IAAK,uBACL,MAAO,CAAC,CAAE,QAAAH,CAAQ,KAAO,CACvB,cAAeA,EAAQ,MAAM,cAC7B,QAASA,EAAQ,MAAM,QACvB,OAAQA,EAAQ,eAAe,MAAM,CAAC,CAAE,WAAAG,CAAW,OACjD,YACEA,GAAY,aAAaH,EAAQ,MAAM,KAAK,EAAE,QAAQ,EACtD,qDACF,CACF,CACF,GACA,QAAS,CAAE,QAAS,sBAAuB,EAC3C,OAAQ,CACN,WAAS,kBAAe,CAAC,CAAE,MAAAF,CAAM,IAC/BA,EAAM,OAAO,IAAKM,IAAmB,CACnC,MAAO,UACP,OAAQ,CAAE,cAAAA,CAAc,CAC1B,EAAE,CACJ,CACF,CACF,CACF,EAEA,QAAS,CAAE,KAAM,OAAQ,EAEzB,MAAO,CAAE,KAAM,OAAQ,CACzB,EAEA,OAAQ,CAAC,CAAE,QAAAJ,CAAQ,IACjBA,EAAQ,eAAe,MAAOK,MAC5B,mBAAgB,CACd,aAAcL,EAAQ,MAAM,aAC5B,IAAK,OAAM,YAASK,EAAM,IAAK,2BAA2B,EAC1D,gBAAiB,OACf,YACEA,EAAM,YACF,aAAaL,EAAQ,MAAM,KAAK,EACjC,MAAOM,GAAWA,EAAO,QAAQ,CAAC,EAClC,QAAQ,EACX,wCACF,EACF,cAAe,OACb,YACED,EAAM,cACN,sCACF,CACJ,CAAC,CACH,CACJ,CAAC,CACH,CAEA,qBAAsB,CACpB,MAAME,EAAiB,IAAI,mBACrBC,EAA0B,IAAI,2BAEpC,MAAO,CACL,YAAa,CAAC,CAAE,MAAAT,CAAM,IACpBQ,EAAe,IACbR,EAAM,eACN,IAAI,+BACFA,EAAM,cACNA,EAAM,QACNA,EAAM,YACR,CACF,EAEF,cAAe,CAAC,CACd,MAAAA,CACF,IAOE,cAAY,WAAWA,EAAM,GAAG,EAC7B,MAAOE,GACNF,EAAM,eAAe,kBAAkBA,EAAM,aAAcE,CAAG,CAChE,EACC,IAAI,EAET,qBAAsB,MAAO,CAC3B,MAAAF,CACF,IAOE,cAAY,WAAWA,EAAM,MAAM,EAAE,MAAOO,GAC1CE,EAAwB,IACtBT,EAAM,cACNA,EAAM,QACNO,CACF,CACF,CACJ,CACF,CACF",
-  "names": ["AuthenticateWithKeypairDeviceAction_exports", "__export", "AuthenticateWithKeypairDeviceAction", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_xstate", "import_AuthenticateDeviceActionTypes", "import_Errors", "import_AuthenticateTask", "import_ExtractEncryptionKeyTask", "import_SignChallengeWithKeypairTask", "import_eitherSeqRecord", "import_required", "import_raiseAndAssign", "stateMachine", "keypairAuth", "getTrustchain", "extractEncryptionKey", "event", "input", "context", "jwt", "error", "trustchain", "encryptionKey", "state", "stream", "authentication", "encryptionKeyExtraction"]
-}

package/lib/cjs/internal/app-binder/device-action/models/AuthenticateWithDeviceDeviceActionTypes.js

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

package/lib/cjs/internal/app-binder/device-action/models/AuthenticateWithDeviceDeviceActionTypes.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/app-binder/device-action/models/AuthenticateWithDeviceDeviceActionTypes.ts"],
-  "sourcesContent": ["import { type Either } from \"purify-ts\";\n\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport {\n  type AuthenticateDAError,\n  type JWT,\n  type Permissions,\n} from \"@api/index\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { type Trustchain } from \"@internal/utils/Trustchain\";\n\nexport type AuthenticateWithDeviceDAInput = {\n  readonly lkrpDataSource: LKRPDataSource;\n  readonly appId: number;\n  readonly cryptoService: CryptoService;\n  readonly keypair: KeyPair;\n  readonly clientName: string;\n  readonly permissions: Permissions;\n};\n\nexport type AuthenticateWithDeviceDAInternalState = Either<\n  AuthenticateDAError,\n  {\n    readonly trustchainId: string | null;\n    readonly jwt: JWT | null;\n    readonly trustchain: Trustchain | null;\n    readonly encryptionKey: Uint8Array | null;\n    readonly wasAddedToTrustchain: boolean;\n  }\n>;\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["AuthenticateWithDeviceDeviceActionTypes_exports", "__toCommonJS"]
-}

package/lib/cjs/internal/app-binder/device-action/models/AuthenticateWithKeypairDeviceActionTypes.js

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

package/lib/cjs/internal/app-binder/device-action/models/AuthenticateWithKeypairDeviceActionTypes.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../src/internal/app-binder/device-action/models/AuthenticateWithKeypairDeviceActionTypes.ts"],
-  "sourcesContent": ["import { type Either } from \"purify-ts\";\n\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport { type AuthenticateDAError, type JWT } from \"@api/index\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { type Trustchain } from \"@internal/utils/Trustchain\";\n\nexport type AuthenticateWithKeypairDAInput = {\n  readonly lkrpDataSource: LKRPDataSource;\n  readonly appId: number;\n  readonly cryptoService: CryptoService;\n  readonly keypair: KeyPair;\n  readonly trustchainId: string;\n};\n\nexport type AuthenticateWithKeypairDAInternalState = Either<\n  AuthenticateDAError,\n  {\n    readonly jwt: JWT | null;\n    readonly trustchain: Trustchain | null;\n    readonly encryptionKey: Uint8Array | null;\n  }\n>;\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["AuthenticateWithKeypairDeviceActionTypes_exports", "__toCommonJS"]
-}

package/lib/cjs/internal/app-binder/task/AuthenticateTask.js

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

package/lib/cjs/internal/app-binder/task/AuthenticateTask.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/internal/app-binder/task/AuthenticateTask.ts"],
-  "sourcesContent": ["import { type Either } from \"purify-ts\";\n\nimport { type AuthenticateDAError } from \"@api/index\";\nimport {\n  type AuthenticationPayload,\n  type AuthenticationResponse,\n  type Challenge,\n  type LKRPDataSource,\n} from \"@internal/lkrp-datasource/data/LKRPDataSource\";\n\nexport class AuthenticateTask {\n  run(\n    lkrpDataSource: LKRPDataSource,\n    signerTask: {\n      run: (\n        challenge: Challenge,\n      ) => PromiseLike<Either<AuthenticateDAError, AuthenticationPayload>>;\n    },\n  ): Promise<Either<AuthenticateDAError, AuthenticationResponse>> {\n    return lkrpDataSource\n      .getChallenge()\n      .chain((challenge) => signerTask.run(challenge))\n      .chain((payload) => lkrpDataSource.authenticate(payload))\n      .run();\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,sBAAAE,IAAA,eAAAC,EAAAH,GAUO,MAAME,CAAiB,CAC5B,IACEE,EACAC,EAK8D,CAC9D,OAAOD,EACJ,aAAa,EACb,MAAOE,GAAcD,EAAW,IAAIC,CAAS,CAAC,EAC9C,MAAOC,GAAYH,EAAe,aAAaG,CAAO,CAAC,EACvD,IAAI,CACT,CACF",
-  "names": ["AuthenticateTask_exports", "__export", "AuthenticateTask", "__toCommonJS", "lkrpDataSource", "signerTask", "challenge", "payload"]
-}

package/lib/cjs/internal/app-binder/task/ExtractEncryptionKeyTask.js

@@ -1,2 +0,0 @@
-"use strict";var p=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var y=Object.prototype.hasOwnProperty;var c=(e,r)=>{for(var o in r)p(e,o,{get:r[o],enumerable:!0})},K=(e,r,o,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of m(r))!y.call(e,t)&&t!==o&&p(e,t,{get:()=>r[t],enumerable:!(i=n(r,t))||i.enumerable});return e};var s=e=>K(p({},"__esModule",{value:!0}),e);var f={};c(f,{ExtractEncryptionKeyTask:()=>P});module.exports=s(f);var a=require("../../../api/model/Errors");class P{async run(r,o,i){return(await i.getPublishedKey(r,o)).map(t=>t.privateKey).toEither(new a.LKRPUnknownError("There is no encryption key for the current member in the application stream."))}}0&&(module.exports={ExtractEncryptionKeyTask});
-//# sourceMappingURL=ExtractEncryptionKeyTask.js.map

package/lib/cjs/internal/app-binder/task/ExtractEncryptionKeyTask.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/internal/app-binder/task/ExtractEncryptionKeyTask.ts"],
-  "sourcesContent": ["import { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport { LKRPUnknownError } from \"@api/model/Errors\";\nimport { type LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\n\nexport class ExtractEncryptionKeyTask {\n  async run(\n    cryptoService: CryptoService,\n    keypair: KeyPair,\n    stream: LKRPBlockStream,\n  ) {\n    // TODO additional derivations should be supported:\n    // https://github.com/LedgerHQ/ledger-live/blob/develop/libs/hw-ledger-key-ring-protocol/src/Device.ts#L216...L226\n    // Probably not needed for Ledger Sync\n    return (await stream.getPublishedKey(cryptoService, keypair))\n      .map((key) => key.privateKey)\n      .toEither(\n        new LKRPUnknownError(\n          \"There is no encryption key for the current member in the application stream.\",\n        ),\n      );\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,IAAA,eAAAC,EAAAH,GAEA,IAAAI,EAAiC,6BAG1B,MAAMF,CAAyB,CACpC,MAAM,IACJG,EACAC,EACAC,EACA,CAIA,OAAQ,MAAMA,EAAO,gBAAgBF,EAAeC,CAAO,GACxD,IAAKE,GAAQA,EAAI,UAAU,EAC3B,SACC,IAAI,mBACF,8EACF,CACF,CACJ,CACF",
-  "names": ["ExtractEncryptionKeyTask_exports", "__export", "ExtractEncryptionKeyTask", "__toCommonJS", "import_Errors", "cryptoService", "keypair", "stream", "key"]
-}

package/lib/cjs/internal/models/LKRPBlockTypes.js

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

package/lib/cjs/internal/models/LKRPBlockTypes.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/internal/models/LKRPBlockTypes.ts"],
-  "sourcesContent": ["import { type LKRPCommand } from \"@internal/utils/LKRPCommand\";\n\nexport type LKRPBlockData = {\n  parent: string;\n  issuer: Uint8Array;\n  commands: LKRPCommand[];\n  signature: Uint8Array;\n};\n\nexport type LKRPBlockParsedData = LKRPBlockData & { header: Uint8Array };\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["LKRPBlockTypes_exports", "__toCommonJS"]
-}

package/lib/cjs/internal/models/LKRPCommandTypes.js

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

package/lib/cjs/internal/models/LKRPCommandTypes.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/internal/models/LKRPCommandTypes.ts"],
-  "sourcesContent": ["import { type CommandTags } from \"./Tags\";\n\nexport type LKRPCommandData = Seed | AddMember | PublishKey | Derive;\n\ntype Seed = {\n  type: CommandTags.Seed;\n  topic: Uint8Array;\n  protocolVersion: number;\n  groupKey: Uint8Array;\n  initializationVector: Uint8Array;\n  encryptedXpriv: Uint8Array;\n  ephemeralPublicKey: Uint8Array;\n};\n\ntype AddMember = {\n  type: CommandTags.AddMember;\n  name: string;\n  publicKey: Uint8Array;\n  permissions: number;\n};\n\ntype PublishKey = {\n  type: CommandTags.PublishKey;\n  initializationVector: Uint8Array;\n  encryptedXpriv: Uint8Array;\n  recipient: Uint8Array;\n  ephemeralPublicKey: Uint8Array;\n};\n\ntype Derive = {\n  type: CommandTags.Derive;\n  path: string;\n  groupKey: Uint8Array;\n  initializationVector: Uint8Array;\n  encryptedXpriv: Uint8Array;\n  ephemeralPublicKey: Uint8Array;\n};\n\nexport type UnsignedCommandData =\n  | AddMemberUnsignedData\n  | PublishKeyUnsignedData\n  | DeriveUnsignedData;\n\nexport type AddMemberUnsignedData = AddMember;\ntype PublishKeyUnsignedData = Pick<PublishKey, \"type\" | \"recipient\">;\ntype DeriveUnsignedData = Pick<Derive, \"type\" | \"path\">;\n\nexport type EncryptedCommand =\n  | EncryptedDeriveCommand\n  | AddMemberUnsignedData\n  | EncryptedPublishKeyCommand;\n\nexport type EncryptedDeriveCommand = DeriveUnsignedData &\n  Pick<\n    ParsedTrustedProperties,\n    \"iv\" | \"xpriv\" | \"ephemeralPublicKey\" | \"commandIv\" | \"groupKey\"\n  >;\nexport type EncryptedPublishKeyCommand = PublishKeyUnsignedData &\n  Pick<\n    ParsedTrustedProperties,\n    \"iv\" | \"xpriv\" | \"ephemeralPublicKey\" | \"commandIv\"\n  >;\n\ntype ParsedTrustedProperties = {\n  iv: Uint8Array;\n  issuer: Uint8Array;\n  xpriv: Uint8Array;\n  ephemeralPublicKey: Uint8Array;\n  commandIv: Uint8Array;\n  groupKey: Uint8Array;\n  newMember: Uint8Array;\n};\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["LKRPCommandTypes_exports", "__toCommonJS"]
-}

package/lib/cjs/internal/models/Types.js

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

package/lib/cjs/internal/models/Types.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/internal/models/Types.ts"],
-  "sourcesContent": ["export type PublishedKey = {\n  privateKey: Uint8Array;\n  chainCode: Uint8Array;\n};\n\nexport type EncryptedPublishedKey = {\n  encryptedXpriv: Uint8Array;\n  initializationVector: Uint8Array;\n  ephemeralPublicKey: Uint8Array;\n};\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["Types_exports", "__toCommonJS"]
-}

package/lib/cjs/internal/use-cases/authentication/DecryptDataUseCase.js

@@ -1,2 +0,0 @@
-"use strict";var p=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var B=Object.getOwnPropertyNames;var P=Object.prototype.hasOwnProperty;var U=(i,e)=>{for(var n in e)p(i,n,{get:e[n],enumerable:!0})},b=(i,e,n,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of B(e))!P.call(i,r)&&r!==n&&p(i,r,{get:()=>e[r],enumerable:!(t=l(e,r))||t.enumerable});return i};var E=i=>b(p({},"__esModule",{value:!0}),i),h=(i,e,n,t)=>{for(var r=t>1?void 0:t?l(e,n):e,o=i.length-1,c;o>=0;o--)(c=i[o])&&(r=(t?c(e,n,r):c(r))||r);return t&&r&&p(e,n,r),r},d=(i,e)=>(n,t)=>e(n,t,i);var F={};U(F,{DecryptDataUseCase:()=>y});module.exports=E(F);var g=require("@ledgerhq/device-management-kit"),m=require("inversify"),v=require("purify-ts"),a=require("../../../api/crypto/CryptoService"),s=require("../../../api/model/Errors"),S=require("../../externalTypes"),f=require("../../utils/eitherSeqRecord");let y=class{constructor(e){this.cryptoService=e}async execute(e,n){const t=new g.ByteArrayParser(n);if(t.extract8BitUInt()!==0)throw new s.LKRPParsingError("Unsupported serialization version");const r=(o,c)=>v.Maybe.fromNullable(o).toEither(new s.LKRPParsingError(`Missing ${c} field`));return(0,f.eitherSeqRecord)({ephemeralPublicKey:()=>r(t.extractFieldByLength(33),"ephemeral public key"),iv:()=>r(t.extractFieldByLength(16),"IV"),tag:()=>r(t.extractFieldByLength(16),"tag"),encryptedData:()=>r(t.extractFieldByLength(t.getUnparsedRemainingLength()),"encrypted data")}).map(async({ephemeralPublicKey:o,iv:c,tag:u,encryptedData:x})=>{const A=await this.cryptoService.importKeyPair(e,a.Curve.K256).deriveSharedSecret(o),w=this.cryptoService.hmac(new Uint8Array,A.slice(1),a.HashAlgo.SHA256),K=this.cryptoService.importSymmetricKey(w,a.EncryptionAlgo.AES256_GCM),L=new Uint8Array([...x,...u]);return await K.decrypt(c,L)}).caseOf({Left:o=>{throw o},Right:o=>o})}};y=h([(0,m.injectable)(),d(0,(0,m.inject)(S.externalTypes.CryptoService))],y);0&&(module.exports={DecryptDataUseCase});
-//# sourceMappingURL=DecryptDataUseCase.js.map

package/lib/cjs/internal/use-cases/authentication/DecryptDataUseCase.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../../src/internal/use-cases/authentication/DecryptDataUseCase.ts"],
-  "sourcesContent": ["import { ByteArrayParser } from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  type CryptoService,\n  Curve,\n  EncryptionAlgo,\n  HashAlgo,\n} from \"@api/crypto/CryptoService\";\nimport { LKRPParsingError } from \"@api/model/Errors\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\n\n@injectable()\nexport class DecryptDataUseCase {\n  constructor(\n    @inject(externalTypes.CryptoService)\n    private cryptoService: CryptoService,\n  ) {}\n\n  // TODO better return type instead of throw on errors\n  async execute(\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\n    const parser = new ByteArrayParser(data);\n    if (parser.extract8BitUInt() !== 0) {\n      throw new LKRPParsingError(\"Unsupported serialization version\");\n    }\n    const required = (value: Uint8Array | undefined, field: string) =>\n      Maybe.fromNullable(value).toEither(\n        new LKRPParsingError(`Missing ${field} field`),\n      );\n\n    return eitherSeqRecord({\n      ephemeralPublicKey: () =>\n        required(parser.extractFieldByLength(33), \"ephemeral public key\"),\n      iv: () => required(parser.extractFieldByLength(16), \"IV\"),\n      tag: () => required(parser.extractFieldByLength(16), \"tag\"),\n      encryptedData: () =>\n        required(\n          parser.extractFieldByLength(parser.getUnparsedRemainingLength()),\n          \"encrypted data\",\n        ),\n    })\n      .map(async ({ ephemeralPublicKey, iv, tag, encryptedData }) => {\n        // Derive the shared secret using ECDH with an ephemeral keypair\n        const privateKey = this.cryptoService.importKeyPair(\n          encryptionKey,\n          Curve.K256,\n        );\n        const sharedSecret =\n          await privateKey.deriveSharedSecret(ephemeralPublicKey);\n\n        // Key derivation using HMAC-SHA256\n        const key = this.cryptoService.hmac(\n          new Uint8Array(),\n          sharedSecret.slice(1),\n          HashAlgo.SHA256,\n        );\n\n        // Decrypt the data\n        const symmetricKey = this.cryptoService.importSymmetricKey(\n          key,\n          EncryptionAlgo.AES256_GCM,\n        );\n        const ciphertext = new Uint8Array([...encryptedData, ...tag]);\n        const cleartext = await symmetricKey.decrypt(iv, ciphertext);\n        return cleartext;\n      })\n      .caseOf({\n        Left: (error) => {\n          throw error;\n        },\n        Right: (cleartext) => cleartext,\n      });\n  }\n}\n"],
-  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,2CAChCC,EAAmC,qBACnCC,EAAsB,qBAEtBC,EAKO,qCACPC,EAAiC,6BACjCC,EAA8B,mCAC9BC,EAAgC,2CAGzB,IAAMC,EAAN,KAAyB,CAC9B,YAEUC,EACR,CADQ,mBAAAA,CACP,CAGH,MAAM,QACJC,EACAC,EACqB,CACrB,MAAMC,EAAS,IAAI,kBAAgBD,CAAI,EACvC,GAAIC,EAAO,gBAAgB,IAAM,EAC/B,MAAM,IAAI,mBAAiB,mCAAmC,EAEhE,MAAMC,EAAW,CAACC,EAA+BC,IAC/C,QAAM,aAAaD,CAAK,EAAE,SACxB,IAAI,mBAAiB,WAAWC,CAAK,QAAQ,CAC/C,EAEF,SAAO,mBAAgB,CACrB,mBAAoB,IAClBF,EAASD,EAAO,qBAAqB,EAAE,EAAG,sBAAsB,EAClE,GAAI,IAAMC,EAASD,EAAO,qBAAqB,EAAE,EAAG,IAAI,EACxD,IAAK,IAAMC,EAASD,EAAO,qBAAqB,EAAE,EAAG,KAAK,EAC1D,cAAe,IACbC,EACED,EAAO,qBAAqBA,EAAO,2BAA2B,CAAC,EAC/D,gBACF,CACJ,CAAC,EACE,IAAI,MAAO,CAAE,mBAAAI,EAAoB,GAAAC,EAAI,IAAAC,EAAK,cAAAC,CAAc,IAAM,CAM7D,MAAMC,EACJ,MALiB,KAAK,cAAc,cACpCV,EACA,QAAM,IACR,EAEmB,mBAAmBM,CAAkB,EAGlDK,EAAM,KAAK,cAAc,KAC7B,IAAI,WACJD,EAAa,MAAM,CAAC,EACpB,WAAS,MACX,EAGME,EAAe,KAAK,cAAc,mBACtCD,EACA,iBAAe,UACjB,EACME,EAAa,IAAI,WAAW,CAAC,GAAGJ,EAAe,GAAGD,CAAG,CAAC,EAE5D,OADkB,MAAMI,EAAa,QAAQL,EAAIM,CAAU,CAE7D,CAAC,EACA,OAAO,CACN,KAAOC,GAAU,CACf,MAAMA,CACR,EACA,MAAQC,GAAcA,CACxB,CAAC,CACL,CACF,EA/DajB,EAANkB,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,gBAAc,aAAa,IAF1BnB",
-  "names": ["DecryptDataUseCase_exports", "__export", "DecryptDataUseCase", "__toCommonJS", "import_device_management_kit", "import_inversify", "import_purify_ts", "import_CryptoService", "import_Errors", "import_externalTypes", "import_eitherSeqRecord", "DecryptDataUseCase", "cryptoService", "encryptionKey", "data", "parser", "required", "value", "field", "ephemeralPublicKey", "iv", "tag", "encryptedData", "sharedSecret", "key", "symmetricKey", "ciphertext", "error", "cleartext", "__decorateClass", "__decorateParam"]
-}

package/lib/cjs/internal/use-cases/authentication/EncryptDataUseCase.js

@@ -1,2 +0,0 @@
-"use strict";var p=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var B=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var T=(t,r)=>{for(var i in r)p(t,i,{get:r[i],enumerable:!0})},g=(t,r,i,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of B(r))!b.call(t,e)&&e!==i&&p(t,e,{get:()=>r[e],enumerable:!(o=u(r,e))||o.enumerable});return t};var w=t=>g(p({},"__esModule",{value:!0}),t),v=(t,r,i,o)=>{for(var e=o>1?void 0:o?u(r,i):r,a=t.length-1,y;a>=0;a--)(y=t[a])&&(e=(o?y(r,i,e):y(e))||e);return o&&e&&p(r,i,e),e},f=(t,r)=>(i,o)=>r(i,o,t);var P={};T(P,{EncryptDataUseCase:()=>n});module.exports=w(P);var K=require("@ledgerhq/device-management-kit"),m=require("inversify"),c=require("../../../api/crypto/CryptoService"),s=require("../../../api/crypto/Key"),h=require("../../externalTypes");let n=class{constructor(r){this.cryptoService=r}async execute(r,i){const o=this.cryptoService.importKeyPair(r,c.Curve.K256),e=await this.cryptoService.createKeyPair(c.Curve.K256),a=await o.deriveSharedSecret(e.getPublicKey()),y=this.cryptoService.hmac(new Uint8Array,a.slice(1),c.HashAlgo.SHA256),d=this.cryptoService.randomBytes(16),S=await this.cryptoService.importSymmetricKey(y,c.EncryptionAlgo.AES256_GCM).encrypt(d,i),l=S.subarray(0,-s.AES256_BLOCK_SIZE),A=S.subarray(-s.AES256_BLOCK_SIZE);return new K.ByteArrayBuilder().add8BitUIntToData(0).addBufferToData(e.getPublicKey()).addBufferToData(d).addBufferToData(A).addBufferToData(l).build()}};n=v([(0,m.injectable)(),f(0,(0,m.inject)(h.externalTypes.CryptoService))],n);0&&(module.exports={EncryptDataUseCase});
-//# sourceMappingURL=EncryptDataUseCase.js.map