@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol 0.0.0-multisig-20250822145545 → 0.0.0-web-ble-29-08---20250829104351

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol",
-  "version": "0.0.0-multisig-20250822145545",
+  "version": "0.0.0-web-ble-29-08---20250829104351",
   "license": "Apache-2.0",
   "private": false,
   "exports": {
@@ -20,20 +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-multisig-20250822145545",
-    "@ledgerhq/signer-utils": "0.0.0-multisig-20250822145545"
+    "@ledgerhq/device-management-kit": "0.0.0-web-ble-29-08---20250829104351",
+    "@ledgerhq/signer-utils": "0.0.0-web-ble-29-08---20250829104351"
   },
   "devDependencies": {
     "@ledgerhq/eslint-config-dsdk": "0.0.2",
-    "@ledgerhq/prettier-config-dsdk": "0.0.2",
     "@ledgerhq/ldmk-tool": "0.0.1",
+    "@ledgerhq/prettier-config-dsdk": "0.0.2",
     "@ledgerhq/tsconfig-dsdk": "1.0.1",
     "@ledgerhq/vitest-config-dmk": "0.0.0"
   },

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 U=(i,r)=>{for(var e in r)a(i,e,{get:r[e],enumerable:!0})},s=(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=>s(a({},"__esModule",{value:!0}),i);var u={};U(u,{SigFormat:()=>y});module.exports=c(u);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  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 m=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var g=(a,r)=>{for(var e in r)s(a,e,{get:r[e],enumerable:!0})},f=(a,r,e,t)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of v(r))!l.call(a,i)&&i!==e&&s(a,i,{get:()=>r[i],enumerable:!(t=m(r,i))||t.enumerable});return a};var K=a=>f(s({},"__esModule",{value:!0}),a);var b={};g(b,{NobleKeyPair:()=>n});module.exports=K(b);var u=require("@ledgerhq/device-management-kit"),y=require("@noble/curves/nist.js"),p=require("@noble/curves/secp256k1.js"),c=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 c.Curve.K256:return p.secp256k1;case c.Curve.P256:return y.p256;default:throw new Error(`Unsupported curve ${r}`)}}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,u.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  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,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/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/esm/api/crypto/CryptoService.js

@@ -1,2 +0,0 @@
-var t=(e=>(e[e.K256=0]="K256",e[e.P256=1]="P256",e))(t||{}),y=(r=>(r[r.AES256_GCM=0]="AES256_GCM",r))(y||{}),a=(r=>(r[r.SHA256=0]="SHA256",r))(a||{});export{t as Curve,y as EncryptionAlgo,a as HashAlgo};
-//# sourceMappingURL=CryptoService.js.map

package/lib/esm/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": "AAGO,IAAKA,OACVA,IAAA,eACAA,IAAA,eAFUA,OAAA,IAKAC,OACVA,IAAA,2BADUA,OAAA,IAIAC,OACVA,IAAA,mBADUA,OAAA",
-  "names": ["Curve", "EncryptionAlgo", "HashAlgo"]
-}

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

@@ -1,2 +0,0 @@
-const r=32,t=16;export{t as AES256_BLOCK_SIZE,r as AES256_KEY_SIZE};
-//# sourceMappingURL=Key.js.map

package/lib/esm/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": "AAAO,MAAMA,EAAkB,GAClBC,EAAoB",
-  "names": ["AES256_KEY_SIZE", "AES256_BLOCK_SIZE"]
-}

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

@@ -1,2 +0,0 @@
-var e=(r=>(r[r.COMPACT=0]="COMPACT",r[r.DER=1]="DER",r))(e||{});export{e as SigFormat};
-//# sourceMappingURL=KeyPair.js.map

package/lib/esm/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  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": "AAAO,IAAKA,OACVA,IAAA,qBACAA,IAAA,aAFUA,OAAA",
-  "names": ["SigFormat"]
-}

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

