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

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

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

Files changed (467) hide show

package/lib/cjs/internal/lkrp-datasource/data/HttpLKRPDataSource.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var o=require("purify-ts"),l=require("../../../api/model/Errors"),h=require("../../utils/LKRPBlock"),m=require("../../utils/Trustchain"),c=require("./HttpLKRPDataSource");const r={access_token:"ACCESS TOKEN",permissions:{TRUSTCHAIN_ID:{"m/":["owner"]}}},i={version:0,challenge:{data:"1010101010010101010",expiry:"2025-06-30T10:00:00Z"},host:"example.com",rp:[{credential:{version:0,curveId:33,signAlgorithm:1,publicKey:"aaaaaaaaaaaaaaaaaaaaaaaaaa"},signature:"abababababababab"}],protocolVersion:{major:1,minor:0,patch:0}},u={credential:{version:0,curveId:33,signAlgorithm:1,publicKey:"bbbbbbbbbbbbbbbbbbbbbbbbbbb"},signature:"acacacacacacacac",attestation:"0000000000000000"};describe("HttpLKRPDataSource",()=>{const a=vi.spyOn(global,"fetch"),t="https://example.com";afterEach(()=>{a.mockClear()}),describe("getChallenge",()=>{it("should fetch challenge successfully",async()=>{const e={tlv:"0f1234567890",json:i};a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(e)});const n=await new c.HttpLKRPDataSource(t).getChallenge();expect(a).toHaveBeenCalledWith(`${t}/challenge`,{headers:{"Content-Type":"application/json"}}),expect(n).toEqual((0,o.Right)(e))}),it("should handle fetch error",async()=>{const e={status:"UNKNOWN",message:"Random error"};a.mockRejectedValueOnce(e);const n=await new c.HttpLKRPDataSource(t).getChallenge();expect(n).toEqual((0,o.Left)(new l.LKRPDataSourceError({status:"UNKNOWN",message:`Random error (from: ${t}/challenge)`})))})}),describe("authenticate",()=>{it("should fetch a JWT when the authentication is successful",async()=>{a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(r)});const s=await new c.HttpLKRPDataSource(t).authenticate({challenge:i,signature:u});expect(a).toHaveBeenCalledWith(`${t}/authenticate`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({challenge:i,signature:u})}),expect(s).toEqual((0,o.Right)({jwt:r,trustchainId:(0,o.Just)("TRUSTCHAIN_ID")}))}),it("should return no trustchainId the returned JWT does not contain one",async()=>{const e={access_token:"ACCESS TOKEN",permissions:{}};a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(e)});const n=await new c.HttpLKRPDataSource(t).authenticate({challenge:i,signature:u});expect(n).toEqual((0,o.Right)({jwt:e,trustchainId:o.Nothing}))}),it("should handle authentication error",async()=>{a.mockResolvedValueOnce({ok:!1,status:401,statusText:"Unauthorized",json:()=>Promise.resolve({message:"Unauthorized access"})});const s=await new c.HttpLKRPDataSource(t).authenticate({challenge:i,signature:u});expect(s).toEqual((0,o.Left)(new l.LKRPDataSourceError({status:"UNAUTHORIZED",message:`[401] Unauthorized access (from: ${t}/authenticate)`})))})}),describe("getTrustchainById",()=>{it("should fetch trustchain by ID successfully",async()=>{const e={"m/":"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d","m/16'":"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b"};a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(e)});const n=await new c.HttpLKRPDataSource(t).getTrustchainById("TRUSTCHAIN_ID",r);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID`,{headers:{"Content-Type":"application/json",Authorization:`Bearer ${r.access_token}`}}),expect(n).toEqual((0,o.Right)(new m.Trustchain("TRUSTCHAIN_ID",e)))}),it("should handle errors",async()=>{a.mockResolvedValueOnce({ok:!1,status:500,statusText:"Internal Server Error",json:()=>Promise.resolve({})});const s=await new c.HttpLKRPDataSource(t).getTrustchainById("TRUSTCHAIN_ID",r);expect(s).toEqual((0,o.Left)(new l.LKRPDataSourceError({status:"UNKNOWN",message:`[500] Internal Server Error (from: ${t}/trustchain/TRUSTCHAIN_ID)`})))})}),describe("postDerivation",()=>{it("should post derivation successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",s=h.LKRPBlock.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const d=await new c.HttpLKRPDataSource(t).postDerivation("TRUSTCHAIN_ID",s,r);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/derivation`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${r.access_token}`},body:JSON.stringify(e)}),expect(d).toEqual((0,o.Right)(void 0))})}),describe("putCommands",()=>{it("should put commands successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",s=h.LKRPBlock.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const d=await new c.HttpLKRPDataSource(t).putCommands("TRUSTCHAIN_ID","m/0'/16'/0'",s,r);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/commands`,{method:"PUT",headers:{"Content-Type":"application/json",Authorization:`Bearer ${r.access_token}`},body:JSON.stringify({path:"m/0'/16'/0'",blocks:[e]})}),expect(d).toEqual((0,o.Right)(void 0))})})});
+"use strict";var o=require("purify-ts"),l=require("../../../api/app-binder/Errors"),h=require("../../utils/LKRPBlock"),m=require("../../utils/Trustchain"),c=require("./HttpLKRPDataSource");const r={access_token:"ACCESS TOKEN",permissions:{TRUSTCHAIN_ID:{"m/":["owner"]}}},i={version:0,challenge:{data:"1010101010010101010",expiry:"2025-06-30T10:00:00Z"},host:"example.com",rp:[{credential:{version:0,curveId:33,signAlgorithm:1,publicKey:"aaaaaaaaaaaaaaaaaaaaaaaaaa"},signature:"abababababababab"}],protocolVersion:{major:1,minor:0,patch:0}},u={credential:{version:0,curveId:33,signAlgorithm:1,publicKey:"bbbbbbbbbbbbbbbbbbbbbbbbbbb"},signature:"acacacacacacacac",attestation:"0000000000000000"};describe("HttpLKRPDataSource",()=>{const a=vi.spyOn(global,"fetch"),t="https://example.com";afterEach(()=>{a.mockClear()}),describe("getChallenge",()=>{it("should fetch challenge successfully",async()=>{const e={tlv:"0f1234567890",json:i};a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(e)});const n=await new c.HttpLKRPDataSource(t).getChallenge();expect(a).toHaveBeenCalledWith(`${t}/challenge`,{headers:{"Content-Type":"application/json"}}),expect(n).toEqual((0,o.Right)(e))}),it("should handle fetch error",async()=>{const e={status:"UNKNOWN",message:"Random error"};a.mockRejectedValueOnce(e);const n=await new c.HttpLKRPDataSource(t).getChallenge();expect(n).toEqual((0,o.Left)(new l.LKRPDataSourceError({status:"UNKNOWN",message:`Random error (from: ${t}/challenge)`})))})}),describe("authenticate",()=>{it("should fetch a JWT when the authentication is successful",async()=>{a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(r)});const s=await new c.HttpLKRPDataSource(t).authenticate({challenge:i,signature:u});expect(a).toHaveBeenCalledWith(`${t}/authenticate`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({challenge:i,signature:u})}),expect(s).toEqual((0,o.Right)({jwt:r,trustchainId:(0,o.Just)("TRUSTCHAIN_ID")}))}),it("should return no trustchainId the returned JWT does not contain one",async()=>{const e={access_token:"ACCESS TOKEN",permissions:{}};a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(e)});const n=await new c.HttpLKRPDataSource(t).authenticate({challenge:i,signature:u});expect(n).toEqual((0,o.Right)({jwt:e,trustchainId:o.Nothing}))}),it("should handle authentication error",async()=>{a.mockResolvedValueOnce({ok:!1,status:401,statusText:"Unauthorized",json:()=>Promise.resolve({message:"Unauthorized access"})});const s=await new c.HttpLKRPDataSource(t).authenticate({challenge:i,signature:u});expect(s).toEqual((0,o.Left)(new l.LKRPDataSourceError({status:"UNAUTHORIZED",message:`[401] Unauthorized access (from: ${t}/authenticate)`})))})}),describe("getTrustchainById",()=>{it("should fetch trustchain by ID successfully",async()=>{const e={"m/":"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d","m/16'":"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b"};a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(e)});const n=await new c.HttpLKRPDataSource(t).getTrustchainById("TRUSTCHAIN_ID",r);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID`,{headers:{"Content-Type":"application/json",Authorization:`Bearer ${r.access_token}`}}),expect(n).toEqual((0,o.Right)(new m.Trustchain("TRUSTCHAIN_ID",e)))}),it("should handle errors",async()=>{a.mockResolvedValueOnce({ok:!1,status:500,statusText:"Internal Server Error",json:()=>Promise.resolve({})});const s=await new c.HttpLKRPDataSource(t).getTrustchainById("TRUSTCHAIN_ID",r);expect(s).toEqual((0,o.Left)(new l.LKRPDataSourceError({status:"UNKNOWN",message:`[500] Internal Server Error (from: ${t}/trustchain/TRUSTCHAIN_ID)`})))})}),describe("postDerivation",()=>{it("should post derivation successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",s=h.LKRPBlock.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const d=await new c.HttpLKRPDataSource(t).postDerivation("TRUSTCHAIN_ID",s,r);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/derivation`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${r.access_token}`},body:JSON.stringify(e)}),expect(d).toEqual((0,o.Right)(void 0))})}),describe("putCommands",()=>{it("should put commands successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",s=h.LKRPBlock.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const d=await new c.HttpLKRPDataSource(t).putCommands("TRUSTCHAIN_ID","m/0'/16'/0'",s,r);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/commands`,{method:"PUT",headers:{"Content-Type":"application/json",Authorization:`Bearer ${r.access_token}`},body:JSON.stringify({path:"m/0'/16'/0'",blocks:[e]})}),expect(d).toEqual((0,o.Right)(void 0))})})});
 //# sourceMappingURL=HttpLKRPDataSource.test.js.map

package/lib/cjs/internal/lkrp-datasource/data/HttpLKRPDataSource.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/lkrp-datasource/data/HttpLKRPDataSource.test.ts"],
-  "sourcesContent": ["import { Just, Left, Nothing, Right } from \"purify-ts\";\n\nimport { LKRPDataSourceError } from \"@api/model/Errors\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { Trustchain } from \"@internal/utils/Trustchain\";\n\nimport { HttpLKRPDataSource } from \"./HttpLKRPDataSource\";\n\nconst mockJwt = {\n  access_token: \"ACCESS TOKEN\",\n  permissions: { TRUSTCHAIN_ID: { \"m/\": [\"owner\"] } },\n};\n\nconst mockChallengeJSON = {\n  version: 0,\n  challenge: {\n    data: \"1010101010010101010\",\n    expiry: \"2025-06-30T10:00:00Z\",\n  },\n  host: \"example.com\",\n  rp: [\n    {\n      credential: {\n        version: 0,\n        curveId: 33,\n        signAlgorithm: 1,\n        publicKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaa\",\n      },\n      signature: \"abababababababab\",\n    },\n  ],\n  protocolVersion: { major: 1, minor: 0, patch: 0 },\n};\n\nconst mockSignature = {\n  credential: {\n    version: 0,\n    curveId: 33,\n    signAlgorithm: 1,\n    publicKey: \"bbbbbbbbbbbbbbbbbbbbbbbbbbb\",\n  },\n  signature: \"acacacacacacacac\",\n  attestation: \"0000000000000000\",\n};\n\ndescribe(\"HttpLKRPDataSource\", () => {\n  const fetchSpy = vi.spyOn(global, \"fetch\");\n  const baseUrl = \"https://example.com\";\n\n  afterEach(() => {\n    fetchSpy.mockClear();\n  });\n\n  describe(\"getChallenge\", () => {\n    it(\"should fetch challenge successfully\", async () => {\n      // GIVEN\n      const mockChallenge = {\n        tlv: \"0f1234567890\",\n        json: mockChallengeJSON,\n      };\n\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockChallenge),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getChallenge();\n      expect(fetchSpy).toHaveBeenCalledWith(`${baseUrl}/challenge`, {\n        headers: {\n          \"Content-Type\": \"application/json\",\n        },\n      });\n\n      // THEN\n      expect(result).toEqual(Right(mockChallenge));\n    });\n\n    it(\"should handle fetch error\", async () => {\n      // GIVEN\n      const error = { status: \"UNKNOWN\", message: \"Random error\" } as const;\n      fetchSpy.mockRejectedValueOnce(error);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getChallenge();\n\n      // THEN\n      expect(result).toEqual(\n        Left(\n          new LKRPDataSourceError({\n            status: \"UNKNOWN\",\n            message: `Random error (from: ${baseUrl}/challenge)`,\n          }),\n        ),\n      );\n    });\n  });\n\n  describe(\"authenticate\", () => {\n    it(\"should fetch a JWT when the authentication is successful\", async () => {\n      // GIVEN\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockJwt),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.authenticate({\n        challenge: mockChallengeJSON,\n        signature: mockSignature,\n      });\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(`${baseUrl}/authenticate`, {\n        method: \"POST\",\n        headers: {\n          \"Content-Type\": \"application/json\",\n        },\n        body: JSON.stringify({\n          challenge: mockChallengeJSON,\n          signature: mockSignature,\n        }),\n      });\n      expect(result).toEqual(\n        Right({ jwt: mockJwt, trustchainId: Just(\"TRUSTCHAIN_ID\") }),\n      );\n    });\n\n    it(\"should return no trustchainId the returned JWT does not contain one\", async () => {\n      // GIVEN\n      const jwtWithoutTrustchainId = {\n        access_token: \"ACCESS TOKEN\",\n        permissions: {},\n      };\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(jwtWithoutTrustchainId),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.authenticate({\n        challenge: mockChallengeJSON,\n        signature: mockSignature,\n      });\n\n      // THEN\n      expect(result).toEqual(\n        Right({ jwt: jwtWithoutTrustchainId, trustchainId: Nothing }),\n      );\n    });\n\n    it(\"should handle authentication error\", async () => {\n      // GIVEN\n      fetchSpy.mockResolvedValueOnce({\n        ok: false,\n        status: 401,\n        statusText: \"Unauthorized\",\n        json: () => Promise.resolve({ message: \"Unauthorized access\" }),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.authenticate({\n        challenge: mockChallengeJSON,\n        signature: mockSignature,\n      });\n\n      // THEN\n      expect(result).toEqual(\n        Left(\n          new LKRPDataSourceError({\n            status: \"UNAUTHORIZED\",\n            message: `[401] Unauthorized access (from: ${baseUrl}/authenticate)`,\n          }),\n        ),\n      );\n    });\n  });\n\n  describe(\"getTrustchainById\", () => {\n    it(\"should fetch trustchain by ID successfully\", async () => {\n      // GIVEN\n      const mockTrustchainData = {\n        \"m/\": \"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d\",\n        \"m/16'\": \"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b\",\n      };\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockTrustchainData),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getTrustchainById(\n        \"TRUSTCHAIN_ID\",\n        mockJwt,\n      );\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(\n        `${baseUrl}/trustchain/TRUSTCHAIN_ID`,\n        {\n          headers: {\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${mockJwt.access_token}`,\n          },\n        },\n      );\n      expect(result).toEqual(\n        Right(new Trustchain(\"TRUSTCHAIN_ID\", mockTrustchainData)),\n      );\n    });\n\n    it(\"should handle errors\", async () => {\n      // GIVEN\n      fetchSpy.mockResolvedValueOnce({\n        ok: false,\n        status: 500,\n        statusText: \"Internal Server Error\",\n        json: () => Promise.resolve({}),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getTrustchainById(\n        \"TRUSTCHAIN_ID\",\n        mockJwt,\n      );\n\n      // THEN\n      expect(result).toEqual(\n        Left(\n          new LKRPDataSourceError({\n            status: \"UNKNOWN\",\n            message: `[500] Internal Server Error (from: ${baseUrl}/trustchain/TRUSTCHAIN_ID)`,\n          }),\n        ),\n      );\n    });\n  });\n\n  describe(\"postDerivation\", () => {\n    it(\"should post derivation successfully\", async () => {\n      // GIVEN\n      const hex = \"0102030405060708090a0b0c0d0e0f\";\n      const mockBlock = LKRPBlock.fromHex(hex);\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        status: 204,\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.postDerivation(\n        \"TRUSTCHAIN_ID\",\n        mockBlock,\n        mockJwt,\n      );\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(\n        `${baseUrl}/trustchain/TRUSTCHAIN_ID/derivation`,\n        {\n          method: \"POST\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${mockJwt.access_token}`,\n          },\n          body: JSON.stringify(hex),\n        },\n      );\n      expect(result).toEqual(Right(undefined));\n    });\n  });\n\n  describe(\"putCommands\", () => {\n    it(\"should put commands successfully\", async () => {\n      // GIVEN\n      const hex = \"0102030405060708090a0b0c0d0e0f\";\n      const mockBlock = LKRPBlock.fromHex(hex);\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        status: 204,\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.putCommands(\n        \"TRUSTCHAIN_ID\",\n        \"m/0'/16'/0'\",\n        mockBlock,\n        mockJwt,\n      );\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(\n        `${baseUrl}/trustchain/TRUSTCHAIN_ID/commands`,\n        {\n          method: \"PUT\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${mockJwt.access_token}`,\n          },\n          body: JSON.stringify({ path: \"m/0'/16'/0'\", blocks: [hex] }),\n        },\n      );\n      expect(result).toEqual(Right(undefined));\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { Just, Left, Nothing, Right } from \"purify-ts\";\n\nimport { LKRPDataSourceError } from \"@api/app-binder/Errors\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { Trustchain } from \"@internal/utils/Trustchain\";\n\nimport { HttpLKRPDataSource } from \"./HttpLKRPDataSource\";\n\nconst mockJwt = {\n  access_token: \"ACCESS TOKEN\",\n  permissions: { TRUSTCHAIN_ID: { \"m/\": [\"owner\"] } },\n};\n\nconst mockChallengeJSON = {\n  version: 0,\n  challenge: {\n    data: \"1010101010010101010\",\n    expiry: \"2025-06-30T10:00:00Z\",\n  },\n  host: \"example.com\",\n  rp: [\n    {\n      credential: {\n        version: 0,\n        curveId: 33,\n        signAlgorithm: 1,\n        publicKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaa\",\n      },\n      signature: \"abababababababab\",\n    },\n  ],\n  protocolVersion: { major: 1, minor: 0, patch: 0 },\n};\n\nconst mockSignature = {\n  credential: {\n    version: 0,\n    curveId: 33,\n    signAlgorithm: 1,\n    publicKey: \"bbbbbbbbbbbbbbbbbbbbbbbbbbb\",\n  },\n  signature: \"acacacacacacacac\",\n  attestation: \"0000000000000000\",\n};\n\ndescribe(\"HttpLKRPDataSource\", () => {\n  const fetchSpy = vi.spyOn(global, \"fetch\");\n  const baseUrl = \"https://example.com\";\n\n  afterEach(() => {\n    fetchSpy.mockClear();\n  });\n\n  describe(\"getChallenge\", () => {\n    it(\"should fetch challenge successfully\", async () => {\n      // GIVEN\n      const mockChallenge = {\n        tlv: \"0f1234567890\",\n        json: mockChallengeJSON,\n      };\n\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockChallenge),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getChallenge();\n      expect(fetchSpy).toHaveBeenCalledWith(`${baseUrl}/challenge`, {\n        headers: {\n          \"Content-Type\": \"application/json\",\n        },\n      });\n\n      // THEN\n      expect(result).toEqual(Right(mockChallenge));\n    });\n\n    it(\"should handle fetch error\", async () => {\n      // GIVEN\n      const error = { status: \"UNKNOWN\", message: \"Random error\" } as const;\n      fetchSpy.mockRejectedValueOnce(error);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getChallenge();\n\n      // THEN\n      expect(result).toEqual(\n        Left(\n          new LKRPDataSourceError({\n            status: \"UNKNOWN\",\n            message: `Random error (from: ${baseUrl}/challenge)`,\n          }),\n        ),\n      );\n    });\n  });\n\n  describe(\"authenticate\", () => {\n    it(\"should fetch a JWT when the authentication is successful\", async () => {\n      // GIVEN\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockJwt),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.authenticate({\n        challenge: mockChallengeJSON,\n        signature: mockSignature,\n      });\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(`${baseUrl}/authenticate`, {\n        method: \"POST\",\n        headers: {\n          \"Content-Type\": \"application/json\",\n        },\n        body: JSON.stringify({\n          challenge: mockChallengeJSON,\n          signature: mockSignature,\n        }),\n      });\n      expect(result).toEqual(\n        Right({ jwt: mockJwt, trustchainId: Just(\"TRUSTCHAIN_ID\") }),\n      );\n    });\n\n    it(\"should return no trustchainId the returned JWT does not contain one\", async () => {\n      // GIVEN\n      const jwtWithoutTrustchainId = {\n        access_token: \"ACCESS TOKEN\",\n        permissions: {},\n      };\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(jwtWithoutTrustchainId),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.authenticate({\n        challenge: mockChallengeJSON,\n        signature: mockSignature,\n      });\n\n      // THEN\n      expect(result).toEqual(\n        Right({ jwt: jwtWithoutTrustchainId, trustchainId: Nothing }),\n      );\n    });\n\n    it(\"should handle authentication error\", async () => {\n      // GIVEN\n      fetchSpy.mockResolvedValueOnce({\n        ok: false,\n        status: 401,\n        statusText: \"Unauthorized\",\n        json: () => Promise.resolve({ message: \"Unauthorized access\" }),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.authenticate({\n        challenge: mockChallengeJSON,\n        signature: mockSignature,\n      });\n\n      // THEN\n      expect(result).toEqual(\n        Left(\n          new LKRPDataSourceError({\n            status: \"UNAUTHORIZED\",\n            message: `[401] Unauthorized access (from: ${baseUrl}/authenticate)`,\n          }),\n        ),\n      );\n    });\n  });\n\n  describe(\"getTrustchainById\", () => {\n    it(\"should fetch trustchain by ID successfully\", async () => {\n      // GIVEN\n      const mockTrustchainData = {\n        \"m/\": \"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d\",\n        \"m/16'\": \"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b\",\n      };\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockTrustchainData),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getTrustchainById(\n        \"TRUSTCHAIN_ID\",\n        mockJwt,\n      );\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(\n        `${baseUrl}/trustchain/TRUSTCHAIN_ID`,\n        {\n          headers: {\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${mockJwt.access_token}`,\n          },\n        },\n      );\n      expect(result).toEqual(\n        Right(new Trustchain(\"TRUSTCHAIN_ID\", mockTrustchainData)),\n      );\n    });\n\n    it(\"should handle errors\", async () => {\n      // GIVEN\n      fetchSpy.mockResolvedValueOnce({\n        ok: false,\n        status: 500,\n        statusText: \"Internal Server Error\",\n        json: () => Promise.resolve({}),\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.getTrustchainById(\n        \"TRUSTCHAIN_ID\",\n        mockJwt,\n      );\n\n      // THEN\n      expect(result).toEqual(\n        Left(\n          new LKRPDataSourceError({\n            status: \"UNKNOWN\",\n            message: `[500] Internal Server Error (from: ${baseUrl}/trustchain/TRUSTCHAIN_ID)`,\n          }),\n        ),\n      );\n    });\n  });\n\n  describe(\"postDerivation\", () => {\n    it(\"should post derivation successfully\", async () => {\n      // GIVEN\n      const hex = \"0102030405060708090a0b0c0d0e0f\";\n      const mockBlock = LKRPBlock.fromHex(hex);\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        status: 204,\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.postDerivation(\n        \"TRUSTCHAIN_ID\",\n        mockBlock,\n        mockJwt,\n      );\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(\n        `${baseUrl}/trustchain/TRUSTCHAIN_ID/derivation`,\n        {\n          method: \"POST\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${mockJwt.access_token}`,\n          },\n          body: JSON.stringify(hex),\n        },\n      );\n      expect(result).toEqual(Right(undefined));\n    });\n  });\n\n  describe(\"putCommands\", () => {\n    it(\"should put commands successfully\", async () => {\n      // GIVEN\n      const hex = \"0102030405060708090a0b0c0d0e0f\";\n      const mockBlock = LKRPBlock.fromHex(hex);\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        status: 204,\n      } as Response);\n\n      // WHEN\n      const dataSource = new HttpLKRPDataSource(baseUrl);\n      const result = await dataSource.putCommands(\n        \"TRUSTCHAIN_ID\",\n        \"m/0'/16'/0'\",\n        mockBlock,\n        mockJwt,\n      );\n\n      // THEN\n      expect(fetchSpy).toHaveBeenCalledWith(\n        `${baseUrl}/trustchain/TRUSTCHAIN_ID/commands`,\n        {\n          method: \"PUT\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n            Authorization: `Bearer ${mockJwt.access_token}`,\n          },\n          body: JSON.stringify({ path: \"m/0'/16'/0'\", blocks: [hex] }),\n        },\n      );\n      expect(result).toEqual(Right(undefined));\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_purify_ts", "import_Errors", "import_LKRPBlock", "import_Trustchain", "import_HttpLKRPDataSource", "mockJwt", "mockChallengeJSON", "mockSignature", "fetchSpy", "baseUrl", "mockChallenge", "result", "error", "jwtWithoutTrustchainId", "mockTrustchainData", "hex", "mockBlock"]
 }

package/lib/cjs/internal/lkrp-datasource/data/LKRPDataSource.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/lkrp-datasource/data/LKRPDataSource.ts"],
-  "sourcesContent": ["import { type EitherAsync, type Maybe } from \"purify-ts\";\n\nimport { type LKRPDataSourceError } from \"@api/model/Errors\";\nimport { type JWT } from \"@api/model/JWT\";\nimport { type LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { type Trustchain } from \"@internal/utils/Trustchain\";\n\nexport interface LKRPDataSource {\n  getChallenge(): EitherAsync<LKRPDataSourceError, Challenge>;\n\n  authenticate(\n    payload: AuthenticationPayload,\n  ): EitherAsync<LKRPDataSourceError, AuthenticationResponse>;\n\n  getTrustchainById(\n    id: string,\n    jwt: JWT,\n  ): EitherAsync<LKRPDataSourceError, Trustchain>;\n\n  postDerivation(\n    id: string,\n    blocks: LKRPBlock,\n    jwt: JWT,\n  ): EitherAsync<LKRPDataSourceError, void>;\n\n  putCommands(\n    id: string,\n    path: string,\n    block: LKRPBlock,\n    jwt: JWT,\n  ): EitherAsync<LKRPDataSourceError, void>;\n}\n\nexport type Challenge = { json: ChallengeJSON; tlv: string };\n\nexport type AuthenticationResponse = {\n  jwt: JWT;\n  trustchainId: Maybe<string>;\n};\n\nexport type AuthenticationPayload = {\n  challenge: ChallengeJSON;\n  signature: ChallengeSignature;\n};\n\ntype ChallengeJSON = {\n  version: number;\n  challenge: {\n    data: string;\n    expiry: string;\n  };\n  host: string;\n  rp: { credential: Credential; signature: string }[];\n  protocolVersion: {\n    major: number;\n    minor: number;\n    patch: number;\n  };\n};\n\ntype ChallengeSignature = {\n  credential: Credential;\n  signature: string;\n  attestation: string;\n};\n\ntype Credential = {\n  version: number;\n  curveId: number;\n  signAlgorithm: number;\n  publicKey: string;\n};\n"],
+  "sourcesContent": ["import { type EitherAsync, type Maybe } from \"purify-ts\";\n\nimport { type LKRPDataSourceError } from \"@api/app-binder/Errors\";\nimport { type JWT } from \"@api/app-binder/LKRPTypes\";\nimport { type LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { type Trustchain } from \"@internal/utils/Trustchain\";\n\nexport interface LKRPDataSource {\n  getChallenge(): EitherAsync<LKRPDataSourceError, Challenge>;\n\n  authenticate(\n    payload: AuthenticationPayload,\n  ): EitherAsync<LKRPDataSourceError, AuthenticationResponse>;\n\n  getTrustchainById(\n    id: string,\n    jwt: JWT,\n  ): EitherAsync<LKRPDataSourceError, Trustchain>;\n\n  postDerivation(\n    id: string,\n    blocks: LKRPBlock,\n    jwt: JWT,\n  ): EitherAsync<LKRPDataSourceError, void>;\n\n  putCommands(\n    id: string,\n    path: string,\n    block: LKRPBlock,\n    jwt: JWT,\n  ): EitherAsync<LKRPDataSourceError, void>;\n}\n\nexport type Challenge = { json: ChallengeJSON; tlv: string };\n\nexport type AuthenticationResponse = {\n  jwt: JWT;\n  trustchainId: Maybe<string>;\n};\n\nexport type AuthenticationPayload = {\n  challenge: ChallengeJSON;\n  signature: ChallengeSignature;\n};\n\ntype ChallengeJSON = {\n  version: number;\n  challenge: {\n    data: string;\n    expiry: string;\n  };\n  host: string;\n  rp: { credential: Credential; signature: string }[];\n  protocolVersion: {\n    major: number;\n    minor: number;\n    patch: number;\n  };\n};\n\ntype ChallengeSignature = {\n  credential: Credential;\n  signature: string;\n  attestation: string;\n};\n\ntype Credential = {\n  version: number;\n  curveId: number;\n  signAlgorithm: number;\n  publicKey: string;\n};\n"],
   "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
   "names": ["LKRPDataSource_exports", "__toCommonJS"]
 }

package/lib/cjs/internal/use-cases/authentication/AuthenticateUseCase.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var s=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var v=Object.prototype.hasOwnProperty;var D=(r,e)=>{for(var i in e)s(r,i,{get:e[i],enumerable:!0})},l=(r,e,i,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of g(e))!v.call(r,t)&&t!==i&&s(r,t,{get:()=>e[t],enumerable:!(n=d(e,t))||n.enumerable});return r};var B=r=>l(s({},"__esModule",{value:!0}),r),m=(r,e,i,n)=>{for(var t=n>1?void 0:n?d(e,i):e,c=r.length-1,p;c>=0;c--)(p=r[c])&&(t=(n?p(e,i,t):p(t))||t);return n&&t&&s(e,i,t),t},u=(r,e)=>(i,n)=>e(i,n,r);var P={};D(P,{AuthenticateUseCase:()=>o});module.exports=B(P);var f=require("@ledgerhq/device-management-kit"),a=require("inversify"),h=require("rxjs"),I=require("../../../api/model/Errors"),y=require("../../app-binder/di/appBinderTypes");let o=class{constructor(e){this.appBinder=e}execute(e){if(e.trustchainId)return this.appBinder.authenticateWithKeypair(e);const i=e.sessionId;return i?this.appBinder.authenticateWithDevice({...e,sessionId:i}):{observable:(0,h.of)({status:f.DeviceActionStatus.Error,error:new I.LKRPMissingDataError("Either a trustchainId or a device is required for authentication.")}),cancel:()=>{}}}};o=m([(0,a.injectable)(),u(0,(0,a.inject)(y.appBinderTypes.AppBinding))],o);0&&(module.exports={AuthenticateUseCase});
+"use strict";var s=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var v=Object.prototype.hasOwnProperty;var D=(r,e)=>{for(var i in e)s(r,i,{get:e[i],enumerable:!0})},l=(r,e,i,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of g(e))!v.call(r,t)&&t!==i&&s(r,t,{get:()=>e[t],enumerable:!(n=d(e,t))||n.enumerable});return r};var B=r=>l(s({},"__esModule",{value:!0}),r),m=(r,e,i,n)=>{for(var t=n>1?void 0:n?d(e,i):e,c=r.length-1,p;c>=0;c--)(p=r[c])&&(t=(n?p(e,i,t):p(t))||t);return n&&t&&s(e,i,t),t},u=(r,e)=>(i,n)=>e(i,n,r);var K={};D(K,{AuthenticateUseCase:()=>o});module.exports=B(K);var f=require("@ledgerhq/device-management-kit"),a=require("inversify"),h=require("rxjs"),I=require("../../../api/app-binder/Errors"),y=require("../../app-binder/di/appBinderTypes");let o=class{constructor(e){this.appBinder=e}execute(e){if(e.trustchainId)return this.appBinder.authenticateWithKeypair(e);const i=e.sessionId;return i?this.appBinder.authenticateWithDevice({...e,sessionId:i}):{observable:(0,h.of)({status:f.DeviceActionStatus.Error,error:new I.LKRPMissingDataError("Either a trustchainId or a device is required for authentication.")}),cancel:()=>{}}}};o=m([(0,a.injectable)(),u(0,(0,a.inject)(y.appBinderTypes.AppBinding))],o);0&&(module.exports={AuthenticateUseCase});
 //# sourceMappingURL=AuthenticateUseCase.js.map

package/lib/cjs/internal/use-cases/authentication/AuthenticateUseCase.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/use-cases/authentication/AuthenticateUseCase.ts"],
-  "sourcesContent": ["import {\n  DeviceActionStatus,\n  DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { of } from \"rxjs\";\n\nimport { AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { KeyPair } from \"@api/crypto/KeyPair\";\nimport { LKRPMissingDataError } from \"@api/model/Errors\";\nimport { Permissions } from \"@api/model/Permissions\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { LedgerKeyringProtocolBinder } from \"@internal/app-binder/LedgerKeyringProtocolBinder\";\n\nexport type AuthenticateUsecaseInput = {\n  keypair: KeyPair;\n  clientName: string;\n  permissions: Permissions;\n} & (\n  | { trustchainId: string; sessionId?: DeviceSessionId }\n  | { trustchainId?: undefined; sessionId: DeviceSessionId }\n);\n\n@injectable()\nexport class AuthenticateUseCase {\n  constructor(\n    @inject(appBinderTypes.AppBinding)\n    private appBinder: LedgerKeyringProtocolBinder,\n  ) {}\n\n  execute(input: AuthenticateUsecaseInput): AuthenticateDAReturnType {\n    if (input.trustchainId) {\n      return this.appBinder.authenticateWithKeypair(input);\n    }\n\n    const sessionId = input.sessionId;\n    if (sessionId) {\n      return this.appBinder.authenticateWithDevice({ ...input, sessionId });\n    }\n\n    // The AuthenticateUsecaseInput type should prevent this case\n    return {\n      observable: of({\n        status: DeviceActionStatus.Error,\n        error: new LKRPMissingDataError(\n          \"Either a trustchainId or a device is required for authentication.\",\n        ),\n      }),\n      cancel: () => undefined,\n    };\n  }\n}\n"],
-  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAGO,2CACPC,EAAmC,qBACnCC,EAAmB,gBAInBC,EAAqC,6BAErCC,EAA+B,kDAaxB,IAAMC,EAAN,KAA0B,CAC/B,YAEUC,EACR,CADQ,eAAAA,CACP,CAEH,QAAQC,EAA2D,CACjE,GAAIA,EAAM,aACR,OAAO,KAAK,UAAU,wBAAwBA,CAAK,EAGrD,MAAMC,EAAYD,EAAM,UACxB,OAAIC,EACK,KAAK,UAAU,uBAAuB,CAAE,GAAGD,EAAO,UAAAC,CAAU,CAAC,EAI/D,CACL,cAAY,MAAG,CACb,OAAQ,qBAAmB,MAC3B,MAAO,IAAI,uBACT,mEACF,CACF,CAAC,EACD,OAAQ,IAAG,EACb,CACF,CACF,EA3BaH,EAANI,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,iBAAe,UAAU,IAFxBL",
+  "sourcesContent": ["import {\n  DeviceActionStatus,\n  DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\nimport { of } from \"rxjs\";\n\nimport { AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { LKRPMissingDataError } from \"@api/app-binder/Errors\";\nimport { Keypair, Permissions } from \"@api/app-binder/LKRPTypes\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { LedgerKeyringProtocolBinder } from \"@internal/app-binder/LedgerKeyringProtocolBinder\";\n\nexport type AuthenticateUsecaseInput = {\n  keypair: Keypair;\n  clientName: string;\n  permissions: Permissions;\n} & (\n  | { trustchainId: string; sessionId?: DeviceSessionId }\n  | { trustchainId?: undefined; sessionId: DeviceSessionId }\n);\n\n@injectable()\nexport class AuthenticateUseCase {\n  constructor(\n    @inject(appBinderTypes.AppBinding)\n    private appBinder: LedgerKeyringProtocolBinder,\n  ) {}\n\n  execute(input: AuthenticateUsecaseInput): AuthenticateDAReturnType {\n    if (input.trustchainId) {\n      return this.appBinder.authenticateWithKeypair(input);\n    }\n\n    const sessionId = input.sessionId;\n    if (sessionId) {\n      return this.appBinder.authenticateWithDevice({ ...input, sessionId });\n    }\n\n    // The AuthenticateUsecaseInput type should prevent this case\n    return {\n      observable: of({\n        status: DeviceActionStatus.Error,\n        error: new LKRPMissingDataError(\n          \"Either a trustchainId or a device is required for authentication.\",\n        ),\n      }),\n      cancel: () => undefined,\n    };\n  }\n}\n"],
+  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAGO,2CACPC,EAAmC,qBACnCC,EAAmB,gBAGnBC,EAAqC,kCAErCC,EAA+B,kDAaxB,IAAMC,EAAN,KAA0B,CAC/B,YAEUC,EACR,CADQ,eAAAA,CACP,CAEH,QAAQC,EAA2D,CACjE,GAAIA,EAAM,aACR,OAAO,KAAK,UAAU,wBAAwBA,CAAK,EAGrD,MAAMC,EAAYD,EAAM,UACxB,OAAIC,EACK,KAAK,UAAU,uBAAuB,CAAE,GAAGD,EAAO,UAAAC,CAAU,CAAC,EAI/D,CACL,cAAY,MAAG,CACb,OAAQ,qBAAmB,MAC3B,MAAO,IAAI,uBACT,mEACF,CACF,CAAC,EACD,OAAQ,IAAG,EACb,CACF,CACF,EA3BaH,EAANI,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,iBAAe,UAAU,IAFxBL",
   "names": ["AuthenticateUseCase_exports", "__export", "AuthenticateUseCase", "__toCommonJS", "import_device_management_kit", "import_inversify", "import_rxjs", "import_Errors", "import_appBinderTypes", "AuthenticateUseCase", "appBinder", "input", "sessionId", "__decorateClass", "__decorateParam"]
 }

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