@@ -1,2 +0,0 @@
-import{randomBytes as m}from"@noble/ciphers/webcrypto";import{hmac as n}from"@noble/hashes/hmac";import{sha256 as o}from"@noble/hashes/sha256";import{HashAlgo as i}from"../../crypto/CryptoService";import{NobleKey as a}from"./NobleKey";import{NobleKeyPair as y}from"./NobleKeyPair";class f{randomBytes(r){return m(r)}hash(r,e){switch(e){case i.SHA256:return o(r);default:throw new Error("Unsupported hash algorithm",e)}}hmac(r,e,t){switch(t){case i.SHA256:return n(o,r,e);default:throw new Error("Unsupported hash algorithm",t)}}async createKeyPair(r){return await y.generate(r)}importKeyPair(r,e){return y.from(r,e)}async createSymmetricKey(r){return await a.generate(r)}importSymmetricKey(r,e){return a.from(r,e)}}export{f as NobleCryptoService};
-//# sourceMappingURL=NobleCryptoService.js.map

package/lib/esm/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": "AAAA,OAAS,eAAAA,MAAmB,2BAC5B,OAAS,QAAAC,MAAY,qBACrB,OAAS,UAAAC,MAAc,uBAEvB,OAIE,YAAAC,MACK,4BAIP,OAAS,YAAAC,MAAgB,aACzB,OAAS,gBAAAC,MAAoB,iBAEtB,MAAMC,CAA4C,CACvD,YAAYC,EAAyB,CACnC,OAAOP,EAAYO,CAAG,CACxB,CAEA,KAAKC,EAAmBC,EAA4B,CAClD,OAAQA,EAAM,CACZ,KAAKN,EAAS,OACZ,OAAOD,EAAOM,CAAK,EACrB,QACE,MAAM,IAAI,MAAM,6BAA8BC,CAAI,CACtD,CACF,CAEA,KAAKC,EAAiBC,EAAqBF,EAA4B,CACrE,OAAQA,EAAM,CACZ,KAAKN,EAAS,OACZ,OAAOF,EAAKC,EAAQQ,EAAKC,CAAO,EAClC,QACE,MAAM,IAAI,MAAM,6BAA8BF,CAAI,CACtD,CACF,CAEA,MAAM,cAAcG,EAAgC,CAClD,OAAO,MAAMP,EAAa,SAASO,CAAK,CAC1C,CAEA,cAAcC,EAAwBD,EAAuB,CAC3D,OAAOP,EAAa,KAAKQ,EAAYD,CAAK,CAC5C,CAEA,MAAM,mBAAmBH,EAAoC,CAC3D,OAAO,MAAML,EAAS,SAASK,CAAI,CACrC,CAEA,mBAAmBK,EAAyBL,EAA2B,CACrE,OAAOL,EAAS,KAAKU,EAAaL,CAAI,CACxC,CACF",
-  "names": ["randomBytes", "hmac", "sha256", "HashAlgo", "NobleKey", "NobleKeyPair", "NobleCryptoService", "len", "bytes", "algo", "key", "message", "curve", "privateKey", "keyMaterial"]
-}

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

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