@@ -1,2 +1,2 @@
-"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});
+"use strict";var c=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var B=(i,e)=>{for(var n in e)c(i,n,{get:e[n],enumerable:!0})},L=(i,e,n,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of w(e))!A.call(i,r)&&r!==n&&c(i,r,{get:()=>e[r],enumerable:!(t=u(e,r))||t.enumerable});return i};var F=i=>L(c({},"__esModule",{value:!0}),i);var b={};B(b,{DecryptDataUseCase:()=>K});module.exports=F(b);var p=require("@ledgerhq/device-management-kit"),m=require("purify-ts"),s=require("../../../api/app-binder/Errors"),l=require("../../../api/index"),y=require("../../utils/crypto"),d=require("../../utils/eitherSeqRecord");class K{execute(e,n){const t=new p.ByteArrayParser(n);if(t.extract8BitUInt()!==0)throw new s.LKRPParsingError("Unsupported serialization version");const r=(a,o)=>m.Maybe.fromNullable(a).toEither(new s.LKRPParsingError(`Missing ${o} field`));return(0,d.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(({ephemeralPublicKey:a,iv:o,tag:h,encryptedData:g})=>{const f=new l.KeypairFromBytes(e).ecdh(a).slice(1),U=y.CryptoUtils.hmac(new Uint8Array,f),x=new Uint8Array([...g,...h]);return y.CryptoUtils.decrypt(U,o,x)}).caseOf({Left:a=>{throw a},Right:a=>a})}}0&&(module.exports={DecryptDataUseCase});
 //# sourceMappingURL=DecryptDataUseCase.js.map

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

@@ -1,7 +1,7 @@
 {
   "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"]
+  "sourcesContent": ["import { ByteArrayParser } from \"@ledgerhq/device-management-kit\";\nimport { Maybe } from \"purify-ts\";\n\nimport { LKRPParsingError } from \"@api/app-binder/Errors\";\nimport { KeypairFromBytes } from \"@api/index\";\nimport { CryptoUtils } from \"@internal/utils/crypto\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\n\nexport class DecryptDataUseCase {\n  execute(encryptionKey: Uint8Array, data: Uint8Array): 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(({ ephemeralPublicKey, iv, tag, encryptedData }) => {\n        // Derive the shared secret using ECDH with an ephemeral keypair\n        const privateKey = new KeypairFromBytes(encryptionKey);\n        const sharedSecret = privateKey.ecdh(ephemeralPublicKey).slice(1);\n\n        // Key derivation using HMAC-SHA256\n        const key = CryptoUtils.hmac(new Uint8Array(), sharedSecret);\n\n        // Decrypt the data\n        const ciphertext = new Uint8Array([...encryptedData, ...tag]);\n        const cleartext = CryptoUtils.decrypt(key, iv, ciphertext);\n        return cleartext;\n      })\n      .caseOf({\n        Left: (error) => {\n          throw error;\n        },\n        Right: (cleartext) => cleartext,\n      });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,2CAChCC,EAAsB,qBAEtBC,EAAiC,kCACjCC,EAAiC,sBACjCC,EAA4B,kCAC5BC,EAAgC,2CAEzB,MAAMP,CAAmB,CAC9B,QAAQQ,EAA2BC,EAA8B,CAC/D,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,CAAC,CAAE,mBAAAI,EAAoB,GAAAC,EAAI,IAAAC,EAAK,cAAAC,CAAc,IAAM,CAGvD,MAAMC,EADa,IAAI,mBAAiBV,CAAa,EACrB,KAAKM,CAAkB,EAAE,MAAM,CAAC,EAG1DK,EAAM,cAAY,KAAK,IAAI,WAAcD,CAAY,EAGrDE,EAAa,IAAI,WAAW,CAAC,GAAGH,EAAe,GAAGD,CAAG,CAAC,EAE5D,OADkB,cAAY,QAAQG,EAAKJ,EAAIK,CAAU,CAE3D,CAAC,EACA,OAAO,CACN,KAAOC,GAAU,CACf,MAAMA,CACR,EACA,MAAQC,GAAcA,CACxB,CAAC,CACL,CACF",
+  "names": ["DecryptDataUseCase_exports", "__export", "DecryptDataUseCase", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_Errors", "import_api", "import_crypto", "import_eitherSeqRecord", "encryptionKey", "data", "parser", "required", "value", "field", "ephemeralPublicKey", "iv", "tag", "encryptedData", "sharedSecret", "key", "ciphertext", "error", "cleartext"]
 }

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

@@ -1,2 +1,2 @@
-"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});
+"use strict";var y=Object.defineProperty;var B=Object.getOwnPropertyDescriptor;var U=Object.getOwnPropertyNames;var D=Object.prototype.hasOwnProperty;var K=(a,r)=>{for(var o in r)y(a,o,{get:r[o],enumerable:!0})},T=(a,r,o,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of U(r))!D.call(a,t)&&t!==o&&y(a,t,{get:()=>r[t],enumerable:!(n=B(r,t))||n.enumerable});return a};var l=a=>T(y({},"__esModule",{value:!0}),a);var b={};K(b,{EncryptDataUseCase:()=>A});module.exports=l(b);var i=require("@ledgerhq/device-management-kit"),d=require("../../../api/index"),e=require("../../utils/crypto");class A{execute(r,o){const n=new d.KeypairFromBytes(r),t=e.CryptoUtils.randomKeypair(),p=n.ecdh(t.pubKeyToU8a()).slice(1),u=e.CryptoUtils.hmac(new Uint8Array,p),s=e.CryptoUtils.randomBytes(16),c=e.CryptoUtils.encrypt(u,s,o),f=c.subarray(0,-e.AES_BLOCK_SIZE),m=c.subarray(-e.AES_BLOCK_SIZE);return new i.ByteArrayBuilder().add8BitUIntToData(0).addBufferToData(t.pubKeyToU8a()).addBufferToData(s).addBufferToData(m).addBufferToData(f).build()}}0&&(module.exports={EncryptDataUseCase});
 //# sourceMappingURL=EncryptDataUseCase.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/use-cases/authentication/EncryptDataUseCase.ts"],
-  "sourcesContent": ["import { ByteArrayBuilder } from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport {\n  type CryptoService,\n  Curve,\n  EncryptionAlgo,\n  HashAlgo,\n} from \"@api/crypto/CryptoService\";\nimport { AES256_BLOCK_SIZE } from \"@api/crypto/Key\";\nimport { externalTypes } from \"@internal/externalTypes\";\n\n@injectable()\nexport class EncryptDataUseCase {\n  constructor(\n    @inject(externalTypes.CryptoService)\n    private cryptoService: CryptoService,\n  ) {}\n\n  async execute(\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\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 ephemeralKeypair = await this.cryptoService.createKeyPair(Curve.K256);\n    const sharedSecret = await privateKey.deriveSharedSecret(\n      ephemeralKeypair.getPublicKey(),\n    );\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    // Generate a random IV (nonce)\n    const iv = this.cryptoService.randomBytes(16);\n\n    // Encrypt data\n    const symmetricKey = this.cryptoService.importSymmetricKey(\n      key,\n      EncryptionAlgo.AES256_GCM,\n    );\n    const ciphertext = await symmetricKey.encrypt(iv, data);\n    const encryptedData = ciphertext.subarray(0, -AES256_BLOCK_SIZE);\n    const tag = ciphertext.subarray(-AES256_BLOCK_SIZE);\n\n    // Serialize the result\n    return new ByteArrayBuilder()\n      .add8BitUIntToData(0) // Version of the format\n      .addBufferToData(ephemeralKeypair.getPublicKey())\n      .addBufferToData(iv)\n      .addBufferToData(tag)\n      .addBufferToData(encryptedData)\n      .build();\n  }\n}\n"],
-  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAiC,2CACjCC,EAAmC,qBAEnCC,EAKO,qCACPC,EAAkC,2BAClCC,EAA8B,mCAGvB,IAAMC,EAAN,KAAyB,CAC9B,YAEUC,EACR,CADQ,mBAAAA,CACP,CAEH,MAAM,QACJC,EACAC,EACqB,CAErB,MAAMC,EAAa,KAAK,cAAc,cACpCF,EACA,QAAM,IACR,EACMG,EAAmB,MAAM,KAAK,cAAc,cAAc,QAAM,IAAI,EACpEC,EAAe,MAAMF,EAAW,mBACpCC,EAAiB,aAAa,CAChC,EAGME,EAAM,KAAK,cAAc,KAC7B,IAAI,WACJD,EAAa,MAAM,CAAC,EACpB,WAAS,MACX,EAGME,EAAK,KAAK,cAAc,YAAY,EAAE,EAOtCC,EAAa,MAJE,KAAK,cAAc,mBACtCF,EACA,iBAAe,UACjB,EACsC,QAAQC,EAAIL,CAAI,EAChDO,EAAgBD,EAAW,SAAS,EAAG,CAAC,mBAAiB,EACzDE,EAAMF,EAAW,SAAS,CAAC,mBAAiB,EAGlD,OAAO,IAAI,mBAAiB,EACzB,kBAAkB,CAAC,EACnB,gBAAgBJ,EAAiB,aAAa,CAAC,EAC/C,gBAAgBG,CAAE,EAClB,gBAAgBG,CAAG,EACnB,gBAAgBD,CAAa,EAC7B,MAAM,CACX,CACF,EAhDaV,EAANY,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,gBAAc,aAAa,IAF1Bb",
-  "names": ["EncryptDataUseCase_exports", "__export", "EncryptDataUseCase", "__toCommonJS", "import_device_management_kit", "import_inversify", "import_CryptoService", "import_Key", "import_externalTypes", "EncryptDataUseCase", "cryptoService", "encryptionKey", "data", "privateKey", "ephemeralKeypair", "sharedSecret", "key", "iv", "ciphertext", "encryptedData", "tag", "__decorateClass", "__decorateParam"]
+  "sourcesContent": ["import { ByteArrayBuilder } from \"@ledgerhq/device-management-kit\";\n\nimport { KeypairFromBytes } from \"@api/index\";\nimport { AES_BLOCK_SIZE, CryptoUtils } from \"@internal/utils/crypto\";\n\nexport class EncryptDataUseCase {\n  execute(encryptionKey: Uint8Array, data: Uint8Array): Uint8Array {\n    // Derive the shared secret using ECDH with an ephemeral keypair\n    const privateKey = new KeypairFromBytes(encryptionKey);\n    const ephemeralKeypair = CryptoUtils.randomKeypair();\n    const sharedSecret = privateKey\n      .ecdh(ephemeralKeypair.pubKeyToU8a())\n      .slice(1);\n\n    // Key derivation using HMAC-SHA256\n    const key = CryptoUtils.hmac(new Uint8Array(), sharedSecret);\n\n    // Generate a random IV (nonce)\n    const iv = CryptoUtils.randomBytes(16);\n\n    // Encrypt data\n    const ciphertext = CryptoUtils.encrypt(key, iv, data);\n    const encryptedData = ciphertext.subarray(0, -AES_BLOCK_SIZE);\n    const tag = ciphertext.subarray(-AES_BLOCK_SIZE);\n\n    // Serialize the result\n    return new ByteArrayBuilder()\n      .add8BitUIntToData(0) // Version of the format\n      .addBufferToData(ephemeralKeypair.pubKeyToU8a())\n      .addBufferToData(iv)\n      .addBufferToData(tag)\n      .addBufferToData(encryptedData)\n      .build();\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,wBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAiC,2CAEjCC,EAAiC,sBACjCC,EAA4C,kCAErC,MAAMJ,CAAmB,CAC9B,QAAQK,EAA2BC,EAA8B,CAE/D,MAAMC,EAAa,IAAI,mBAAiBF,CAAa,EAC/CG,EAAmB,cAAY,cAAc,EAC7CC,EAAeF,EAClB,KAAKC,EAAiB,YAAY,CAAC,EACnC,MAAM,CAAC,EAGJE,EAAM,cAAY,KAAK,IAAI,WAAcD,CAAY,EAGrDE,EAAK,cAAY,YAAY,EAAE,EAG/BC,EAAa,cAAY,QAAQF,EAAKC,EAAIL,CAAI,EAC9CO,EAAgBD,EAAW,SAAS,EAAG,CAAC,gBAAc,EACtDE,EAAMF,EAAW,SAAS,CAAC,gBAAc,EAG/C,OAAO,IAAI,mBAAiB,EACzB,kBAAkB,CAAC,EACnB,gBAAgBJ,EAAiB,YAAY,CAAC,EAC9C,gBAAgBG,CAAE,EAClB,gBAAgBG,CAAG,EACnB,gBAAgBD,CAAa,EAC7B,MAAM,CACX,CACF",
+  "names": ["EncryptDataUseCase_exports", "__export", "EncryptDataUseCase", "__toCommonJS", "import_device_management_kit", "import_api", "import_crypto", "encryptionKey", "data", "privateKey", "ephemeralKeypair", "sharedSecret", "key", "iv", "ciphertext", "encryptedData", "tag"]
 }

package/lib/cjs/internal/utils/LKRPBlock.js CHANGED Viewed

@@ -1,5 +1,5 @@
-"use strict";var m=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var P=Object.prototype.hasOwnProperty;var g=(n,r)=>{for(var e in r)m(n,e,{get:r[e],enumerable:!0})},L=(n,r,e,s)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of y(r))!P.call(n,o)&&o!==e&&m(n,o,{get:()=>r[o],enumerable:!(s=p(r,o))||s.enumerable});return n};var B=n=>L(m({},"__esModule",{value:!0}),n);var b={};g(b,{LKRPBlock:()=>u});module.exports=B(b);var t=require("@ledgerhq/device-management-kit"),f=require("@noble/hashes/sha256"),a=require("purify-ts"),i=require("../models/Tags"),l=require("./TLVParser");class u{constructor(r,e){this.bytes=r;this.data=e?(0,a.Just)((0,a.Right)(e)):a.Nothing}hashValue=a.Nothing;data;static fromHex(r){return new u((0,t.hexaStringToBuffer)(r)??new Uint8Array)}static fromData(r){const e=new t.ByteArrayBuilder().encodeInTLVFromUInt8(i.GeneralTags.Int,1).encodeInTLVFromHexa(i.GeneralTags.Hash,r.parent).encodeInTLVFromBuffer(i.GeneralTags.PublicKey,r.issuer).encodeInTLVFromUInt8(i.GeneralTags.Int,r.commands.length).build(),s=new t.ByteArrayBuilder;r.commands.forEach(d=>s.addBufferToData(d.toU8A()));const o=s.build(),c=new t.ByteArrayBuilder().encodeInTLVFromBuffer(i.GeneralTags.Signature,r.signature).build(),h=new t.ByteArrayBuilder().addBufferToData(e).addBufferToData(o).addBufferToData(c).build();return new u(h,{...r,header:e,signature:c})}toString(){return(0,t.bufferToHexaString)(this.bytes,!1)}toU8A(){return this.bytes}parse(){return this.data.orDefaultLazy(()=>{const r=new l.TLVParser(this.bytes).parseBlockData();return this.data=(0,a.Just)(r),r})}toHuman(){return this.parse().chain(r=>a.Either.sequence(r.commands.map(e=>e.toHuman())).map(e=>({...r,commands:e}))).map(r=>[`Parent: ${r.parent}`,`Issuer: ${(0,t.bufferToHexaString)(r.issuer,!1)}`,`Commands:${r.commands.flatMap(e=>e.split(`
-`).map(s=>`
-  ${s}`)).join("")}`,`Signature: ${(0,t.bufferToHexaString)(r.signature.slice(2),!1)}`].join(`
-`))}hash(){return this.hashValue.orDefaultLazy(()=>{const r=(0,f.sha256)(this.bytes);return(0,t.bufferToHexaString)(r,!1)})}}0&&(module.exports={LKRPBlock});
+"use strict";var c=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var f=(s,r)=>{for(var t in r)c(s,t,{get:r[t],enumerable:!0})},b=(s,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of P(r))!d.call(s,i)&&i!==t&&c(s,i,{get:()=>r[i],enumerable:!(n=y(r,i))||n.enumerable});return s};var L=s=>b(c({},"__esModule",{value:!0}),s);var K={};f(K,{LKRPBlock:()=>o});module.exports=L(K);var a=require("@ledgerhq/device-management-kit"),e=require("purify-ts"),h=require("./crypto"),l=require("./TLVBuilder"),m=require("./TLVParser");class o{constructor(r,t){this.bytes=r;this.data=t?(0,e.Just)((0,e.Right)(t)):e.Nothing}hashValue=e.Nothing;data;static fromHex(r){return new o((0,a.hexaStringToBuffer)(r)??new Uint8Array)}static fromData(r){const t=new l.TLVBuilder().addInt(1,1).addHash((0,a.hexaStringToBuffer)(r.parent)??new Uint8Array).addPublicKey(r.issuer).addInt(r.commands.length,1),n=t.build();r.commands.forEach(g=>t.push(g.toU8A()));const i=t.build().length,u=t.addSignature(r.signature).build(),p=u.slice(i,u.length);return new o(u,{...r,header:n,signature:p})}toString(){return(0,a.bufferToHexaString)(this.bytes).slice(2)}toU8A(){return this.bytes}parse(){return this.data.orDefaultLazy(()=>{const r=new m.TLVParser(this.bytes).parseBlockData();return this.data=(0,e.Just)(r),r})}toHuman(){return this.parse().chain(r=>e.Either.sequence(r.commands.map(t=>t.toHuman())).map(t=>({...r,commands:t}))).map(r=>[`Parent: ${r.parent}`,`Issuer: ${(0,a.bufferToHexaString)(r.issuer).slice(2)}`,`Commands:${r.commands.flatMap(t=>t.split(`
+`).map(n=>`
+  ${n}`)).join("")}`,`Signature: ${(0,a.bufferToHexaString)(r.signature.slice(2)).slice(2)}`].join(`
+`))}hash(){return this.hashValue.orDefaultLazy(()=>{const r=h.CryptoUtils.hash(this.bytes);return(0,a.bufferToHexaString)(r).slice(2)})}}0&&(module.exports={LKRPBlock});
 //# sourceMappingURL=LKRPBlock.js.map

package/lib/cjs/internal/utils/LKRPBlock.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/utils/LKRPBlock.ts"],
-  "sourcesContent": ["import {\n  bufferToHexaString,\n  ByteArrayBuilder,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { Either, Just, type Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { type LKRPParsingError } from \"@api/model/Errors\";\nimport {\n  type LKRPBlockData,\n  type LKRPBlockParsedData,\n} from \"@internal/models/LKRPBlockTypes\";\nimport { GeneralTags } from \"@internal/models/Tags\";\n\nimport { TLVParser } from \"./TLVParser\";\n\nexport class LKRPBlock {\n  private hashValue: Maybe<string> = Nothing; // Cache hash value for performance\n  private data: Maybe<Either<LKRPParsingError, LKRPBlockParsedData>>;\n\n  public constructor(\n    private readonly bytes: Uint8Array,\n    data?: LKRPBlockParsedData,\n  ) {\n    this.data = data ? Just(Right(data)) : Nothing;\n  }\n\n  static fromHex(hex: string): LKRPBlock {\n    return new LKRPBlock(hexaStringToBuffer(hex) ?? new Uint8Array());\n  }\n\n  static fromData(data: LKRPBlockData): LKRPBlock {\n    const header = new ByteArrayBuilder()\n      .encodeInTLVFromUInt8(GeneralTags.Int, 1) // Version 1\n      .encodeInTLVFromHexa(GeneralTags.Hash, data.parent)\n      .encodeInTLVFromBuffer(GeneralTags.PublicKey, data.issuer)\n      .encodeInTLVFromUInt8(GeneralTags.Int, data.commands.length)\n      .build();\n\n    const commandsBuilder = new ByteArrayBuilder();\n    data.commands.forEach((cmd) =>\n      commandsBuilder.addBufferToData(cmd.toU8A()),\n    );\n    const commands = commandsBuilder.build();\n\n    const signature = new ByteArrayBuilder()\n      .encodeInTLVFromBuffer(GeneralTags.Signature, data.signature)\n      .build();\n\n    const bytes = new ByteArrayBuilder()\n      .addBufferToData(header)\n      .addBufferToData(commands)\n      .addBufferToData(signature)\n      .build();\n\n    return new LKRPBlock(bytes, { ...data, header, signature });\n  }\n\n  toString(): string {\n    return bufferToHexaString(this.bytes, false);\n  }\n\n  toU8A(): Uint8Array {\n    return this.bytes;\n  }\n\n  parse(): Either<LKRPParsingError, LKRPBlockParsedData> {\n    return this.data.orDefaultLazy(() => {\n      const data = new TLVParser(this.bytes).parseBlockData();\n      this.data = Just(data);\n      return data;\n    });\n  }\n\n  toHuman(): Either<LKRPParsingError, string> {\n    return this.parse()\n      .chain((data) =>\n        Either.sequence(data.commands.map((cmd) => cmd.toHuman())).map(\n          (commands) => ({ ...data, commands }),\n        ),\n      )\n      .map((data) =>\n        [\n          `Parent: ${data.parent}`,\n          `Issuer: ${bufferToHexaString(data.issuer, false)}`,\n          `Commands:${data.commands\n            .flatMap((cmd) => cmd.split(\"\\n\").map((l) => `\\n  ${l}`))\n            .join(\"\")}`,\n          `Signature: ${bufferToHexaString(data.signature.slice(2), false)}`,\n        ].join(\"\\n\"),\n      );\n  }\n\n  hash(): string {\n    return this.hashValue.orDefaultLazy(() => {\n      const hashValue = sha256(this.bytes);\n      return bufferToHexaString(hashValue, false);\n    });\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,eAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAIO,2CACPC,EAAuB,gCACvBC,EAAyD,qBAOzDC,EAA4B,iCAE5BC,EAA0B,uBAEnB,MAAMN,CAAU,CAId,YACYO,EACjBC,EACA,CAFiB,WAAAD,EAGjB,KAAK,KAAOC,KAAO,WAAK,SAAMA,CAAI,CAAC,EAAI,SACzC,CARQ,UAA2B,UAC3B,KASR,OAAO,QAAQC,EAAwB,CACrC,OAAO,IAAIT,KAAU,sBAAmBS,CAAG,GAAK,IAAI,UAAY,CAClE,CAEA,OAAO,SAASD,EAAgC,CAC9C,MAAME,EAAS,IAAI,mBAAiB,EACjC,qBAAqB,cAAY,IAAK,CAAC,EACvC,oBAAoB,cAAY,KAAMF,EAAK,MAAM,EACjD,sBAAsB,cAAY,UAAWA,EAAK,MAAM,EACxD,qBAAqB,cAAY,IAAKA,EAAK,SAAS,MAAM,EAC1D,MAAM,EAEHG,EAAkB,IAAI,mBAC5BH,EAAK,SAAS,QAASI,GACrBD,EAAgB,gBAAgBC,EAAI,MAAM,CAAC,CAC7C,EACA,MAAMC,EAAWF,EAAgB,MAAM,EAEjCG,EAAY,IAAI,mBAAiB,EACpC,sBAAsB,cAAY,UAAWN,EAAK,SAAS,EAC3D,MAAM,EAEHD,EAAQ,IAAI,mBAAiB,EAChC,gBAAgBG,CAAM,EACtB,gBAAgBG,CAAQ,EACxB,gBAAgBC,CAAS,EACzB,MAAM,EAET,OAAO,IAAId,EAAUO,EAAO,CAAE,GAAGC,EAAM,OAAAE,EAAQ,UAAAI,CAAU,CAAC,CAC5D,CAEA,UAAmB,CACjB,SAAO,sBAAmB,KAAK,MAAO,EAAK,CAC7C,CAEA,OAAoB,CAClB,OAAO,KAAK,KACd,CAEA,OAAuD,CACrD,OAAO,KAAK,KAAK,cAAc,IAAM,CACnC,MAAMN,EAAO,IAAI,YAAU,KAAK,KAAK,EAAE,eAAe,EACtD,YAAK,QAAO,QAAKA,CAAI,EACdA,CACT,CAAC,CACH,CAEA,SAA4C,CAC1C,OAAO,KAAK,MAAM,EACf,MAAOA,GACN,SAAO,SAASA,EAAK,SAAS,IAAKI,GAAQA,EAAI,QAAQ,CAAC,CAAC,EAAE,IACxDC,IAAc,CAAE,GAAGL,EAAM,SAAAK,CAAS,EACrC,CACF,EACC,IAAKL,GACJ,CACE,WAAWA,EAAK,MAAM,GACtB,cAAW,sBAAmBA,EAAK,OAAQ,EAAK,CAAC,GACjD,YAAYA,EAAK,SACd,QAASI,GAAQA,EAAI,MAAM;AAAA,CAAI,EAAE,IAAKG,GAAM;AAAA,IAAOA,CAAC,EAAE,CAAC,EACvD,KAAK,EAAE,CAAC,GACX,iBAAc,sBAAmBP,EAAK,UAAU,MAAM,CAAC,EAAG,EAAK,CAAC,EAClE,EAAE,KAAK;AAAA,CAAI,CACb,CACJ,CAEA,MAAe,CACb,OAAO,KAAK,UAAU,cAAc,IAAM,CACxC,MAAMQ,KAAY,UAAO,KAAK,KAAK,EACnC,SAAO,sBAAmBA,EAAW,EAAK,CAC5C,CAAC,CACH,CACF",
-  "names": ["LKRPBlock_exports", "__export", "LKRPBlock", "__toCommonJS", "import_device_management_kit", "import_sha256", "import_purify_ts", "import_Tags", "import_TLVParser", "bytes", "data", "hex", "header", "commandsBuilder", "cmd", "commands", "signature", "l", "hashValue"]
+  "sourcesContent": ["import {\n  bufferToHexaString,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { Either, Just, type Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { type LKRPParsingError } from \"@api/app-binder/Errors\";\nimport {\n  type LKRPBlockData,\n  type LKRPBlockParsedData,\n} from \"@internal/models/LKRPBlockTypes\";\n\nimport { CryptoUtils } from \"./crypto\";\nimport { TLVBuilder } from \"./TLVBuilder\";\nimport { TLVParser } from \"./TLVParser\";\n\nexport class LKRPBlock {\n  private hashValue: Maybe<string> = Nothing; // Cache hash value for performance\n  private data: Maybe<Either<LKRPParsingError, LKRPBlockParsedData>>;\n\n  public constructor(\n    private readonly bytes: Uint8Array,\n    data?: LKRPBlockParsedData,\n  ) {\n    this.data = data ? Just(Right(data)) : Nothing;\n  }\n\n  static fromHex(hex: string): LKRPBlock {\n    return new LKRPBlock(hexaStringToBuffer(hex) ?? new Uint8Array());\n  }\n\n  static fromData(data: LKRPBlockData): LKRPBlock {\n    const builder = new TLVBuilder()\n      .addInt(1, 1) // Version 1\n      .addHash(hexaStringToBuffer(data.parent) ?? new Uint8Array())\n      .addPublicKey(data.issuer)\n      .addInt(data.commands.length, 1);\n\n    const header = builder.build();\n\n    data.commands.forEach((cmd) => builder.push(cmd.toU8A()));\n\n    const sigStart = builder.build().length;\n    const bytes = builder.addSignature(data.signature).build();\n    const signature = bytes.slice(sigStart, bytes.length);\n\n    return new LKRPBlock(bytes, { ...data, header, signature });\n  }\n\n  toString(): string {\n    return bufferToHexaString(this.bytes).slice(2);\n  }\n\n  toU8A(): Uint8Array {\n    return this.bytes;\n  }\n\n  parse(): Either<LKRPParsingError, LKRPBlockParsedData> {\n    return this.data.orDefaultLazy(() => {\n      const data = new TLVParser(this.bytes).parseBlockData();\n      this.data = Just(data);\n      return data;\n    });\n  }\n\n  toHuman(): Either<LKRPParsingError, string> {\n    return this.parse()\n      .chain((data) =>\n        Either.sequence(data.commands.map((cmd) => cmd.toHuman())).map(\n          (commands) => ({ ...data, commands }),\n        ),\n      )\n      .map((data) =>\n        [\n          `Parent: ${data.parent}`,\n          `Issuer: ${bufferToHexaString(data.issuer).slice(2)}`,\n          `Commands:${data.commands\n            .flatMap((cmd) => cmd.split(\"\\n\").map((l) => `\\n  ${l}`))\n            .join(\"\")}`,\n          `Signature: ${bufferToHexaString(data.signature.slice(2)).slice(2)}`,\n        ].join(\"\\n\"),\n      );\n  }\n\n  hash(): string {\n    return this.hashValue.orDefaultLazy(() => {\n      const hashValue = CryptoUtils.hash(this.bytes);\n      return bufferToHexaString(hashValue).slice(2);\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,eAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAGO,2CACPC,EAAyD,qBAQzDC,EAA4B,oBAC5BC,EAA2B,wBAC3BC,EAA0B,uBAEnB,MAAMN,CAAU,CAId,YACYO,EACjBC,EACA,CAFiB,WAAAD,EAGjB,KAAK,KAAOC,KAAO,WAAK,SAAMA,CAAI,CAAC,EAAI,SACzC,CARQ,UAA2B,UAC3B,KASR,OAAO,QAAQC,EAAwB,CACrC,OAAO,IAAIT,KAAU,sBAAmBS,CAAG,GAAK,IAAI,UAAY,CAClE,CAEA,OAAO,SAASD,EAAgC,CAC9C,MAAME,EAAU,IAAI,aAAW,EAC5B,OAAO,EAAG,CAAC,EACX,WAAQ,sBAAmBF,EAAK,MAAM,GAAK,IAAI,UAAY,EAC3D,aAAaA,EAAK,MAAM,EACxB,OAAOA,EAAK,SAAS,OAAQ,CAAC,EAE3BG,EAASD,EAAQ,MAAM,EAE7BF,EAAK,SAAS,QAASI,GAAQF,EAAQ,KAAKE,EAAI,MAAM,CAAC,CAAC,EAExD,MAAMC,EAAWH,EAAQ,MAAM,EAAE,OAC3BH,EAAQG,EAAQ,aAAaF,EAAK,SAAS,EAAE,MAAM,EACnDM,EAAYP,EAAM,MAAMM,EAAUN,EAAM,MAAM,EAEpD,OAAO,IAAIP,EAAUO,EAAO,CAAE,GAAGC,EAAM,OAAAG,EAAQ,UAAAG,CAAU,CAAC,CAC5D,CAEA,UAAmB,CACjB,SAAO,sBAAmB,KAAK,KAAK,EAAE,MAAM,CAAC,CAC/C,CAEA,OAAoB,CAClB,OAAO,KAAK,KACd,CAEA,OAAuD,CACrD,OAAO,KAAK,KAAK,cAAc,IAAM,CACnC,MAAMN,EAAO,IAAI,YAAU,KAAK,KAAK,EAAE,eAAe,EACtD,YAAK,QAAO,QAAKA,CAAI,EACdA,CACT,CAAC,CACH,CAEA,SAA4C,CAC1C,OAAO,KAAK,MAAM,EACf,MAAOA,GACN,SAAO,SAASA,EAAK,SAAS,IAAKI,GAAQA,EAAI,QAAQ,CAAC,CAAC,EAAE,IACxDG,IAAc,CAAE,GAAGP,EAAM,SAAAO,CAAS,EACrC,CACF,EACC,IAAKP,GACJ,CACE,WAAWA,EAAK,MAAM,GACtB,cAAW,sBAAmBA,EAAK,MAAM,EAAE,MAAM,CAAC,CAAC,GACnD,YAAYA,EAAK,SACd,QAASI,GAAQA,EAAI,MAAM;AAAA,CAAI,EAAE,IAAKI,GAAM;AAAA,IAAOA,CAAC,EAAE,CAAC,EACvD,KAAK,EAAE,CAAC,GACX,iBAAc,sBAAmBR,EAAK,UAAU,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EACpE,EAAE,KAAK;AAAA,CAAI,CACb,CACJ,CAEA,MAAe,CACb,OAAO,KAAK,UAAU,cAAc,IAAM,CACxC,MAAMS,EAAY,cAAY,KAAK,KAAK,KAAK,EAC7C,SAAO,sBAAmBA,CAAS,EAAE,MAAM,CAAC,CAC9C,CAAC,CACH,CACF",
+  "names": ["LKRPBlock_exports", "__export", "LKRPBlock", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_crypto", "import_TLVBuilder", "import_TLVParser", "bytes", "data", "hex", "builder", "header", "cmd", "sigStart", "signature", "commands", "l", "hashValue"]
 }

package/lib/cjs/internal/utils/LKRPBlock.test.js CHANGED Viewed

@@ -1,4 +1,4 @@
-"use strict";var r=require("@ledgerhq/device-management-kit"),c=require("purify-ts"),i=require("../../api/model/Errors"),n=require("../models/Tags"),d=require("./LKRPBlock"),f=require("./LKRPCommand");const t={parent:"0000",issuer:new Uint8Array([1,2,3]),commands:[f.LKRPCommand.fromHex("10020102"),f.LKRPCommand.fromHex("11020304")],signature:new Uint8Array([4,5,6])},s=["010101","02020000","0603010203","010102"].join(""),b=[...s,"10020102","11020304","0303040506"].join(""),o={...t,header:(0,r.hexaStringToBuffer)(s),signature:Uint8Array.from([n.GeneralTags.Signature,3,...t.signature])};describe("LKRPBlock",()=>{describe("fromData",()=>{it("should create a Block from data",()=>{const e=d.LKRPBlock.fromData(t);expect(e.parse()).toStrictEqual((0,c.Right)(o)),expect(e.toString()).toBe(b)})}),describe("toString",()=>{it("should return the hex representation of the block",()=>{const e=d.LKRPBlock.fromHex(b);expect(e.toString()).toBe(b)})}),describe("toU8A",()=>{it("should return the bytes of the block",()=>{const e=new Uint8Array([1,2,3,4,5,6,7,8]),a=new d.LKRPBlock(e);expect(a.toU8A()).toBe(e)})}),describe("parse",()=>{it("should parse the block data correctly",()=>{const a=d.LKRPBlock.fromHex(b).parse();expect(a).toStrictEqual((0,c.Right)(o))}),it("should fail if the block data is invalid",()=>{const e=d.LKRPBlock.fromHex("invalid");expect(e.parse()).toStrictEqual((0,c.Left)(new i.LKRPParsingError("Unexpected end of TLV")))})}),describe("toHuman",()=>{it("should return a human-readable representation of the block",()=>{const e=`
+"use strict";var a=require("purify-ts"),r=require("../../api/app-binder/Errors"),i=require("../models/Tags"),n=require("./hex"),d=require("./LKRPBlock"),f=require("./LKRPCommand");const t={parent:"0000",issuer:new Uint8Array([1,2,3]),commands:[f.LKRPCommand.fromHex("10020102"),f.LKRPCommand.fromHex("11020304")],signature:new Uint8Array([4,5,6])},s=["010101","02020000","0603010203","010102"].join(""),b=[...s,"10020102","11020304","0303040506"].join(""),o={...t,header:(0,n.hexToBytes)(s),signature:Uint8Array.from([i.GeneralTags.Signature,3,...t.signature])};describe("LKRPBlock",()=>{describe("fromData",()=>{it("should create a Block from data",()=>{const e=d.LKRPBlock.fromData(t);expect(e.parse()).toStrictEqual((0,a.Right)(o)),expect(e.toString()).toBe(b)})}),describe("toString",()=>{it("should return the hex representation of the block",()=>{const e=d.LKRPBlock.fromHex(b);expect(e.toString()).toBe(b)})}),describe("toU8A",()=>{it("should return the bytes of the block",()=>{const e=new Uint8Array([1,2,3,4,5,6,7,8]),c=new d.LKRPBlock(e);expect(c.toU8A()).toBe(e)})}),describe("parse",()=>{it("should parse the block data correctly",()=>{const c=d.LKRPBlock.fromHex(b).parse();expect(c).toStrictEqual((0,a.Right)(o))}),it("should fail if the block data is invalid",()=>{const e=d.LKRPBlock.fromHex("invalid");expect(e.parse()).toStrictEqual((0,a.Left)(new r.LKRPParsingError("Unexpected end of TLV")))})}),describe("toHuman",()=>{it("should return a human-readable representation of the block",()=>{const e=`
         01 01 01
         02 20 1d bf 17 52 c5 4b 9f b5 4f b7 c3 63 c1 e6 15 f7 2f d9 61 b7 97 e6 f0 9e 6c 1d 1b 6e db 28 5a 6d
         06 21 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21
@@ -19,6 +19,6 @@
           06 21 03 d4 c6 1d da 2a af 76 29 54 fc e9 73 96 d9 be 03 99 e1 dc 75 c3 b7 90 c7 a3 4d de 85 96 a1 18 12
           06 21 02 45 f1 1d 7d 78 bd 22 76 45 11 8a bb 20 b4 07 ff 97 8d f8 7a 6b b3 c4 46 1d 63 37 66 85 8f 98 f5
         03 47 30 45 02 21 00 a0 ea 9d ee 12 f3 83 13 2f 90 72 ad 47 85 a4 15 14 75 d5 70 4a a9 ff 7f 95 52 e9 03 47 b4 ce be 02 20 71 a3 e4 4c 1f 4f a6 4b c6 e2 f4 06 fa 00 fc b4 6f 70 1c 99 49 29 12 bf 33 c7 3e df b2 d5 d1 71
-      `.replace(/\s/g,""),l=d.LKRPBlock.fromHex(e).toHuman();expect(l).toStrictEqual((0,c.Right)(["Parent: 1dbf1752c54b9fb54fb7c363c1e615f72fd961b797e6f09e6c1d1b6edb285a6d","Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021","Commands:","  Derive(0x15):","    path: m/0'/16'/1'","    groupKey: 034f37312d9babd8c032e1dd2de33da369fa1ce30f005bbba600d17330ba392cb2","    initializationVector: b6da2c97a3ec8b074f38f1508aed3335","    encryptedXpriv: d21f8f307702333f7a593bebd798a6b06eb5904277268a91350a3c1b1ee67c24b5a47d228c60d0fbc1524eac1bcf123e6e26b5d71708291cc08dcf49de0bb34bacf20093524ca6565d87c636b24475b2","    ephemeralPublicKey: 0293feb66412536d3d71d5c7afac96a36ea8c685889eebcf6f6f82685712fef150","  AddMember(0x11):","    name: debug-d4c61d","    publicKey: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    permissions: 4294967295","  PublishKey(0x12):","    initializationVector: e7b736c40b14a830fb23aaded8eae544","    encryptedXpriv: df7e808c794675d0a2d466d4efc8ecd07d52368016100d34d6fdb8e6da86e92fbbb7110cb56429b83b1cb974ed4b705143f691b5b81468abd2c526266a6dee6df4fdf1a9d81fe74cda4f61c98960b4db","    recipient: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    ephemeralPublicKey: 0245f11d7d78bd227645118abb20b407ff978df87a6bb3c4461d633766858f98f5","Signature: 3045022100a0ea9dee12f383132f9072ad4785a4151475d5704aa9ff7f9552e90347b4cebe022071a3e44c1f4fa64bc6e2f406fa00fcb46f701c99492912bf33c73edfb2d5d171"].join(`
-`)))})}),describe("hash",()=>{it("should return the hash of the block",()=>{const a=d.LKRPBlock.fromHex(b).hash();expect(a).toBe("7cf783bc15c062242ab92796237da3b192361da7645c488d5023698d4f9cc952")})})});
+      `.replace(/\s/g,""),l=d.LKRPBlock.fromHex(e).toHuman();expect(l).toStrictEqual((0,a.Right)(["Parent: 1dbf1752c54b9fb54fb7c363c1e615f72fd961b797e6f09e6c1d1b6edb285a6d","Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021","Commands:","  Derive(0x15):","    path: m/0'/16'/1'","    groupKey: 034f37312d9babd8c032e1dd2de33da369fa1ce30f005bbba600d17330ba392cb2","    initializationVector: b6da2c97a3ec8b074f38f1508aed3335","    encryptedXpriv: d21f8f307702333f7a593bebd798a6b06eb5904277268a91350a3c1b1ee67c24b5a47d228c60d0fbc1524eac1bcf123e6e26b5d71708291cc08dcf49de0bb34bacf20093524ca6565d87c636b24475b2","    ephemeralPublicKey: 0293feb66412536d3d71d5c7afac96a36ea8c685889eebcf6f6f82685712fef150","  AddMember(0x11):","    name: debug-d4c61d","    publicKey: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    permissions: 4294967295","  PublishKey(0x12):","    initializationVector: e7b736c40b14a830fb23aaded8eae544","    encryptedXpriv: df7e808c794675d0a2d466d4efc8ecd07d52368016100d34d6fdb8e6da86e92fbbb7110cb56429b83b1cb974ed4b705143f691b5b81468abd2c526266a6dee6df4fdf1a9d81fe74cda4f61c98960b4db","    recipient: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    ephemeralPublicKey: 0245f11d7d78bd227645118abb20b407ff978df87a6bb3c4461d633766858f98f5","Signature: 3045022100a0ea9dee12f383132f9072ad4785a4151475d5704aa9ff7f9552e90347b4cebe022071a3e44c1f4fa64bc6e2f406fa00fcb46f701c99492912bf33c73edfb2d5d171"].join(`
+`)))})}),describe("hash",()=>{it("should return the hash of the block",()=>{const c=d.LKRPBlock.fromHex(b).hash();expect(c).toBe("7cf783bc15c062242ab92796237da3b192361da7645c488d5023698d4f9cc952")})})});
 //# sourceMappingURL=LKRPBlock.test.js.map

package/lib/cjs/internal/utils/LKRPBlock.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/utils/LKRPBlock.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\n\nimport { LKRPParsingError } from \"@api/model/Errors\";\nimport { GeneralTags } from \"@internal/models/Tags\";\n\nimport { LKRPBlock } from \"./LKRPBlock\";\nimport { LKRPCommand } from \"./LKRPCommand\";\n\n// Mocked data for testing\nconst mockedBlockData = {\n  parent: \"0000\",\n  issuer: new Uint8Array([1, 2, 3]),\n  commands: [LKRPCommand.fromHex(\"10020102\"), LKRPCommand.fromHex(\"11020304\")],\n  signature: new Uint8Array([4, 5, 6]),\n};\nconst mockedHeaderHex = [\n  \"010101\", // Version: 1\n  \"02020000\", // Parent hash: 00 00 00\n  \"0603010203\", // Issuer: 01 02 03\n  \"010102\", // Command Count: 2\n].join(\"\");\nconst mockedBlockHex = [\n  ...mockedHeaderHex, // Header\n  \"10020102\", // Command 1\n  \"11020304\", // Command 2\n  \"0303040506\", // Signature: 04 05 06\n].join(\"\");\nconst parsedMockedBlockData = {\n  ...mockedBlockData,\n  header: hexaStringToBuffer(mockedHeaderHex)!,\n  signature: Uint8Array.from([\n    GeneralTags.Signature,\n    3,\n    ...mockedBlockData.signature,\n  ]),\n};\n\ndescribe(\"LKRPBlock\", () => {\n  describe(\"fromData\", () => {\n    it(\"should create a Block from data\", () => {\n      // WHEN\n      const block = LKRPBlock.fromData(mockedBlockData);\n      // THEN\n      expect(block.parse()).toStrictEqual(Right(parsedMockedBlockData));\n      expect(block.toString()).toBe(mockedBlockHex);\n    });\n  });\n\n  describe(\"toString\", () => {\n    it(\"should return the hex representation of the block\", () => {\n      // WHEN\n      const block = LKRPBlock.fromHex(mockedBlockHex);\n      // THEN\n      expect(block.toString()).toBe(mockedBlockHex);\n    });\n  });\n\n  describe(\"toU8A\", () => {\n    it(\"should return the bytes of the block\", () => {\n      // GIVEN\n      const bytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);\n      // WHEN\n      const block = new LKRPBlock(bytes);\n      // THEN\n      expect(block.toU8A()).toBe(bytes);\n    });\n  });\n\n  describe(\"parse\", () => {\n    it(\"should parse the block data correctly\", () => {\n      // GIVEN\n      const block = LKRPBlock.fromHex(mockedBlockHex);\n      // WHEN\n      const parsedData = block.parse();\n      // THEN\n      expect(parsedData).toStrictEqual(Right(parsedMockedBlockData));\n    });\n\n    it(\"should fail if the block data is invalid\", () => {\n      // WHEN\n      const invalidBlock = LKRPBlock.fromHex(\"invalid\");\n      // THEN\n      expect(invalidBlock.parse()).toStrictEqual(\n        Left(new LKRPParsingError(\"Unexpected end of TLV\")),\n      );\n    });\n  });\n\n  describe(\"toHuman\", () => {\n    it(\"should return a human-readable representation of the block\", () => {\n      // GIVEN\n      const hex = `\n        01 01 01\n        02 20 1d bf 17 52 c5 4b 9f b5 4f b7 c3 63 c1 e6 15 f7 2f d9 61 b7 97 e6 f0 9e 6c 1d 1b 6e db 28 5a 6d\n        06 21 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21\n        01 01 03\n        15 b8\n          05 0c 80 00 00 00 80 00 00 10 80 00 00 01\n          06 21 03 4f 37 31 2d 9b ab d8 c0 32 e1 dd 2d e3 3d a3 69 fa 1c e3 0f 00 5b bb a6 00 d1 73 30 ba 39 2c b2\n          05 10 b6 da 2c 97 a3 ec 8b 07 4f 38 f1 50 8a ed 33 35\n          05 50 d2 1f 8f 30 77 02 33 3f 7a 59 3b eb d7 98 a6 b0 6e b5 90 42 77 26 8a 91 35 0a 3c 1b 1e e6 7c 24 b5 a4 7d 22 8c 60 d0 fb c1 52 4e ac 1b cf 12 3e 6e 26 b5 d7 17 08 29 1c c0 8d cf 49 de 0b b3 4b ac f2 00 93 52 4c a6 56 5d 87 c6 36 b2 44 75 b2\n          06 21 02 93 fe b6 64 12 53 6d 3d 71 d5 c7 af ac 96 a3 6e a8 c6 85 88 9e eb cf 6f 6f 82 68 57 12 fe f1 50\n        11 37\n          04 0c 64 65 62 75 67 2d 64 34 63 36 31 64\n          06 21 03 d4 c6 1d da 2a af 76 29 54 fc e9 73 96 d9 be 03 99 e1 dc 75 c3 b7 90 c7 a3 4d de 85 96 a1 18 12\n          01 04 ff ff ff ff\n        12 aa\n          05 10 e7 b7 36 c4 0b 14 a8 30 fb 23 aa de d8 ea e5 44\n          05 50 df 7e 80 8c 79 46 75 d0 a2 d4 66 d4 ef c8 ec d0 7d 52 36 80 16 10 0d 34 d6 fd b8 e6 da 86 e9 2f bb b7 11 0c b5 64 29 b8 3b 1c b9 74 ed 4b 70 51 43 f6 91 b5 b8 14 68 ab d2 c5 26 26 6a 6d ee 6d f4 fd f1 a9 d8 1f e7 4c da 4f 61 c9 89 60 b4 db\n          06 21 03 d4 c6 1d da 2a af 76 29 54 fc e9 73 96 d9 be 03 99 e1 dc 75 c3 b7 90 c7 a3 4d de 85 96 a1 18 12\n          06 21 02 45 f1 1d 7d 78 bd 22 76 45 11 8a bb 20 b4 07 ff 97 8d f8 7a 6b b3 c4 46 1d 63 37 66 85 8f 98 f5\n        03 47 30 45 02 21 00 a0 ea 9d ee 12 f3 83 13 2f 90 72 ad 47 85 a4 15 14 75 d5 70 4a a9 ff 7f 95 52 e9 03 47 b4 ce be 02 20 71 a3 e4 4c 1f 4f a6 4b c6 e2 f4 06 fa 00 fc b4 6f 70 1c 99 49 29 12 bf 33 c7 3e df b2 d5 d1 71\n      `.replace(/\\s/g, \"\");\n\n      // WHEN\n      const block = LKRPBlock.fromHex(hex);\n      const humanReadable = block.toHuman();\n\n      // THEN\n      expect(humanReadable).toStrictEqual(\n        Right(\n          [\n            `Parent: 1dbf1752c54b9fb54fb7c363c1e615f72fd961b797e6f09e6c1d1b6edb285a6d`,\n            `Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021`,\n            `Commands:`,\n            `  Derive(0x15):`,\n            `    path: m/0'/16'/1'`,\n            `    groupKey: 034f37312d9babd8c032e1dd2de33da369fa1ce30f005bbba600d17330ba392cb2`,\n            `    initializationVector: b6da2c97a3ec8b074f38f1508aed3335`,\n            `    encryptedXpriv: d21f8f307702333f7a593bebd798a6b06eb5904277268a91350a3c1b1ee67c24b5a47d228c60d0fbc1524eac1bcf123e6e26b5d71708291cc08dcf49de0bb34bacf20093524ca6565d87c636b24475b2`,\n            `    ephemeralPublicKey: 0293feb66412536d3d71d5c7afac96a36ea8c685889eebcf6f6f82685712fef150`,\n            `  AddMember(0x11):`,\n            `    name: debug-d4c61d`,\n            `    publicKey: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812`,\n            `    permissions: 4294967295`,\n            `  PublishKey(0x12):`,\n            `    initializationVector: e7b736c40b14a830fb23aaded8eae544`,\n            `    encryptedXpriv: df7e808c794675d0a2d466d4efc8ecd07d52368016100d34d6fdb8e6da86e92fbbb7110cb56429b83b1cb974ed4b705143f691b5b81468abd2c526266a6dee6df4fdf1a9d81fe74cda4f61c98960b4db`,\n            `    recipient: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812`,\n            `    ephemeralPublicKey: 0245f11d7d78bd227645118abb20b407ff978df87a6bb3c4461d633766858f98f5`,\n            `Signature: 3045022100a0ea9dee12f383132f9072ad4785a4151475d5704aa9ff7f9552e90347b4cebe022071a3e44c1f4fa64bc6e2f406fa00fcb46f701c99492912bf33c73edfb2d5d171`,\n          ].join(\"\\n\"),\n        ),\n      );\n    });\n  });\n\n  describe(\"hash\", () => {\n    it(\"should return the hash of the block\", () => {\n      // GIVEN\n      const block = LKRPBlock.fromHex(mockedBlockHex);\n      // WHEN\n      const hash = block.hash();\n      // THEN\n      expect(hash).toBe(\n        \"7cf783bc15c062242ab92796237da3b192361da7645c488d5023698d4f9cc952\",\n      );\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAAmC,2CACnCC,EAA4B,qBAE5BC,EAAiC,6BACjCC,EAA4B,iCAE5BC,EAA0B,uBAC1BC,EAA4B,yBAG5B,MAAMC,EAAkB,CACtB,OAAQ,OACR,OAAQ,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,EAChC,SAAU,CAAC,cAAY,QAAQ,UAAU,EAAG,cAAY,QAAQ,UAAU,CAAC,EAC3E,UAAW,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,CACrC,EACMC,EAAkB,CACtB,SACA,WACA,aACA,QACF,EAAE,KAAK,EAAE,EACHC,EAAiB,CACrB,GAAGD,EACH,WACA,WACA,YACF,EAAE,KAAK,EAAE,EACHE,EAAwB,CAC5B,GAAGH,EACH,UAAQ,sBAAmBC,CAAe,EAC1C,UAAW,WAAW,KAAK,CACzB,cAAY,UACZ,EACA,GAAGD,EAAgB,SACrB,CAAC,CACH,EAEA,SAAS,YAAa,IAAM,CAC1B,SAAS,WAAY,IAAM,CACzB,GAAG,kCAAmC,IAAM,CAE1C,MAAMI,EAAQ,YAAU,SAASJ,CAAe,EAEhD,OAAOI,EAAM,MAAM,CAAC,EAAE,iBAAc,SAAMD,CAAqB,CAAC,EAChE,OAAOC,EAAM,SAAS,CAAC,EAAE,KAAKF,CAAc,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,WAAY,IAAM,CACzB,GAAG,oDAAqD,IAAM,CAE5D,MAAME,EAAQ,YAAU,QAAQF,CAAc,EAE9C,OAAOE,EAAM,SAAS,CAAC,EAAE,KAAKF,CAAc,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,uCAAwC,IAAM,CAE/C,MAAMG,EAAQ,IAAI,WAAW,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,CAAC,CAAC,EAE/CD,EAAQ,IAAI,YAAUC,CAAK,EAEjC,OAAOD,EAAM,MAAM,CAAC,EAAE,KAAKC,CAAK,CAClC,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,wCAAyC,IAAM,CAIhD,MAAMC,EAFQ,YAAU,QAAQJ,CAAc,EAErB,MAAM,EAE/B,OAAOI,CAAU,EAAE,iBAAc,SAAMH,CAAqB,CAAC,CAC/D,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMI,EAAe,YAAU,QAAQ,SAAS,EAEhD,OAAOA,EAAa,MAAM,CAAC,EAAE,iBAC3B,QAAK,IAAI,mBAAiB,uBAAuB,CAAC,CACpD,CACF,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6DAA8D,IAAM,CAErE,MAAMC,EAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAqBV,QAAQ,MAAO,EAAE,EAIbC,EADQ,YAAU,QAAQD,CAAG,EACP,QAAQ,EAGpC,OAAOC,CAAa,EAAE,iBACpB,SACE,CACE,2EACA,6EACA,YACA,kBACA,wBACA,mFACA,6DACA,uLACA,6FACA,qBACA,yBACA,oFACA,8BACA,sBACA,6DACA,uLACA,oFACA,6FACA,2JACF,EAAE,KAAK;AAAA,CAAI,CACb,CACF,CACF,CAAC,CACH,CAAC,EAED,SAAS,OAAQ,IAAM,CACrB,GAAG,sCAAuC,IAAM,CAI9C,MAAMC,EAFQ,YAAU,QAAQR,CAAc,EAE3B,KAAK,EAExB,OAAOQ,CAAI,EAAE,KACX,kEACF,CACF,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["import_device_management_kit", "import_purify_ts", "import_Errors", "import_Tags", "import_LKRPBlock", "import_LKRPCommand", "mockedBlockData", "mockedHeaderHex", "mockedBlockHex", "parsedMockedBlockData", "block", "bytes", "parsedData", "invalidBlock", "hex", "humanReadable", "hash"]
+  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { LKRPParsingError } from \"@api/app-binder/Errors\";\nimport { GeneralTags } from \"@internal/models/Tags\";\n\nimport { hexToBytes } from \"./hex\";\nimport { LKRPBlock } from \"./LKRPBlock\";\nimport { LKRPCommand } from \"./LKRPCommand\";\n\n// Mocked data for testing\nconst mockedBlockData = {\n  parent: \"0000\",\n  issuer: new Uint8Array([1, 2, 3]),\n  commands: [LKRPCommand.fromHex(\"10020102\"), LKRPCommand.fromHex(\"11020304\")],\n  signature: new Uint8Array([4, 5, 6]),\n};\nconst mockedHeaderHex = [\n  \"010101\", // Version: 1\n  \"02020000\", // Parent hash: 00 00 00\n  \"0603010203\", // Issuer: 01 02 03\n  \"010102\", // Command Count: 2\n].join(\"\");\nconst mockedBlockHex = [\n  ...mockedHeaderHex, // Header\n  \"10020102\", // Command 1\n  \"11020304\", // Command 2\n  \"0303040506\", // Signature: 04 05 06\n].join(\"\");\nconst parsedMockedBlockData = {\n  ...mockedBlockData,\n  header: hexToBytes(mockedHeaderHex),\n  signature: Uint8Array.from([\n    GeneralTags.Signature,\n    3,\n    ...mockedBlockData.signature,\n  ]),\n};\n\ndescribe(\"LKRPBlock\", () => {\n  describe(\"fromData\", () => {\n    it(\"should create a Block from data\", () => {\n      // WHEN\n      const block = LKRPBlock.fromData(mockedBlockData);\n      // THEN\n      expect(block.parse()).toStrictEqual(Right(parsedMockedBlockData));\n      expect(block.toString()).toBe(mockedBlockHex);\n    });\n  });\n\n  describe(\"toString\", () => {\n    it(\"should return the hex representation of the block\", () => {\n      // WHEN\n      const block = LKRPBlock.fromHex(mockedBlockHex);\n      // THEN\n      expect(block.toString()).toBe(mockedBlockHex);\n    });\n  });\n\n  describe(\"toU8A\", () => {\n    it(\"should return the bytes of the block\", () => {\n      // GIVEN\n      const bytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);\n      // WHEN\n      const block = new LKRPBlock(bytes);\n      // THEN\n      expect(block.toU8A()).toBe(bytes);\n    });\n  });\n\n  describe(\"parse\", () => {\n    it(\"should parse the block data correctly\", () => {\n      // GIVEN\n      const block = LKRPBlock.fromHex(mockedBlockHex);\n      // WHEN\n      const parsedData = block.parse();\n      // THEN\n      expect(parsedData).toStrictEqual(Right(parsedMockedBlockData));\n    });\n\n    it(\"should fail if the block data is invalid\", () => {\n      // WHEN\n      const invalidBlock = LKRPBlock.fromHex(\"invalid\");\n      // THEN\n      expect(invalidBlock.parse()).toStrictEqual(\n        Left(new LKRPParsingError(\"Unexpected end of TLV\")),\n      );\n    });\n  });\n\n  describe(\"toHuman\", () => {\n    it(\"should return a human-readable representation of the block\", () => {\n      // GIVEN\n      const hex = `\n        01 01 01\n        02 20 1d bf 17 52 c5 4b 9f b5 4f b7 c3 63 c1 e6 15 f7 2f d9 61 b7 97 e6 f0 9e 6c 1d 1b 6e db 28 5a 6d\n        06 21 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21\n        01 01 03\n        15 b8\n          05 0c 80 00 00 00 80 00 00 10 80 00 00 01\n          06 21 03 4f 37 31 2d 9b ab d8 c0 32 e1 dd 2d e3 3d a3 69 fa 1c e3 0f 00 5b bb a6 00 d1 73 30 ba 39 2c b2\n          05 10 b6 da 2c 97 a3 ec 8b 07 4f 38 f1 50 8a ed 33 35\n          05 50 d2 1f 8f 30 77 02 33 3f 7a 59 3b eb d7 98 a6 b0 6e b5 90 42 77 26 8a 91 35 0a 3c 1b 1e e6 7c 24 b5 a4 7d 22 8c 60 d0 fb c1 52 4e ac 1b cf 12 3e 6e 26 b5 d7 17 08 29 1c c0 8d cf 49 de 0b b3 4b ac f2 00 93 52 4c a6 56 5d 87 c6 36 b2 44 75 b2\n          06 21 02 93 fe b6 64 12 53 6d 3d 71 d5 c7 af ac 96 a3 6e a8 c6 85 88 9e eb cf 6f 6f 82 68 57 12 fe f1 50\n        11 37\n          04 0c 64 65 62 75 67 2d 64 34 63 36 31 64\n          06 21 03 d4 c6 1d da 2a af 76 29 54 fc e9 73 96 d9 be 03 99 e1 dc 75 c3 b7 90 c7 a3 4d de 85 96 a1 18 12\n          01 04 ff ff ff ff\n        12 aa\n          05 10 e7 b7 36 c4 0b 14 a8 30 fb 23 aa de d8 ea e5 44\n          05 50 df 7e 80 8c 79 46 75 d0 a2 d4 66 d4 ef c8 ec d0 7d 52 36 80 16 10 0d 34 d6 fd b8 e6 da 86 e9 2f bb b7 11 0c b5 64 29 b8 3b 1c b9 74 ed 4b 70 51 43 f6 91 b5 b8 14 68 ab d2 c5 26 26 6a 6d ee 6d f4 fd f1 a9 d8 1f e7 4c da 4f 61 c9 89 60 b4 db\n          06 21 03 d4 c6 1d da 2a af 76 29 54 fc e9 73 96 d9 be 03 99 e1 dc 75 c3 b7 90 c7 a3 4d de 85 96 a1 18 12\n          06 21 02 45 f1 1d 7d 78 bd 22 76 45 11 8a bb 20 b4 07 ff 97 8d f8 7a 6b b3 c4 46 1d 63 37 66 85 8f 98 f5\n        03 47 30 45 02 21 00 a0 ea 9d ee 12 f3 83 13 2f 90 72 ad 47 85 a4 15 14 75 d5 70 4a a9 ff 7f 95 52 e9 03 47 b4 ce be 02 20 71 a3 e4 4c 1f 4f a6 4b c6 e2 f4 06 fa 00 fc b4 6f 70 1c 99 49 29 12 bf 33 c7 3e df b2 d5 d1 71\n      `.replace(/\\s/g, \"\");\n\n      // WHEN\n      const block = LKRPBlock.fromHex(hex);\n      const humanReadable = block.toHuman();\n\n      // THEN\n      expect(humanReadable).toStrictEqual(\n        Right(\n          [\n            `Parent: 1dbf1752c54b9fb54fb7c363c1e615f72fd961b797e6f09e6c1d1b6edb285a6d`,\n            `Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021`,\n            `Commands:`,\n            `  Derive(0x15):`,\n            `    path: m/0'/16'/1'`,\n            `    groupKey: 034f37312d9babd8c032e1dd2de33da369fa1ce30f005bbba600d17330ba392cb2`,\n            `    initializationVector: b6da2c97a3ec8b074f38f1508aed3335`,\n            `    encryptedXpriv: d21f8f307702333f7a593bebd798a6b06eb5904277268a91350a3c1b1ee67c24b5a47d228c60d0fbc1524eac1bcf123e6e26b5d71708291cc08dcf49de0bb34bacf20093524ca6565d87c636b24475b2`,\n            `    ephemeralPublicKey: 0293feb66412536d3d71d5c7afac96a36ea8c685889eebcf6f6f82685712fef150`,\n            `  AddMember(0x11):`,\n            `    name: debug-d4c61d`,\n            `    publicKey: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812`,\n            `    permissions: 4294967295`,\n            `  PublishKey(0x12):`,\n            `    initializationVector: e7b736c40b14a830fb23aaded8eae544`,\n            `    encryptedXpriv: df7e808c794675d0a2d466d4efc8ecd07d52368016100d34d6fdb8e6da86e92fbbb7110cb56429b83b1cb974ed4b705143f691b5b81468abd2c526266a6dee6df4fdf1a9d81fe74cda4f61c98960b4db`,\n            `    recipient: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812`,\n            `    ephemeralPublicKey: 0245f11d7d78bd227645118abb20b407ff978df87a6bb3c4461d633766858f98f5`,\n            `Signature: 3045022100a0ea9dee12f383132f9072ad4785a4151475d5704aa9ff7f9552e90347b4cebe022071a3e44c1f4fa64bc6e2f406fa00fcb46f701c99492912bf33c73edfb2d5d171`,\n          ].join(\"\\n\"),\n        ),\n      );\n    });\n  });\n\n  describe(\"hash\", () => {\n    it(\"should return the hash of the block\", () => {\n      // GIVEN\n      const block = LKRPBlock.fromHex(mockedBlockHex);\n      // WHEN\n      const hash = block.hash();\n      // THEN\n      expect(hash).toBe(\n        \"7cf783bc15c062242ab92796237da3b192361da7645c488d5023698d4f9cc952\",\n      );\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAA4B,qBAE5BC,EAAiC,kCACjCC,EAA4B,iCAE5BC,EAA2B,iBAC3BC,EAA0B,uBAC1BC,EAA4B,yBAG5B,MAAMC,EAAkB,CACtB,OAAQ,OACR,OAAQ,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,EAChC,SAAU,CAAC,cAAY,QAAQ,UAAU,EAAG,cAAY,QAAQ,UAAU,CAAC,EAC3E,UAAW,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,CACrC,EACMC,EAAkB,CACtB,SACA,WACA,aACA,QACF,EAAE,KAAK,EAAE,EACHC,EAAiB,CACrB,GAAGD,EACH,WACA,WACA,YACF,EAAE,KAAK,EAAE,EACHE,EAAwB,CAC5B,GAAGH,EACH,UAAQ,cAAWC,CAAe,EAClC,UAAW,WAAW,KAAK,CACzB,cAAY,UACZ,EACA,GAAGD,EAAgB,SACrB,CAAC,CACH,EAEA,SAAS,YAAa,IAAM,CAC1B,SAAS,WAAY,IAAM,CACzB,GAAG,kCAAmC,IAAM,CAE1C,MAAMI,EAAQ,YAAU,SAASJ,CAAe,EAEhD,OAAOI,EAAM,MAAM,CAAC,EAAE,iBAAc,SAAMD,CAAqB,CAAC,EAChE,OAAOC,EAAM,SAAS,CAAC,EAAE,KAAKF,CAAc,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,WAAY,IAAM,CACzB,GAAG,oDAAqD,IAAM,CAE5D,MAAME,EAAQ,YAAU,QAAQF,CAAc,EAE9C,OAAOE,EAAM,SAAS,CAAC,EAAE,KAAKF,CAAc,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,uCAAwC,IAAM,CAE/C,MAAMG,EAAQ,IAAI,WAAW,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,CAAC,CAAC,EAE/CD,EAAQ,IAAI,YAAUC,CAAK,EAEjC,OAAOD,EAAM,MAAM,CAAC,EAAE,KAAKC,CAAK,CAClC,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,wCAAyC,IAAM,CAIhD,MAAMC,EAFQ,YAAU,QAAQJ,CAAc,EAErB,MAAM,EAE/B,OAAOI,CAAU,EAAE,iBAAc,SAAMH,CAAqB,CAAC,CAC/D,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMI,EAAe,YAAU,QAAQ,SAAS,EAEhD,OAAOA,EAAa,MAAM,CAAC,EAAE,iBAC3B,QAAK,IAAI,mBAAiB,uBAAuB,CAAC,CACpD,CACF,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6DAA8D,IAAM,CAErE,MAAMC,EAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAqBV,QAAQ,MAAO,EAAE,EAIbC,EADQ,YAAU,QAAQD,CAAG,EACP,QAAQ,EAGpC,OAAOC,CAAa,EAAE,iBACpB,SACE,CACE,2EACA,6EACA,YACA,kBACA,wBACA,mFACA,6DACA,uLACA,6FACA,qBACA,yBACA,oFACA,8BACA,sBACA,6DACA,uLACA,oFACA,6FACA,2JACF,EAAE,KAAK;AAAA,CAAI,CACb,CACF,CACF,CAAC,CACH,CAAC,EAED,SAAS,OAAQ,IAAM,CACrB,GAAG,sCAAuC,IAAM,CAI9C,MAAMC,EAFQ,YAAU,QAAQR,CAAc,EAE3B,KAAK,EAExB,OAAOQ,CAAI,EAAE,KACX,kEACF,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["import_purify_ts", "import_Errors", "import_Tags", "import_hex", "import_LKRPBlock", "import_LKRPCommand", "mockedBlockData", "mockedHeaderHex", "mockedBlockHex", "parsedMockedBlockData", "block", "bytes", "parsedData", "invalidBlock", "hex", "humanReadable", "hash"]
 }

package/lib/cjs/internal/utils/LKRPBlockStream.js CHANGED Viewed

@@ -1,4 +1,4 @@
-"use strict";var p=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var d=(c,e)=>{for(var o in e)p(c,o,{get:e[o],enumerable:!0})},K=(c,e,o,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of P(e))!g.call(c,a)&&a!==o&&p(c,a,{get:()=>e[a],enumerable:!(t=b(e,a))||t.enumerable});return c};var k=c=>K(p({},"__esModule",{value:!0}),c);var M={};d(M,{LKRPBlockStream:()=>l});module.exports=k(M);var y=require("@ledgerhq/device-management-kit"),r=require("purify-ts"),u=require("../../api/crypto/CryptoService"),h=require("../models/Tags"),m=require("./LKRPBlock"),f=require("./TLVParser");class l{constructor(e,o){this.bytes=e;this.blocks=o?(0,r.Just)((0,r.Right)(o)):r.Nothing}validation=r.Nothing;blocks=r.Nothing;path=r.Nothing;static fromHex(e){return new l((0,y.hexaStringToBuffer)(e)??new Uint8Array)}static fromData(e,o){const t=[];let a=o??(0,y.bufferToHexaString)(crypto.getRandomValues(new Uint8Array(32)),!1);for(const i of e){const n=m.LKRPBlock.fromData({...i,parent:a});a=n.hash(),t.push(n)}const s=t.reduce((i,n)=>new Uint8Array([...i,...n.toU8A()]),new Uint8Array);return new l(s,t)}toU8A(){return this.bytes}toString(){return(0,y.bufferToHexaString)(this.bytes,!1)}parse(){return this.blocks.orDefaultLazy(()=>{const e=new f.TLVParser(this.bytes),o=[];for(;!e.state.isDone;){const a=e.state.offset,s=e.parseBlockData().map(i=>{const n=e.state.offset;return new m.LKRPBlock(this.bytes.slice(a,n),i)});if(o.push(s),s.isLeft())break}const t=r.Either.sequence(o);return this.blocks=(0,r.Just)(t),t})}toHuman(){return this.parse().map(e=>e.map(o=>o.toHuman())).chain(r.Either.sequence).map(e=>e.join(`
+"use strict";var l=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var g=(c,t)=>{for(var r in t)l(c,r,{get:t[r],enumerable:!0})},K=(c,t,r,a)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of P(t))!d.call(c,e)&&e!==r&&l(c,e,{get:()=>t[e],enumerable:!(a=f(t,e))||a.enumerable});return c};var k=c=>K(l({},"__esModule",{value:!0}),c);var L={};g(L,{LKRPBlockStream:()=>h});module.exports=k(L);var o=require("purify-ts"),y=require("../models/Tags"),u=require("../utils/crypto"),p=require("./hex"),m=require("./LKRPBlock"),b=require("./TLVParser");class h{constructor(t,r){this.bytes=t;this.blocks=r?(0,o.Just)((0,o.Right)(r)):o.Nothing}validation=o.Nothing;blocks=o.Nothing;path=o.Nothing;static fromHex(t){return new h((0,p.hexToBytes)(t))}static fromData(t,r){const a=[];let e=r??(0,p.bytesToHex)(crypto.getRandomValues(new Uint8Array(32)));for(const n of t){const i=m.LKRPBlock.fromData({...n,parent:e});e=i.hash(),a.push(i)}const s=a.reduce((n,i)=>new Uint8Array([...n,...i.toU8A()]),new Uint8Array);return new h(s,a)}toU8A(){return this.bytes}toString(){return(0,p.bytesToHex)(this.bytes)}parse(){return this.blocks.orDefaultLazy(()=>{const t=new b.TLVParser(this.bytes),r=[];for(;!t.state.isDone;){const e=t.state.offset,s=t.parseBlockData().map(n=>{const i=t.state.offset;return new m.LKRPBlock(this.bytes.slice(e,i),n)});if(r.push(s),s.isLeft())break}const a=o.Either.sequence(r);return this.blocks=(0,o.Just)(a),a})}toHuman(){return this.parse().map(t=>t.map(r=>r.toHuman())).chain(o.Either.sequence).map(t=>t.join(`
-`))}async validate(e){return this.validation.orDefaultLazy(async()=>this.parse().map(t=>t.map(a=>a.parse().map(({parent:s})=>({parent:s,hash:()=>a.hash()})))).chain(r.Either.sequence).toMaybe().map(async t=>{if(e&&t[0]&&e!==t[0].parent)return!1;for await(const[a,s]of t.entries()){const i=t[a+1];if(i&&s.hash()!==i.parent)return!1}return!0}).orDefault(Promise.resolve(!1)))}getPath(){return this.path.ifNothing(()=>{this.path=this.parse().toMaybe().chainNullable(e=>e[0]).chain(e=>e.parse().toMaybe()).chainNullable(({commands:e})=>e[0]).chain(e=>e.parse().toMaybe()).chain(e=>{switch(e.type){case h.CommandTags.Derive:return(0,r.Just)(e.path);case h.CommandTags.Seed:return(0,r.Just)("m/0'");default:return r.Nothing}})}),this.path}getMemberBlock(e){return this.parse().toMaybe().chain(o=>{for(const t of o){const a=t.parse();if(a.isRight()){const s=a.extract();for(const i of s.commands){const n=i.getPublicKey();if(n.isJust()&&n.extract()===e)return r.Maybe.of(s)}}}return r.Nothing})}hasMember(e){return this.getMemberBlock(e).isJust()}async getPublishedKey(e,o){return r.MaybeAsync.liftMaybe(this.getMemberBlock(o.getPublicKeyToHex()).chain(t=>{for(const a of t.commands){const s=a.getEncryptedPublishedKey();if(s.isJust())return s}return r.Nothing})).map(async t=>{const a=(await o.deriveSharedSecret(t.ephemeralPublicKey)).slice(1),i=await e.importSymmetricKey(a,u.EncryptionAlgo.AES256_GCM).decrypt(t.initializationVector,t.encryptedXpriv);return{privateKey:i.slice(0,32),chainCode:i.slice(32)}})}}0&&(module.exports={LKRPBlockStream});
+`))}async validate(t){return this.validation.orDefaultLazy(async()=>this.parse().map(a=>a.map(e=>e.parse().map(({parent:s})=>({parent:s,hash:()=>e.hash()})))).chain(o.Either.sequence).toMaybe().map(async a=>{if(t&&a[0]&&t!==a[0].parent)return!1;for await(const[e,s]of a.entries()){const n=a[e+1];if(n&&s.hash()!==n.parent)return!1}return!0}).orDefault(Promise.resolve(!1)))}getPath(){return this.path.ifNothing(()=>{this.path=this.parse().toMaybe().chainNullable(t=>t[0]).chain(t=>t.parse().toMaybe()).chainNullable(({commands:t})=>t[0]).chain(t=>t.parse().toMaybe()).chain(t=>{switch(t.type){case y.CommandTags.Derive:return(0,o.Just)(t.path);case y.CommandTags.Seed:return(0,o.Just)("m/0'");default:return o.Nothing}})}),this.path}getMemberBlock(t){return this.parse().toMaybe().chain(r=>{for(const a of r){const e=a.parse();if(e.isRight()){const s=e.extract();for(const n of s.commands){const i=n.getPublicKey();if(i.isJust()&&i.extract()===t)return o.Maybe.of(s)}}}return o.Nothing})}hasMember(t){return this.getMemberBlock(t).isJust()}getPublishedKey(t){return this.getMemberBlock(t.pubKeyToHex()).chain(r=>{for(const a of r.commands){const e=a.getEncryptedPublishedKey();if(e.isJust())return e}return o.Nothing}).map(r=>{const a=t.ecdh(r.ephemeralPublicKey).slice(1),e=u.CryptoUtils.decrypt(a,r.initializationVector,r.encryptedXpriv);return{privateKey:e.slice(0,32),chainCode:e.slice(32)}})}}0&&(module.exports={LKRPBlockStream});
 //# sourceMappingURL=LKRPBlockStream.js.map