package/lib/esm/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,OAAS,sBAAAA,MAA0B,kCAEnC,OAAS,SAAAC,EAAO,kBAAAC,EAAgB,YAAAC,MAAgB,4BAEhD,OAAS,sBAAAC,MAA0B,uBACnC,OAAS,YAAAC,MAAgB,aACzB,OAAS,gBAAAC,MAAoB,iBAE7B,SAAS,qBAAsB,IAAM,CACnC,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAgB,IAAIH,CACtB,CAAC,EAED,GAAG,iDAAkD,IAAM,CAEzD,MAAMI,EAAQD,EAAc,YAAY,EAAM,EAC9C,OAAOC,EAAM,MAAM,EAAE,KAAK,EAAM,CAClC,CAAC,EAED,GAAG,yCAA0C,IAAM,CACjD,MAAMC,EAAO,IAAI,YAAY,EAAE,OAAO,MAAM,EACtCC,EAAaH,EAAc,KAAKE,EAAMN,EAAS,MAAM,EAC3D,OAAOO,CAAU,EAAE,QACjBV,EACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMW,EAAM,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EAClCC,EAAU,IAAI,YAAY,EAAE,OAAO,cAAc,EACjDC,EAAaN,EAAc,KAAKI,EAAKC,EAAST,EAAS,MAAM,EACnE,OAAOU,CAAU,EAAE,QACjBb,EACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,2BAA4B,SAAY,CACzC,MAAMc,EAAU,MAAMP,EAAc,cAAcN,EAAM,IAAI,EAC5D,OAAOa,aAAmBR,CAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,2BAA4B,IAAM,CACnC,MAAMS,EAAa,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACtCD,EAAUP,EAAc,cAAcQ,EAAYd,EAAM,IAAI,EAClE,OAAOa,aAAmBR,CAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,gCAAiC,SAAY,CAC9C,MAAMU,EAAe,MAAMT,EAAc,mBACvCL,EAAe,UACjB,EACA,OAAOc,aAAwBX,CAAQ,EAAE,WAAW,CACtD,CAAC,EAED,GAAG,gCAAiC,IAAM,CACxC,MAAMY,EAAc,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACvCD,EAAeT,EAAc,mBACjCU,EACAf,EAAe,UACjB,EACA,OAAOc,aAAwBX,CAAQ,EAAE,WAAW,CACtD,CAAC,CACH,CAAC",
-  "names": ["hexaStringToBuffer", "Curve", "EncryptionAlgo", "HashAlgo", "NobleCryptoService", "NobleKey", "NobleKeyPair", "cryptoService", "bytes", "data", "hashResult", "key", "message", "hmacResult", "keyPair", "privateKey", "symmetricKey", "keyMaterial"]
-}

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

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

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

@@ -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": "AAAA,OAAS,OAAAA,MAAW,qBACpB,OAAS,eAAAC,MAAmB,2BAE5B,OAAS,kBAAAC,MAAsB,4BAC/B,OAAS,qBAAAC,EAAmB,mBAAAC,MAAiC,kBAEtD,MAAMC,CAAwB,CAoB3B,YAAoBC,EAAiB,CAAjB,SAAAA,CAAkB,CAnB9C,aAAa,SACXC,EAAuBL,EAAe,WACnB,CACnB,GAAIK,IAASL,EAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCK,CAAI,EAAE,EAE5D,OAAO,IAAIF,EAASJ,EAAYG,CAAe,CAAC,CAClD,CAEA,OAAO,KACLI,EACAD,EAAuBL,EAAe,WAC5B,CACV,GAAIK,IAASL,EAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCK,CAAI,EAAE,EAE5D,OAAO,IAAIF,EAASG,CAAW,CACjC,CAIA,MAAM,QAAQC,EAAgBC,EAAuC,CAEnE,OADeV,EAAI,KAAK,IAAKS,EAAG,MAAM,EAAGN,CAAiB,CAAC,EAC7C,QAAQO,CAAI,CAC5B,CAEA,MAAM,QACJD,EACAE,EACqB,CAErB,OADeX,EAAI,KAAK,IAAKS,EAAG,MAAM,EAAGN,CAAiB,CAAC,EAC7C,QAAQQ,CAAa,CACrC,CACF",
-  "names": ["gcm", "randomBytes", "EncryptionAlgo", "AES256_BLOCK_SIZE", "AES256_KEY_SIZE", "NobleKey", "key", "algo", "keyMaterial", "iv", "data", "encryptedData"]
-}

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

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

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

@@ -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,OAAS,qBAAAA,EAAmB,mBAAAC,MAAuB,kBAEnD,OAAS,YAAAC,MAAgB,aAEzB,SAAS,WAAY,IAAM,CACzB,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,4CAA6C,SAAY,CAC1D,MAAMC,EAAM,MAAMF,EAAS,SAAS,EAC9BG,EAAK,IAAI,WAAWL,CAAiB,EAAE,KAAK,CAAI,EAChDM,EAAgB,MAAMF,EAAI,QAAQC,EAAIF,CAAQ,EAC9CI,EAAgB,MAAMH,EAAI,QAAQC,EAAIC,CAAa,EAEzD,OAAOA,CAAa,EAAE,IAAI,QAAQH,CAAQ,EAC1C,OAAOI,CAAa,EAAE,QAAQJ,CAAQ,CACxC,CAAC,EAED,GAAG,oDAAqD,SAAY,CAClE,MAAMK,EAAc,IAAI,WAAWP,CAAe,EAAE,KAAK,CAAI,EACvDG,EAAMF,EAAS,KAAKM,CAAW,EAC/BH,EAAK,IAAI,WAAWL,CAAiB,EAAE,KAAK,CAAI,EAChDM,EAAgB,MAAMF,EAAI,QAAQC,EAAIF,CAAQ,EAC9CI,EAAgB,MAAMH,EAAI,QAAQC,EAAIC,CAAa,EAEzD,OAAOA,CAAa,EAAE,IAAI,QAAQH,CAAQ,EAC1C,OAAOI,CAAa,EAAE,QAAQJ,CAAQ,CACxC,CAAC,CACH,CAAC",
-  "names": ["AES256_BLOCK_SIZE", "AES256_KEY_SIZE", "NobleKey", "testData", "key", "iv", "encryptedData", "decryptedData", "keyMaterial"]
-}

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

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

package/lib/esm/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  async sign(data: Uint8Array, format?: SigFormat): Promise<Uint8Array> {\n    return this.curve\n      .sign(data, this.privateKey)\n      .toBytes(format === SigFormat.DER ? \"der\" : \"compact\");\n  }\n\n  async verify(\n    data: Uint8Array,\n    signature: Uint8Array,\n    format?: SigFormat,\n  ): Promise<boolean> {\n    return this.curve.verify(signature, data, this.publicKey, {\n      format: format === SigFormat.DER ? \"der\" : \"compact\",\n    });\n  }\n\n  async deriveSharedSecret(\n    peerPublicKey: Uint8Array,\n    isCompressed: boolean = true,\n  ): Promise<Uint8Array> {\n    return this.curve.getSharedSecret(\n      this.privateKey,\n      peerPublicKey,\n      isCompressed,\n    );\n  }\n\n  getPublicKey(): Uint8Array {\n    return this.publicKey;\n  }\n\n  getPublicKeyToHex(): string {\n    return bufferToHexaString(this.publicKey, false);\n  }\n}\n"],
-  "mappings": "AAAA,OAAS,sBAAAA,MAA0B,kCAEnC,OAAS,QAAAC,MAAY,wBACrB,OAAS,aAAAC,MAAiB,6BAE1B,OAAS,SAAAC,MAAa,4BACtB,OAAuB,aAAAC,MAAiB,sBAEjC,MAAMC,CAAgC,CAwBnC,YACEC,EACAC,EACAC,EACR,CAHQ,WAAAF,EACA,gBAAAC,EACA,eAAAC,CACP,CA3BH,aAAa,SAASF,EAAqC,CACzD,MAAMG,EAAYJ,EAAa,SAASC,CAAK,EACvC,CAAE,UAAAI,EAAW,UAAAF,CAAU,EAAIC,EAAU,OAAO,EAClD,OAAO,IAAIJ,EAAaI,EAAWC,EAAWF,CAAS,CACzD,CAEA,OAAO,KAAKD,EAAwBD,EAA4B,CAC9D,MAAMG,EAAYJ,EAAa,SAASC,CAAK,EACvCE,EAAYC,EAAU,aAAaF,CAAU,EACnD,OAAO,IAAIF,EAAaI,EAAWF,EAAYC,CAAS,CAC1D,CAEA,OAAe,SAASF,EAAuB,CAC7C,OAAQA,EAAO,CACb,KAAKH,EAAM,KACT,OAAOD,EACT,KAAKC,EAAM,KACT,OAAOF,EACT,QACE,MAAM,IAAI,MAAM,qBAAqBK,CAAK,EAAE,CAChD,CACF,CAQA,MAAM,KAAKK,EAAkBC,EAAyC,CACpE,OAAO,KAAK,MACT,KAAKD,EAAM,KAAK,UAAU,EAC1B,QAAQC,IAAWR,EAAU,IAAM,MAAQ,SAAS,CACzD,CAEA,MAAM,OACJO,EACAE,EACAD,EACkB,CAClB,OAAO,KAAK,MAAM,OAAOC,EAAWF,EAAM,KAAK,UAAW,CACxD,OAAQC,IAAWR,EAAU,IAAM,MAAQ,SAC7C,CAAC,CACH,CAEA,MAAM,mBACJU,EACAC,EAAwB,GACH,CACrB,OAAO,KAAK,MAAM,gBAChB,KAAK,WACLD,EACAC,CACF,CACF,CAEA,cAA2B,CACzB,OAAO,KAAK,SACd,CAEA,mBAA4B,CAC1B,OAAOf,EAAmB,KAAK,UAAW,EAAK,CACjD,CACF",
-  "names": ["bufferToHexaString", "p256", "secp256k1", "Curve", "SigFormat", "NobleKeyPair", "curve", "privateKey", "publicKey", "curveImpl", "secretKey", "data", "format", "signature", "peerPublicKey", "isCompressed"]
-}

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

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

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