package/lib/cjs/internal/utils/LKRPBlockStream.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/utils/LKRPBlockStream.ts"],
-  "sourcesContent": ["import {\n  bufferToHexaString,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { Either, Just, Maybe, MaybeAsync, Nothing, Right } from \"purify-ts\";\n\nimport { type CryptoService, EncryptionAlgo } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport { type LKRPParsingError } from \"@api/model/Errors\";\nimport { type LKRPBlockData } from \"@internal/models/LKRPBlockTypes\";\nimport { CommandTags } from \"@internal/models/Tags\";\nimport {\n  type EncryptedPublishedKey,\n  type PublishedKey,\n} from \"@internal/models/Types\";\n\nimport { LKRPBlock } from \"./LKRPBlock\";\nimport { TLVParser } from \"./TLVParser\";\n\nexport class LKRPBlockStream {\n  private validation: Maybe<Promise<boolean>> = Nothing;\n  private blocks: Maybe<Either<LKRPParsingError, LKRPBlock[]>> = Nothing;\n  private path: Maybe<string> = Nothing;\n\n  constructor(\n    private readonly bytes: Uint8Array,\n    blocks?: LKRPBlock[],\n  ) {\n    this.blocks = blocks ? Just(Right(blocks)) : Nothing;\n  }\n\n  static fromHex(hex: string): LKRPBlockStream {\n    return new LKRPBlockStream(hexaStringToBuffer(hex) ?? new Uint8Array());\n  }\n\n  static fromData(\n    blocksData: Omit<LKRPBlockData, \"parent\">[],\n    parentHash?: string,\n  ): LKRPBlockStream {\n    const blocks: LKRPBlock[] = [];\n    let hash =\n      parentHash ??\n      bufferToHexaString(crypto.getRandomValues(new Uint8Array(32)), false);\n\n    for (const blockData of blocksData) {\n      const block = LKRPBlock.fromData({\n        ...blockData,\n        parent: hash,\n      });\n      hash = block.hash();\n      blocks.push(block);\n    }\n    const bytes = blocks.reduce(\n      (acc, block) => new Uint8Array([...acc, ...block.toU8A()]),\n      new Uint8Array(),\n    );\n    return new LKRPBlockStream(bytes, blocks);\n  }\n\n  toU8A(): Uint8Array {\n    return this.bytes;\n  }\n\n  toString(): string {\n    return bufferToHexaString(this.bytes, false);\n  }\n\n  parse(): Either<LKRPParsingError, LKRPBlock[]> {\n    return this.blocks.orDefaultLazy(() => {\n      const parser = new TLVParser(this.bytes);\n      const parsed: Either<LKRPParsingError, LKRPBlock>[] = [];\n      while (!parser.state.isDone) {\n        const start = parser.state.offset;\n        const block = parser.parseBlockData().map((data) => {\n          const end = parser.state.offset;\n          return new LKRPBlock(this.bytes.slice(start, end), data);\n        });\n        parsed.push(block);\n        if (block.isLeft()) break;\n      }\n      const blocks = Either.sequence(parsed);\n      this.blocks = Just(blocks);\n      return blocks;\n    });\n  }\n\n  toHuman(): Either<LKRPParsingError, string> {\n    return this.parse()\n      .map((blocks) => blocks.map((block) => block.toHuman()))\n      .chain(Either.sequence)\n      .map((blocks) => blocks.join(\"\\n\\n\"));\n  }\n\n  async validate(streamParentHash?: string): Promise<boolean> {\n    return this.validation.orDefaultLazy(async () => {\n      const validation = this.parse()\n        .map((blocks) =>\n          blocks.map((block) =>\n            block\n              .parse()\n              .map(({ parent }) => ({ parent, hash: () => block.hash() })),\n          ),\n        )\n        .chain(Either.sequence)\n        .toMaybe()\n        .map(async (blocks) => {\n          if (\n            streamParentHash &&\n            blocks[0] &&\n            streamParentHash !== blocks[0].parent\n          ) {\n            return false;\n          }\n\n          for await (const [index, block] of blocks.entries()) {\n            const nextBlock = blocks[index + 1];\n            if (nextBlock && block.hash() !== nextBlock.parent) {\n              return false;\n            }\n          }\n          return true;\n        })\n        .orDefault(Promise.resolve(false));\n\n      return validation;\n    });\n  }\n\n  getPath(): Maybe<string> {\n    this.path.ifNothing(() => {\n      this.path = this.parse()\n        .toMaybe()\n        .chainNullable((blocks) => blocks[0])\n        .chain((block) => block.parse().toMaybe())\n        .chainNullable(({ commands }) => commands[0])\n        .chain((command) => command.parse().toMaybe())\n        .chain((data) => {\n          switch (data.type) {\n            case CommandTags.Derive:\n              return Just(data.path);\n            case CommandTags.Seed:\n              return Just(\"m/0'\");\n            default:\n              return Nothing;\n          }\n        });\n    });\n    return this.path;\n  }\n\n  getMemberBlock(member: string): Maybe<LKRPBlockData> {\n    return this.parse()\n      .toMaybe()\n      .chain((blocks) => {\n        for (const block of blocks) {\n          const parsedBlock = block.parse();\n          if (parsedBlock.isRight()) {\n            const blockData = parsedBlock.extract();\n            for (const command of blockData.commands) {\n              const pubkey = command.getPublicKey();\n              if (pubkey.isJust() && pubkey.extract() === member) {\n                return Maybe.of(blockData);\n              }\n            }\n          }\n        }\n        return Nothing;\n      });\n  }\n\n  hasMember(member: string): boolean {\n    return this.getMemberBlock(member).isJust();\n  }\n\n  async getPublishedKey(\n    cryptoService: CryptoService,\n    keypair: KeyPair,\n  ): Promise<Maybe<PublishedKey>> {\n    return MaybeAsync.liftMaybe(\n      this.getMemberBlock(keypair.getPublicKeyToHex()).chain(\n        (block): Maybe<EncryptedPublishedKey> => {\n          for (const command of block.commands) {\n            const key = command.getEncryptedPublishedKey();\n            if (key.isJust()) {\n              return key;\n            }\n          }\n          return Nothing;\n        },\n      ),\n    ).map(async (published) => {\n      const secret = (\n        await keypair.deriveSharedSecret(published.ephemeralPublicKey)\n      ).slice(1);\n      const key = cryptoService.importSymmetricKey(\n        secret,\n        EncryptionAlgo.AES256_GCM,\n      );\n      const xpriv = await key.decrypt(\n        published.initializationVector,\n        published.encryptedXpriv,\n      );\n      return { privateKey: xpriv.slice(0, 32), chainCode: xpriv.slice(32) };\n    });\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["LKRPBlockStream_exports", "__export", "LKRPBlockStream", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_CryptoService", "import_Tags", "import_LKRPBlock", "import_TLVParser", "bytes", "blocks", "hex", "blocksData", "parentHash", "hash", "blockData", "block", "acc", "parser", "parsed", "start", "data", "end", "streamParentHash", "parent", "index", "nextBlock", "commands", "command", "member", "parsedBlock", "pubkey", "cryptoService", "keypair", "key", "published", "secret", "xpriv"]
+  "sourcesContent": ["import { Either, Just, Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { type LKRPParsingError } from \"@api/app-binder/Errors\";\nimport { type Keypair } from \"@api/app-binder/LKRPTypes\";\nimport { type LKRPBlockData } from \"@internal/models/LKRPBlockTypes\";\nimport { CommandTags } from \"@internal/models/Tags\";\nimport {\n  type EncryptedPublishedKey,\n  type PublishedKey,\n} from \"@internal/models/Types\";\nimport { CryptoUtils } from \"@internal/utils/crypto\";\n\nimport { bytesToHex, hexToBytes } from \"./hex\";\nimport { LKRPBlock } from \"./LKRPBlock\";\nimport { TLVParser } from \"./TLVParser\";\n\nexport class LKRPBlockStream {\n  private validation: Maybe<Promise<boolean>> = Nothing;\n  private blocks: Maybe<Either<LKRPParsingError, LKRPBlock[]>> = Nothing;\n  private path: Maybe<string> = Nothing;\n\n  constructor(\n    private readonly bytes: Uint8Array,\n    blocks?: LKRPBlock[],\n  ) {\n    this.blocks = blocks ? Just(Right(blocks)) : Nothing;\n  }\n\n  static fromHex(hex: string): LKRPBlockStream {\n    return new LKRPBlockStream(hexToBytes(hex));\n  }\n\n  static fromData(\n    blocksData: Omit<LKRPBlockData, \"parent\">[],\n    parentHash?: string,\n  ): LKRPBlockStream {\n    const blocks: LKRPBlock[] = [];\n    let hash =\n      parentHash ?? bytesToHex(crypto.getRandomValues(new Uint8Array(32)));\n\n    for (const blockData of blocksData) {\n      const block = LKRPBlock.fromData({\n        ...blockData,\n        parent: hash,\n      });\n      hash = block.hash();\n      blocks.push(block);\n    }\n    const bytes = blocks.reduce(\n      (acc, block) => new Uint8Array([...acc, ...block.toU8A()]),\n      new Uint8Array(),\n    );\n    return new LKRPBlockStream(bytes, blocks);\n  }\n\n  toU8A(): Uint8Array {\n    return this.bytes;\n  }\n\n  toString(): string {\n    return bytesToHex(this.bytes);\n  }\n\n  parse(): Either<LKRPParsingError, LKRPBlock[]> {\n    return this.blocks.orDefaultLazy(() => {\n      const parser = new TLVParser(this.bytes);\n      const parsed: Either<LKRPParsingError, LKRPBlock>[] = [];\n      while (!parser.state.isDone) {\n        const start = parser.state.offset;\n        const block = parser.parseBlockData().map((data) => {\n          const end = parser.state.offset;\n          return new LKRPBlock(this.bytes.slice(start, end), data);\n        });\n        parsed.push(block);\n        if (block.isLeft()) break;\n      }\n      const blocks = Either.sequence(parsed);\n      this.blocks = Just(blocks);\n      return blocks;\n    });\n  }\n\n  toHuman(): Either<LKRPParsingError, string> {\n    return this.parse()\n      .map((blocks) => blocks.map((block) => block.toHuman()))\n      .chain(Either.sequence)\n      .map((blocks) => blocks.join(\"\\n\\n\"));\n  }\n\n  async validate(streamParentHash?: string): Promise<boolean> {\n    return this.validation.orDefaultLazy(async () => {\n      const validation = this.parse()\n        .map((blocks) =>\n          blocks.map((block) =>\n            block\n              .parse()\n              .map(({ parent }) => ({ parent, hash: () => block.hash() })),\n          ),\n        )\n        .chain(Either.sequence)\n        .toMaybe()\n        .map(async (blocks) => {\n          if (\n            streamParentHash &&\n            blocks[0] &&\n            streamParentHash !== blocks[0].parent\n          ) {\n            return false;\n          }\n\n          for await (const [index, block] of blocks.entries()) {\n            const nextBlock = blocks[index + 1];\n            if (nextBlock && block.hash() !== nextBlock.parent) {\n              return false;\n            }\n          }\n          return true;\n        })\n        .orDefault(Promise.resolve(false));\n\n      return validation;\n    });\n  }\n\n  getPath(): Maybe<string> {\n    this.path.ifNothing(() => {\n      this.path = this.parse()\n        .toMaybe()\n        .chainNullable((blocks) => blocks[0])\n        .chain((block) => block.parse().toMaybe())\n        .chainNullable(({ commands }) => commands[0])\n        .chain((command) => command.parse().toMaybe())\n        .chain((data) => {\n          switch (data.type) {\n            case CommandTags.Derive:\n              return Just(data.path);\n            case CommandTags.Seed:\n              return Just(\"m/0'\");\n            default:\n              return Nothing;\n          }\n        });\n    });\n    return this.path;\n  }\n\n  getMemberBlock(member: string): Maybe<LKRPBlockData> {\n    return this.parse()\n      .toMaybe()\n      .chain((blocks) => {\n        for (const block of blocks) {\n          const parsedBlock = block.parse();\n          if (parsedBlock.isRight()) {\n            const blockData = parsedBlock.extract();\n            for (const command of blockData.commands) {\n              const pubkey = command.getPublicKey();\n              if (pubkey.isJust() && pubkey.extract() === member) {\n                return Maybe.of(blockData);\n              }\n            }\n          }\n        }\n        return Nothing;\n      });\n  }\n\n  hasMember(member: string): boolean {\n    return this.getMemberBlock(member).isJust();\n  }\n\n  getPublishedKey(keypair: Keypair): Maybe<PublishedKey> {\n    return this.getMemberBlock(keypair.pubKeyToHex())\n      .chain((block): Maybe<EncryptedPublishedKey> => {\n        for (const command of block.commands) {\n          const key = command.getEncryptedPublishedKey();\n          if (key.isJust()) {\n            return key;\n          }\n        }\n        return Nothing;\n      })\n      .map((published) => {\n        const secret = keypair.ecdh(published.ephemeralPublicKey).slice(1);\n        const xpriv = CryptoUtils.decrypt(\n          secret,\n          published.initializationVector,\n          published.encryptedXpriv,\n        );\n        return { privateKey: xpriv.slice(0, 32), chainCode: xpriv.slice(32) };\n      });\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["LKRPBlockStream_exports", "__export", "LKRPBlockStream", "__toCommonJS", "import_purify_ts", "import_Tags", "import_crypto", "import_hex", "import_LKRPBlock", "import_TLVParser", "bytes", "blocks", "hex", "blocksData", "parentHash", "hash", "blockData", "block", "acc", "parser", "parsed", "start", "data", "end", "streamParentHash", "parent", "index", "nextBlock", "commands", "command", "member", "parsedBlock", "pubkey", "keypair", "key", "published", "secret", "xpriv"]
 }