@@ -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,OAAS,SAAAA,MAAa,4BACtB,OAAS,aAAAC,MAAiB,sBAE1B,OAAS,gBAAAC,MAAoB,iBAE7B,SAAS,eAAgB,IAAM,CAC7B,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,qDAAsD,SAAY,CAEnE,MAAMC,GADU,MAAMF,EAAa,SAASF,EAAM,IAAI,GAC5B,aAAa,EACvC,OAAOI,CAAS,EAAE,YAAY,EAC9B,OAAOA,EAAU,UAAU,EAAE,gBAAgB,CAAC,CAChD,CAAC,EAED,GAAG,8CAA+C,IAAM,CACtD,MAAMC,EAAa,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACtCC,EAAUJ,EAAa,KAAKG,EAAYL,EAAM,IAAI,EACxD,OAAOM,EAAQ,aAAa,CAAC,EAAE,YAAY,CAC7C,CAAC,EAED,GAAG,wCAAyC,SAAY,CACtD,MAAMA,EAAU,MAAMJ,EAAa,SAASF,EAAM,IAAI,EAChDO,EAAY,MAAMD,EAAQ,KAAKH,CAAQ,EACvCK,EAAa,MAAMF,EAAQ,OAAOH,EAAUI,CAAS,EAC3D,OAAOC,CAAU,EAAE,WAAW,CAChC,CAAC,EAED,GAAG,uDAAwD,SAAY,CACrE,MAAMF,EAAU,MAAMJ,EAAa,SAASF,EAAM,IAAI,EAChDO,EAAY,MAAMD,EAAQ,KAAKH,EAAUF,EAAU,GAAG,EACtDO,EAAa,MAAMF,EAAQ,OAAOH,EAAUI,EAAWN,EAAU,GAAG,EAC1E,OAAOO,CAAU,EAAE,WAAW,CAChC,CAAC,EAED,GAAG,wDAAyD,SAAY,CACtE,MAAMF,EAAU,MAAMJ,EAAa,SAASF,EAAM,IAAI,EAChDS,EAAe,MAAMP,EAAa,SAASF,EAAM,IAAI,EACrDU,EAAgB,MAAMJ,EAAQ,mBAClCG,EAAa,aAAa,CAC5B,EACME,EAAgB,MAAMF,EAAa,mBACvCH,EAAQ,aAAa,CACvB,EAEA,OAAOI,CAAa,EAAE,YAAY,EAClC,OAAOA,EAAc,UAAU,EAAE,gBAAgB,CAAC,EAClD,OAAOA,CAAa,EAAE,cAAcC,CAAa,CACnD,CAAC,EAED,GAAG,0CAA2C,SAAY,CAExD,MAAMC,GADU,MAAMV,EAAa,SAASF,EAAM,IAAI,GACzB,kBAAkB,EAC/C,OAAO,OAAOY,CAAY,EAAE,KAAK,QAAQ,EACzC,OAAOA,EAAa,MAAM,EAAE,gBAAgB,CAAC,CAC/C,CAAC,CACH,CAAC",
-  "names": ["Curve", "SigFormat", "NobleKeyPair", "testData", "publicKey", "privateKey", "keyPair", "signature", "isVerified", "otherKeyPair", "sharedSecret1", "sharedSecret2", "hexPublicKey"]
-}

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

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

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

@@ -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": "AAAO,IAAKA,OACVA,EAAA,KAAO,OACPA,EAAA,QAAU,UAFAA,OAAA",
-  "names": ["LKRPEnv"]
-}

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

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

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

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

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

@@ -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": "AAGO,IAAKA,OACVA,IAAA,MAAQ,YAAR,QACAA,IAAA,YAAc,GAAd,cACAA,IAAA,WAAa,GAAb,aACAA,IAAA,cAAgB,GAAhB,gBAJUA,OAAA",
-  "names": ["Permissions"]
-}

package/lib/types/api/crypto/CryptoService.d.ts

@@ -1,22 +0,0 @@
-import { type Key } from "./Key";
-import { type KeyPair } from "./KeyPair";
-export declare enum Curve {
-    K256 = 0,// secp256k1
-    P256 = 1
-}
-export declare enum EncryptionAlgo {
-    AES256_GCM = 0
-}
-export declare enum HashAlgo {
-    SHA256 = 0
-}
-export interface CryptoService {
-    randomBytes(len: number): Uint8Array;
-    hash(bytes: Uint8Array, algo: HashAlgo): Uint8Array;
-    hmac(key: Uint8Array, message: Uint8Array, algo: HashAlgo): Uint8Array;
-    createKeyPair(curve: Curve): Promise<KeyPair>;
-    importKeyPair(privateKey: Uint8Array, curve: Curve): KeyPair;
-    createSymmetricKey(algo: EncryptionAlgo): Promise<Key>;
-    importSymmetricKey(keyMaterial: Uint8Array, algo: EncryptionAlgo): Key;
-}
-//# sourceMappingURL=CryptoService.d.ts.map

package/lib/types/api/crypto/CryptoService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CryptoService.d.ts","sourceRoot":"","sources":["../../../../src/api/crypto/CryptoService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,OAAO,CAAC;AACjC,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,oBAAY,KAAK;IACf,IAAI,IAAA,CAAE,YAAY;IAClB,IAAI,IAAA;CACL;AAED,oBAAY,cAAc;IACxB,UAAU,IAAA;CACX;AAED,oBAAY,QAAQ;IAClB,MAAM,IAAA;CACP;AAED,MAAM,WAAW,aAAa;IAE5B,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAGrC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAGpD,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAGvE,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAG9C,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAG7D,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAGvD,kBAAkB,CAAC,WAAW,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,GAAG,GAAG,CAAC;CACxE"}

package/lib/types/api/crypto/Key.d.ts