package/lib/cjs/internal/utils/LKRPBlockStream.test.js CHANGED Viewed

@@ -1,4 +1,4 @@
-"use strict";var a=require("@ledgerhq/device-management-kit"),t=require("purify-ts"),p=require("../../api/model/Errors"),o=require("../models/Tags"),m=require("./LKRPBlock"),d=require("./LKRPBlockStream"),i=require("./LKRPCommand");describe("LKRPBlockStream",()=>{describe("toString",()=>{it("should return the hex representation of the block stream",()=>{const e="0102030405060708",c=d.LKRPBlockStream.fromHex(e);expect(c.toString()).toBe(e)})}),describe("toU8A",()=>{it("should return the bytes of the block stream",()=>{const e=new Uint8Array([1,2,3,4,5,6,7,8]),c=new d.LKRPBlockStream(e);expect(c.toU8A()).toBe(e)})}),describe("toHuman",()=>{it("should return a human-readable representation of the block stream",()=>{const c=d.LKRPBlockStream.fromHex(r).toHuman();expect(c).toStrictEqual((0,t.Right)(["Parent: 7ba5eefac6605547fc50188ba7880311d3d1240a7ae32e6eaac7499434091c45","Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021","Commands:","  Derive(0x15):","    path: m/0'/16'/0'","    groupKey: 02839a288f6a76090b64312281d2e7d6b02c4ddf64ed5e7693471b1b445f819508","    initializationVector: a66c5a4486e870287caa53bbd609af00","    encryptedXpriv: 0f43341d6f9099a5180fb304a2889b3b0468f05fb0b931d22211753b3411567abb21981b64261e95bcd44a3512af7c87bbb5a4b6b680c03b5f09e8d9c56a9cb1c0788993a3d9d5c140a2462cb1930d19","    ephemeralPublicKey: 02fbe26c32ab991c1b107156e22fc158c335e0aeedc171381c9d77743c66f41171","  AddMember(0x11):","    name: debug-d4c61d","    publicKey: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    permissions: 4294967295","  PublishKey(0x12):","    initializationVector: 4d305eae5b70b69cf657f3b9f7db5863","    encryptedXpriv: 898de535f87f7ac775b09c80827d14efddeeaa9a2b106bfd7fcc91942dc36d6a1751793ba7ec0792ba936f5f1d858bc1fc54ca1a70e8d28a5b0bf33b5e926f3add372c802b3b9da64bc06e26b9349db5","    recipient: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    ephemeralPublicKey: 023db66b974b871c6caafdf486c6895518303b140d389e787d2c3b5527c2df50f4","Signature: 3044022056ab426bd75696cbe9538cb42271e8796ba1576dfe3e2634f0a6f1a636821e5002205e41ae68ebd8fbff404340a4f0124af25e948aa52500de192d15ff4f8ee92c02","","Parent: 154d99eb867cfeef249d573fc2e1f3d307c1e49ec1f66e9af1c9dbd219143211","Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021","Commands:","  AddMember(0x11):","    name: debug-80a289","    publicKey: 0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db","    permissions: 4294967295","  PublishKey(0x12):","    initializationVector: 27bdb34fb6028128bfc919f4db7d1378","    encryptedXpriv: e792b83f26fac0de46ee8f1a07e53b0e508d9373aa2e8047f0a764204ab0f06a2fffa9c29599f5d3fe42fefabd9827867157bd14ec7e2bd8ef83c6f9371d7b48d28d9a4499f8ed626ce75fcec0a0b33f","    recipient: 0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db","    ephemeralPublicKey: 027d40157737671bb04eaca2756b8ec58020ff5c893b10cbfb25b48014c5252dc4","Signature: 30440220718d20c9996893639da807b8a9675d944abdc8fded97f73159beba5004fa17f102203338b74a9e6a2e696ea3658d3af4fce95ffa0f74c11b2c3d37b0ca1b577657e8"].join(`
+"use strict";var t=require("purify-ts"),p=require("../../api/app-binder/Errors"),o=require("../models/Tags"),a=require("./hex"),m=require("./LKRPBlock"),d=require("./LKRPBlockStream"),i=require("./LKRPCommand");describe("LKRPBlockStream",()=>{describe("toString",()=>{it("should return the hex representation of the block stream",()=>{const e="0102030405060708",c=d.LKRPBlockStream.fromHex(e);expect(c.toString()).toBe(e)})}),describe("toU8A",()=>{it("should return the bytes of the block stream",()=>{const e=new Uint8Array([1,2,3,4,5,6,7,8]),c=new d.LKRPBlockStream(e);expect(c.toU8A()).toBe(e)})}),describe("toHuman",()=>{it("should return a human-readable representation of the block stream",()=>{const c=d.LKRPBlockStream.fromHex(r).toHuman();expect(c).toStrictEqual((0,t.Right)(["Parent: 7ba5eefac6605547fc50188ba7880311d3d1240a7ae32e6eaac7499434091c45","Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021","Commands:","  Derive(0x15):","    path: m/0'/16'/0'","    groupKey: 02839a288f6a76090b64312281d2e7d6b02c4ddf64ed5e7693471b1b445f819508","    initializationVector: a66c5a4486e870287caa53bbd609af00","    encryptedXpriv: 0f43341d6f9099a5180fb304a2889b3b0468f05fb0b931d22211753b3411567abb21981b64261e95bcd44a3512af7c87bbb5a4b6b680c03b5f09e8d9c56a9cb1c0788993a3d9d5c140a2462cb1930d19","    ephemeralPublicKey: 02fbe26c32ab991c1b107156e22fc158c335e0aeedc171381c9d77743c66f41171","  AddMember(0x11):","    name: debug-d4c61d","    publicKey: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    permissions: 4294967295","  PublishKey(0x12):","    initializationVector: 4d305eae5b70b69cf657f3b9f7db5863","    encryptedXpriv: 898de535f87f7ac775b09c80827d14efddeeaa9a2b106bfd7fcc91942dc36d6a1751793ba7ec0792ba936f5f1d858bc1fc54ca1a70e8d28a5b0bf33b5e926f3add372c802b3b9da64bc06e26b9349db5","    recipient: 03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812","    ephemeralPublicKey: 023db66b974b871c6caafdf486c6895518303b140d389e787d2c3b5527c2df50f4","Signature: 3044022056ab426bd75696cbe9538cb42271e8796ba1576dfe3e2634f0a6f1a636821e5002205e41ae68ebd8fbff404340a4f0124af25e948aa52500de192d15ff4f8ee92c02","","Parent: 154d99eb867cfeef249d573fc2e1f3d307c1e49ec1f66e9af1c9dbd219143211","Issuer: 0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021","Commands:","  AddMember(0x11):","    name: debug-80a289","    publicKey: 0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db","    permissions: 4294967295","  PublishKey(0x12):","    initializationVector: 27bdb34fb6028128bfc919f4db7d1378","    encryptedXpriv: e792b83f26fac0de46ee8f1a07e53b0e508d9373aa2e8047f0a764204ab0f06a2fffa9c29599f5d3fe42fefabd9827867157bd14ec7e2bd8ef83c6f9371d7b48d28d9a4499f8ed626ce75fcec0a0b33f","    recipient: 0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db","    ephemeralPublicKey: 027d40157737671bb04eaca2756b8ec58020ff5c893b10cbfb25b48014c5252dc4","Signature: 30440220718d20c9996893639da807b8a9675d944abdc8fded97f73159beba5004fa17f102203338b74a9e6a2e696ea3658d3af4fce95ffa0f74c11b2c3d37b0ca1b577657e8"].join(`
 `)))})}),describe("parse",()=>{it("should parse the block stream correctly",()=>{const e=d.LKRPBlockStream.fromHex(r),c=e.parse();e.toHuman(),expect(c).toStrictEqual((0,t.Right)([m.LKRPBlock.fromData(f),m.LKRPBlock.fromData(n)]))}),it("should fail if the block stream data is invalid",()=>{const c=d.LKRPBlockStream.fromHex("00").parse();expect(c).toStrictEqual((0,t.Left)(new p.LKRPParsingError("Invalid end of TLV, expected length")))})}),describe("fromData",()=>{it("should create a BlockStream from data",()=>{const e=[{...f,parent:void 0},{...n,parent:void 0}],c=d.LKRPBlockStream.fromData(e,f.parent);expect(c.toString()).toBe(r)}),it("should assign a random parent hash if not provided",()=>{const e=[{...f,parent:void 0},{...n,parent:void 0}],b=d.LKRPBlockStream.fromData(e).parse().map(s=>s[0]?.hash()).caseOf({Left:()=>{},Right:s=>s});expect(typeof b).toBe("string"),expect(b?.length).toBe(64),expect(b).not.toBe(f.parent)})}),describe("validate",()=>{it("should validate the block stream",async()=>{const e=d.LKRPBlockStream.fromHex(r),c=await e.validate(f.parent),b=await e.validate(f.parent);expect(c).toBe(!0),expect(b).toBe(!0)}),it("should fail validation if the parent hash does not match",async()=>{const e=d.LKRPBlockStream.fromHex(r.replace(n.parent,f.parent)),c=await e.validate("0123455678"),b=await e.validate();expect(c).toBe(!1),expect(b).toBe(!1)})}),describe("getPath",()=>{it("should return the path of the block stream",()=>{const c=d.LKRPBlockStream.fromHex(r).getPath();expect(c).toEqual((0,t.Just)("m/0'/16'/0'"))})})});const r=`
   01 01 01
   02 20 7b a5 ee fa c6 60 55 47 fc 50 18 8b a7 88 03 11 d3 d1 24 0a 7a e3 2e 6e aa c7 49 94 34 09 1c 45
@@ -35,5 +35,5 @@
       06 21 02 80 a2 89 18 36 9e 12 c8 6f eb 32 1c d1 00 fe 6d 95 8e 55 a0 bb 57 05 76 ef 71 8e 7a 37 92 04 db
       06 21 02 7d 40 15 77 37 67 1b b0 4e ac a2 75 6b 8e c5 80 20 ff 5c 89 3b 10 cb fb 25 b4 80 14 c5 25 2d c4
   03 46 30 44 02 20 71 8d 20 c9 99 68 93 63 9d a8 07 b8 a9 67 5d 94 4a bd c8 fd ed 97 f7 31 59 be ba 50 04 fa 17 f1 02 20 33 38 b7 4a 9e 6a 2e 69 6e a3 65 8d 3a f4 fc e9 5f fa 0f 74 c1 1b 2c 3d 37 b0 ca 1b 57 76 57 e8
-`.replace(/\s/g,""),f={parent:"7ba5eefac6605547fc50188ba7880311d3d1240a7ae32e6eaac7499434091c45",issuer:(0,a.hexaStringToBuffer)("0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021"),commands:[i.LKRPCommand.fromData({type:o.CommandTags.Derive,path:"m/0'/16'/0'",groupKey:(0,a.hexaStringToBuffer)("02839a288f6a76090b64312281d2e7d6b02c4ddf64ed5e7693471b1b445f819508"),initializationVector:(0,a.hexaStringToBuffer)("a66c5a4486e870287caa53bbd609af00"),encryptedXpriv:(0,a.hexaStringToBuffer)("0f43341d6f9099a5180fb304a2889b3b0468f05fb0b931d22211753b3411567abb21981b64261e95bcd44a3512af7c87bbb5a4b6b680c03b5f09e8d9c56a9cb1c0788993a3d9d5c140a2462cb1930d19"),ephemeralPublicKey:(0,a.hexaStringToBuffer)("02fbe26c32ab991c1b107156e22fc158c335e0aeedc171381c9d77743c66f41171")}),i.LKRPCommand.fromData({type:o.CommandTags.AddMember,name:"debug-d4c61d",publicKey:(0,a.hexaStringToBuffer)("03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812"),permissions:4294967295}),i.LKRPCommand.fromData({type:o.CommandTags.PublishKey,initializationVector:(0,a.hexaStringToBuffer)("4d305eae5b70b69cf657f3b9f7db5863"),encryptedXpriv:(0,a.hexaStringToBuffer)("898de535f87f7ac775b09c80827d14efddeeaa9a2b106bfd7fcc91942dc36d6a1751793ba7ec0792ba936f5f1d858bc1fc54ca1a70e8d28a5b0bf33b5e926f3add372c802b3b9da64bc06e26b9349db5"),recipient:(0,a.hexaStringToBuffer)("03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812"),ephemeralPublicKey:(0,a.hexaStringToBuffer)("023db66b974b871c6caafdf486c6895518303b140d389e787d2c3b5527c2df50f4")})],signature:(0,a.hexaStringToBuffer)("3044022056ab426bd75696cbe9538cb42271e8796ba1576dfe3e2634f0a6f1a636821e5002205e41ae68ebd8fbff404340a4f0124af25e948aa52500de192d15ff4f8ee92c02")},n={parent:"154d99eb867cfeef249d573fc2e1f3d307c1e49ec1f66e9af1c9dbd219143211",issuer:(0,a.hexaStringToBuffer)("0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021"),commands:[i.LKRPCommand.fromData({type:o.CommandTags.AddMember,name:"debug-80a289",publicKey:(0,a.hexaStringToBuffer)("0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db"),permissions:4294967295}),i.LKRPCommand.fromData({type:o.CommandTags.PublishKey,initializationVector:(0,a.hexaStringToBuffer)("27bdb34fb6028128bfc919f4db7d1378"),encryptedXpriv:(0,a.hexaStringToBuffer)("e792b83f26fac0de46ee8f1a07e53b0e508d9373aa2e8047f0a764204ab0f06a2fffa9c29599f5d3fe42fefabd9827867157bd14ec7e2bd8ef83c6f9371d7b48d28d9a4499f8ed626ce75fcec0a0b33f"),recipient:(0,a.hexaStringToBuffer)("0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db"),ephemeralPublicKey:(0,a.hexaStringToBuffer)("027d40157737671bb04eaca2756b8ec58020ff5c893b10cbfb25b48014c5252dc4")})],signature:(0,a.hexaStringToBuffer)("30440220718d20c9996893639da807b8a9675d944abdc8fded97f73159beba5004fa17f102203338b74a9e6a2e696ea3658d3af4fce95ffa0f74c11b2c3d37b0ca1b577657e8")};
+`.replace(/\s/g,""),f={parent:"7ba5eefac6605547fc50188ba7880311d3d1240a7ae32e6eaac7499434091c45",issuer:(0,a.hexToBytes)("0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021"),commands:[i.LKRPCommand.fromData({type:o.CommandTags.Derive,path:"m/0'/16'/0'",groupKey:(0,a.hexToBytes)("02839a288f6a76090b64312281d2e7d6b02c4ddf64ed5e7693471b1b445f819508"),initializationVector:(0,a.hexToBytes)("a66c5a4486e870287caa53bbd609af00"),encryptedXpriv:(0,a.hexToBytes)("0f43341d6f9099a5180fb304a2889b3b0468f05fb0b931d22211753b3411567abb21981b64261e95bcd44a3512af7c87bbb5a4b6b680c03b5f09e8d9c56a9cb1c0788993a3d9d5c140a2462cb1930d19"),ephemeralPublicKey:(0,a.hexToBytes)("02fbe26c32ab991c1b107156e22fc158c335e0aeedc171381c9d77743c66f41171")}),i.LKRPCommand.fromData({type:o.CommandTags.AddMember,name:"debug-d4c61d",publicKey:(0,a.hexToBytes)("03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812"),permissions:4294967295}),i.LKRPCommand.fromData({type:o.CommandTags.PublishKey,initializationVector:(0,a.hexToBytes)("4d305eae5b70b69cf657f3b9f7db5863"),encryptedXpriv:(0,a.hexToBytes)("898de535f87f7ac775b09c80827d14efddeeaa9a2b106bfd7fcc91942dc36d6a1751793ba7ec0792ba936f5f1d858bc1fc54ca1a70e8d28a5b0bf33b5e926f3add372c802b3b9da64bc06e26b9349db5"),recipient:(0,a.hexToBytes)("03d4c61dda2aaf762954fce97396d9be0399e1dc75c3b790c7a34dde8596a11812"),ephemeralPublicKey:(0,a.hexToBytes)("023db66b974b871c6caafdf486c6895518303b140d389e787d2c3b5527c2df50f4")})],signature:(0,a.hexToBytes)("3044022056ab426bd75696cbe9538cb42271e8796ba1576dfe3e2634f0a6f1a636821e5002205e41ae68ebd8fbff404340a4f0124af25e948aa52500de192d15ff4f8ee92c02")},n={parent:"154d99eb867cfeef249d573fc2e1f3d307c1e49ec1f66e9af1c9dbd219143211",issuer:(0,a.hexToBytes)("0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021"),commands:[i.LKRPCommand.fromData({type:o.CommandTags.AddMember,name:"debug-80a289",publicKey:(0,a.hexToBytes)("0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db"),permissions:4294967295}),i.LKRPCommand.fromData({type:o.CommandTags.PublishKey,initializationVector:(0,a.hexToBytes)("27bdb34fb6028128bfc919f4db7d1378"),encryptedXpriv:(0,a.hexToBytes)("e792b83f26fac0de46ee8f1a07e53b0e508d9373aa2e8047f0a764204ab0f06a2fffa9c29599f5d3fe42fefabd9827867157bd14ec7e2bd8ef83c6f9371d7b48d28d9a4499f8ed626ce75fcec0a0b33f"),recipient:(0,a.hexToBytes)("0280a28918369e12c86feb321cd100fe6d958e55a0bb570576ef718e7a379204db"),ephemeralPublicKey:(0,a.hexToBytes)("027d40157737671bb04eaca2756b8ec58020ff5c893b10cbfb25b48014c5252dc4")})],signature:(0,a.hexToBytes)("30440220718d20c9996893639da807b8a9675d944abdc8fded97f73159beba5004fa17f102203338b74a9e6a2e696ea3658d3af4fce95ffa0f74c11b2c3d37b0ca1b577657e8")};
 //# sourceMappingURL=LKRPBlockStream.test.js.map