@@ -1,7 +0,0 @@
-export declare const AES256_KEY_SIZE = 32;
-export declare const AES256_BLOCK_SIZE = 16;
-export interface Key {
-    encrypt(iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
-    decrypt(iv: Uint8Array, encryptedData: Uint8Array): Promise<Uint8Array>;
-}
-//# sourceMappingURL=Key.d.ts.map

package/lib/types/api/crypto/Key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Key.d.ts","sourceRoot":"","sources":["../../../../src/api/crypto/Key.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,MAAM,WAAW,GAAG;IAClB,OAAO,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/D,OAAO,CAAC,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACzE"}

package/lib/types/api/crypto/KeyPair.d.ts

@@ -1,12 +0,0 @@
-export declare enum SigFormat {
-    COMPACT = 0,
-    DER = 1
-}
-export interface KeyPair {
-    sign(data: Uint8Array, format?: SigFormat): Promise<Uint8Array>;
-    verify(data: Uint8Array, signature: Uint8Array, format?: SigFormat): Promise<boolean>;
-    deriveSharedSecret(peerPublicKey: Uint8Array): Promise<Uint8Array>;
-    getPublicKey(): Uint8Array;
-    getPublicKeyToHex(): string;
-}
-//# sourceMappingURL=KeyPair.d.ts.map

package/lib/types/api/crypto/KeyPair.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"KeyPair.d.ts","sourceRoot":"","sources":["../../../../src/api/crypto/KeyPair.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACnB,OAAO,IAAA;IACP,GAAG,IAAA;CACJ;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAChE,MAAM,CACJ,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,SAAS,GACjB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,kBAAkB,CAAC,aAAa,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACnE,YAAY,IAAI,UAAU,CAAC;IAC3B,iBAAiB,IAAI,MAAM,CAAC;CAC7B"}

package/lib/types/api/crypto/noble/NobleCryptoService.d.ts

@@ -1,13 +0,0 @@
-import { type CryptoService, type Curve, type EncryptionAlgo, HashAlgo } from "../../crypto/CryptoService";
-import { type Key } from "../../crypto/Key";
-import { type KeyPair } from "../../crypto/KeyPair";
-export declare class NobleCryptoService implements CryptoService {
-    randomBytes(len: number): Uint8Array;
-    hash(bytes: Uint8Array, algo: HashAlgo): Uint8Array;
-    hmac(key: Uint8Array, message: Uint8Array, algo: HashAlgo): Uint8Array;
-    createKeyPair(curve: Curve): Promise<KeyPair>;
-    importKeyPair(privateKey: Uint8Array, curve: Curve): KeyPair;
-    createSymmetricKey(algo: EncryptionAlgo): Promise<Key>;
-    importSymmetricKey(keyMaterial: Uint8Array, algo: EncryptionAlgo): Key;
-}
-//# sourceMappingURL=NobleCryptoService.d.ts.map

package/lib/types/api/crypto/noble/NobleCryptoService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NobleCryptoService.d.ts","sourceRoot":"","sources":["../../../../../src/api/crypto/noble/NobleCryptoService.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,KAAK,EACV,KAAK,cAAc,EACnB,QAAQ,EACT,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAKnD,qBAAa,kBAAmB,YAAW,aAAa;IACtD,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAIpC,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,UAAU;IASnD,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,UAAU;IAShE,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC;IAInD,aAAa,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO;IAItD,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,CAAC;IAI5D,kBAAkB,CAAC,WAAW,EAAE,UAAU,EAAE,IAAI,EAAE,cAAc,GAAG,GAAG;CAGvE"}

package/lib/types/api/crypto/noble/NobleCryptoService.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=NobleCryptoService.test.d.ts.map

package/lib/types/api/crypto/noble/NobleCryptoService.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NobleCryptoService.test.d.ts","sourceRoot":"","sources":["../../../../../src/api/crypto/noble/NobleCryptoService.test.ts"],"names":[],"mappings":""}

package/lib/types/api/crypto/noble/NobleKey.d.ts

@@ -1,11 +0,0 @@
-import { EncryptionAlgo } from "../../crypto/CryptoService";
-import { type Key } from "../../crypto/Key";
-export declare class NobleKey implements Key {
-    private key;
-    static generate(algo?: EncryptionAlgo): Promise<NobleKey>;
-    static from(keyMaterial: Uint8Array, algo?: EncryptionAlgo): NobleKey;
-    private constructor();
-    encrypt(iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
-    decrypt(iv: Uint8Array, encryptedData: Uint8Array): Promise<Uint8Array>;
-}
-//# sourceMappingURL=NobleKey.d.ts.map

package/lib/types/api/crypto/noble/NobleKey.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NobleKey.d.ts","sourceRoot":"","sources":["../../../../../src/api/crypto/noble/NobleKey.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAsC,KAAK,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAE/E,qBAAa,QAAS,YAAW,GAAG;IAoBd,OAAO,CAAC,GAAG;WAnBlB,QAAQ,CACnB,IAAI,GAAE,cAA0C,GAC/C,OAAO,CAAC,QAAQ,CAAC;IAOpB,MAAM,CAAC,IAAI,CACT,WAAW,EAAE,UAAU,EACvB,IAAI,GAAE,cAA0C,GAC/C,QAAQ;IAOX,OAAO;IAED,OAAO,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAK9D,OAAO,CACX,EAAE,EAAE,UAAU,EACd,aAAa,EAAE,UAAU,GACxB,OAAO,CAAC,UAAU,CAAC;CAIvB"}

package/lib/types/api/crypto/noble/NobleKey.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=NobleKey.test.d.ts.map

package/lib/types/api/crypto/noble/NobleKey.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NobleKey.test.d.ts","sourceRoot":"","sources":["../../../../../src/api/crypto/noble/NobleKey.test.ts"],"names":[],"mappings":""}