@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol 0.0.0-ledger-button-20250806141658 → 0.0.0-ledger-button-20250808005842

package/lib/esm/internal/app-binder/task/SignBlockTask.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/task/SignBlockTask.ts"],
-  "sourcesContent": ["import {\n  bufferToHexaString,\n  CommandResultStatus,\n  type InternalApi,\n  UnknownDAError,\n} from \"@ledgerhq/device-management-kit\";\nimport { Either, EitherAsync, Left, Right } from \"purify-ts\";\n\nimport {\n  type LKRPHttpRequestError,\n  type LKRPMissingDataError,\n  type LKRPParsingError,\n} from \"@api/app-binder/Errors\";\nimport { type JWT, type Keypair } from \"@api/index\";\nimport { SignBlockHeaderCommand } from \"@internal/app-binder/command/SignBlockHeader\";\nimport { SignBlockSignatureCommand } from \"@internal/app-binder/command/SignBlockSignatureCommand\";\nimport { SignBlockSingleCommand } from \"@internal/app-binder/command/SignBlockSingleCommand\";\nimport { type LKRPDeviceCommandError } from \"@internal/app-binder/command/utils/ledgerKeyringProtocolErrors\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { CryptoUtils } from \"@internal/utils/crypto\";\nimport {\n  eitherAsyncSeqRecord,\n  eitherSeqRecord,\n} from \"@internal/utils/eitherSeqRecord\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { LKRPCommand } from \"@internal/utils/LKRPCommand\";\nimport { CommandTags, GeneralTags } from \"@internal/utils/TLVTags\";\nimport {\n  type AddMemberUnsignedData,\n  type EncryptedCommand,\n  type EncryptedDeriveCommand,\n  type EncryptedPublishKeyCommand,\n} from \"@internal/utils/types\";\n\nimport { TrustedProperties } from \"./utils/TrustedProperties\";\n\ntype BlockFlow =\n  | { type: \"derive\"; data: AddMemberBlockData }\n  | { type: \"addMember\"; data: AddMemberBlockData };\n\ntype AddMemberBlockData = {\n  name: string;\n  publicKey: Uint8Array;\n  permissions: number;\n};\n\ntype HeaderPayload = {\n  iv: Uint8Array;\n  issuer: Uint8Array;\n};\ntype SignaturePayload = {\n  secret: Uint8Array;\n  signature: Uint8Array;\n};\n\ntype EncryptedBlock = {\n  header: HeaderPayload;\n  commands: EncryptedCommand[];\n  signature: SignaturePayload;\n};\n\nexport type SignBlockError =\n  | LKRPDeviceCommandError\n  | LKRPParsingError\n  | LKRPMissingDataError\n  | LKRPHttpRequestError\n  | UnknownDAError;\n\nexport type SignBlockTaskInput = {\n  lkrpDataSource: LKRPDataSource;\n  trustchainId: string;\n  path: string;\n  jwt: JWT;\n  parent: Uint8Array;\n  blockFlow: BlockFlow;\n  sessionKeypair: Keypair;\n};\n\nexport const ISSUER_PLACEHOLDER = new Uint8Array([\n  3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0,\n]);\n\nexport class SignBlockTask {\n  constructor(private readonly api: InternalApi) {}\n\n  run({\n    lkrpDataSource,\n    trustchainId,\n    path,\n    jwt,\n    parent,\n    blockFlow,\n    sessionKeypair,\n  }: SignBlockTaskInput): EitherAsync<SignBlockError, void> {\n    const commands = this.signCommands(path, blockFlow);\n    return eitherAsyncSeqRecord({\n      header: this.signBlockHeader(parent, commands.length),\n      commands: EitherAsync.sequence(commands),\n      signature: this.signBlockSignature(sessionKeypair),\n    })\n      .chain((encryptedBlock) =>\n        EitherAsync.liftEither(this.decryptBlock(parent, encryptedBlock)),\n      )\n      .chain((block) => {\n        switch (blockFlow.type) {\n          case \"derive\":\n            return lkrpDataSource.postDerivation(trustchainId, block, jwt);\n          case \"addMember\":\n            return lkrpDataSource.putCommands(trustchainId, path, block, jwt);\n        }\n      });\n  }\n\n  signBlockHeader(\n    parent: Uint8Array,\n    commandCount: number,\n  ): EitherAsync<SignBlockError, HeaderPayload> {\n    return EitherAsync.fromPromise(async () => {\n      const header = Uint8Array.from(\n        [\n          [GeneralTags.Int, 1, 1], // Version 1\n          [GeneralTags.Hash, parent.length, ...parent], // Parent block hash\n          [\n            GeneralTags.PublicKey,\n            ISSUER_PLACEHOLDER.length,\n            ...ISSUER_PLACEHOLDER,\n          ], // Placeholder for issuer public key (will be replaced by the device)\n          [GeneralTags.Int, 1, commandCount],\n        ].flat(),\n      );\n      try {\n        const response = await this.api.sendCommand(\n          new SignBlockHeaderCommand({ header }),\n        );\n        if (response.status !== CommandResultStatus.Success) {\n          return Left(response.error);\n        }\n        const trustedProps = new TrustedProperties(response.data);\n        return eitherSeqRecord({\n          iv: () => trustedProps.getIv(),\n          issuer: () => trustedProps.getIssuer(),\n        }) as Either<SignBlockError, HeaderPayload>;\n      } catch (error) {\n        return Left(new UnknownDAError(String(error)));\n      }\n    });\n  }\n\n  signBlockSignature(\n    sessionKeypair: Keypair,\n  ): EitherAsync<SignBlockError, SignaturePayload> {\n    return EitherAsync.fromPromise(async () => {\n      try {\n        const response = await this.api.sendCommand(\n          new SignBlockSignatureCommand(),\n        );\n        if (response.status !== CommandResultStatus.Success) {\n          return Left(response.error);\n        }\n        const { signature, deviceSessionKey } = response.data;\n        // At this step, the shared secret is used directly as an encryption key after removing the first byte\n        const secret = sessionKeypair.ecdh(deviceSessionKey).slice(1);\n        return Right({ signature, secret });\n      } catch (error) {\n        return Left(new UnknownDAError(String(error)));\n      }\n    });\n  }\n\n  signCommands(\n    applicationPath: string,\n    block: BlockFlow,\n  ): EitherAsync<SignBlockError, EncryptedCommand>[] {\n    switch (block.type) {\n      case \"derive\":\n        return [\n          this.signDeriveCommand(applicationPath),\n          this.signAddMemberCommand(block.data),\n          this.signPublishKeyCommand(block.data),\n        ];\n      case \"addMember\":\n        return [\n          this.signAddMemberCommand(block.data),\n          this.signPublishKeyCommand(block.data),\n        ];\n    }\n  }\n\n  signSingleCommand(command: Uint8Array) {\n    return EitherAsync.fromPromise(\n      async (): Promise<Either<SignBlockError, TrustedProperties>> => {\n        try {\n          const response = await this.api.sendCommand(\n            new SignBlockSingleCommand({ command }),\n          );\n          if (response.status !== CommandResultStatus.Success) {\n            return Left(response.error);\n          }\n          return Right(new TrustedProperties(response.data));\n        } catch (error) {\n          return Left(new UnknownDAError(String(error)));\n        }\n      },\n    );\n  }\n\n  signDeriveCommand(applicationPath: string) {\n    return this.signSingleCommand(\n      LKRPCommand.bytesFromUnsignedData({\n        type: CommandTags.Derive,\n        path: applicationPath,\n      }),\n    ).chain((trustedProps) =>\n      EitherAsync.liftEither<SignBlockError, EncryptedDeriveCommand>(\n        eitherSeqRecord({\n          type: CommandTags.Derive,\n          path: applicationPath,\n          iv: () => trustedProps.getIv(),\n          xpriv: () => trustedProps.getXPriv(),\n          ephemeralPublicKey: () => trustedProps.getEphemeralPublicKey(),\n          commandIv: () => trustedProps.getCommandIv(),\n          groupKey: () => trustedProps.getGroupKey(),\n          newMember: () => trustedProps.getNewMember(), // Just validate it's there\n        }),\n      ),\n    );\n  }\n\n  signAddMemberCommand({ name, publicKey, permissions }: AddMemberBlockData) {\n    return this.signSingleCommand(\n      LKRPCommand.bytesFromUnsignedData({\n        type: CommandTags.AddMember,\n        name,\n        publicKey,\n        permissions,\n      }),\n    ).chain((trustedProps) =>\n      EitherAsync.liftEither<SignBlockError, AddMemberUnsignedData>(\n        eitherSeqRecord({\n          type: CommandTags.AddMember,\n          name,\n          publicKey,\n          permissions,\n          iv: () => trustedProps.getIv(), // Just validate it's there\n          newMember: () => trustedProps.getNewMember(), // Just validate it's there\n        }),\n      ),\n    );\n  }\n\n  signPublishKeyCommand({ publicKey }: Pick<AddMemberBlockData, \"publicKey\">) {\n    return this.signSingleCommand(\n      LKRPCommand.bytesFromUnsignedData({\n        type: CommandTags.PublishKey,\n        recipient: publicKey,\n      }),\n    ).chain((trustedProps) =>\n      EitherAsync.liftEither<SignBlockError, EncryptedPublishKeyCommand>(\n        eitherSeqRecord({\n          type: CommandTags.PublishKey,\n          recipient: publicKey,\n          iv: () => trustedProps.getIv(),\n          xpriv: () => trustedProps.getXPriv(),\n          ephemeralPublicKey: () => trustedProps.getEphemeralPublicKey(),\n          commandIv: () => trustedProps.getCommandIv(),\n          newMember: () => trustedProps.getNewMember(), // Just validate it's there,\n        }),\n      ),\n    );\n  }\n\n  decryptBlock(\n    parent: Uint8Array,\n    { header, commands, signature }: EncryptedBlock,\n  ): Either<SignBlockError, LKRPBlock> {\n    const decryptedIssuer = CryptoUtils.decrypt(\n      signature.secret,\n      header.iv,\n      header.issuer,\n    );\n    return Either.sequence(\n      commands.map((command) => this.decryptCommand(signature.secret, command)),\n    ).map((decryptedCommands) =>\n      LKRPBlock.fromData({\n        parent: bufferToHexaString(parent),\n        issuer: decryptedIssuer,\n        commands: decryptedCommands,\n        signature: signature.signature,\n      }),\n    );\n  }\n\n  decryptCommand(\n    secret: Uint8Array,\n    command: EncryptedCommand,\n  ): Either<UnknownDAError, LKRPCommand> {\n    switch (command.type) {\n      case CommandTags.Derive:\n      case CommandTags.PublishKey: {\n        const encryptedXpriv = CryptoUtils.decrypt(\n          secret,\n          command.iv,\n          command.xpriv,\n        );\n        return Right(\n          LKRPCommand.fromData({\n            ...command,\n            initializationVector: command.commandIv,\n            encryptedXpriv,\n          }),\n        );\n      }\n      case CommandTags.AddMember:\n        return Right(LKRPCommand.fromData({ ...command }));\n      default:\n        return Left(new UnknownDAError(\"Unsupported command type\"));\n    }\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["bufferToHexaString", "CommandResultStatus", "UnknownDAError", "Either", "EitherAsync", "Left", "Right", "SignBlockHeaderCommand", "SignBlockSignatureCommand", "SignBlockSingleCommand", "CryptoUtils", "eitherAsyncSeqRecord", "eitherSeqRecord", "LKRPBlock", "LKRPCommand", "CommandTags", "GeneralTags", "TrustedProperties", "ISSUER_PLACEHOLDER", "SignBlockTask", "api", "lkrpDataSource", "trustchainId", "path", "jwt", "parent", "blockFlow", "sessionKeypair", "commands", "encryptedBlock", "block", "commandCount", "header", "response", "trustedProps", "error", "signature", "deviceSessionKey", "secret", "applicationPath", "command", "name", "publicKey", "permissions", "decryptedIssuer", "decryptedCommands", "encryptedXpriv"]
+  "sourcesContent": ["import {\n  bufferToHexaString,\n  CommandResultStatus,\n  type InternalApi,\n} from \"@ledgerhq/device-management-kit\";\nimport { Either, EitherAsync, Left, Right } from \"purify-ts\";\n\nimport {\n  LKRPDataSourceError,\n  type LKRPMissingDataError,\n  LKRPOutdatedTrustchainError,\n  type LKRPParsingError,\n  LKRPUnknownError,\n  LKRPUnsupportedCommandError,\n} from \"@api/app-binder/Errors\";\nimport { type JWT, type Keypair } from \"@api/index\";\nimport { SignBlockHeaderCommand } from \"@internal/app-binder/command/SignBlockHeader\";\nimport { SignBlockSignatureCommand } from \"@internal/app-binder/command/SignBlockSignatureCommand\";\nimport { SignBlockSingleCommand } from \"@internal/app-binder/command/SignBlockSingleCommand\";\nimport { type LKRPDeviceCommandError } from \"@internal/app-binder/command/utils/ledgerKeyringProtocolErrors\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport {\n  type AddMemberUnsignedData,\n  type EncryptedCommand,\n  type EncryptedDeriveCommand,\n  type EncryptedPublishKeyCommand,\n} from \"@internal/models/LKRPCommandTypes\";\nimport { CommandTags } from \"@internal/models/Tags\";\nimport { CryptoUtils } from \"@internal/utils/crypto\";\nimport {\n  eitherAsyncSeqRecord,\n  eitherSeqRecord,\n} from \"@internal/utils/eitherSeqRecord\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { LKRPCommand } from \"@internal/utils/LKRPCommand\";\n\nimport { TrustedProperties } from \"./utils/TrustedProperties\";\n\ntype BlockFlow =\n  | { type: \"derive\"; data: AddMemberBlockData }\n  | { type: \"addMember\"; data: AddMemberBlockData };\n\ntype AddMemberBlockData = {\n  name: string;\n  publicKey: Uint8Array;\n  permissions: number;\n};\n\ntype HeaderPayload = {\n  iv: Uint8Array;\n  issuer: Uint8Array;\n};\ntype SignaturePayload = {\n  secret: Uint8Array;\n  signature: Uint8Array;\n};\n\ntype EncryptedBlock = {\n  header: HeaderPayload;\n  commands: EncryptedCommand[];\n  signature: SignaturePayload;\n};\n\ntype SignBlockError =\n  | LKRPDeviceCommandError\n  | LKRPParsingError\n  | LKRPMissingDataError\n  | LKRPDataSourceError\n  | LKRPOutdatedTrustchainError\n  | LKRPUnknownError;\n\nexport type SignBlockTaskInput = {\n  lkrpDataSource: LKRPDataSource;\n  trustchainId: string;\n  path: string;\n  jwt: JWT;\n  parent: Uint8Array;\n  blockFlow: BlockFlow;\n  sessionKeypair: Keypair;\n};\n\nexport class SignBlockTask {\n  constructor(private readonly api: InternalApi) {}\n\n  run({\n    lkrpDataSource,\n    trustchainId,\n    path,\n    jwt,\n    parent,\n    blockFlow,\n    sessionKeypair,\n  }: SignBlockTaskInput): EitherAsync<SignBlockError, void> {\n    const commands = this.signCommands(path, blockFlow);\n    return eitherAsyncSeqRecord({\n      header: this.signBlockHeader(parent, commands.length),\n      commands: EitherAsync.sequence(commands),\n      signature: this.signBlockSignature(sessionKeypair),\n    })\n      .chain((encryptedBlock) =>\n        EitherAsync.liftEither(this.decryptBlock(parent, encryptedBlock)),\n      )\n      .chain((block) => {\n        switch (blockFlow.type) {\n          case \"derive\":\n            return lkrpDataSource.postDerivation(trustchainId, block, jwt);\n          case \"addMember\":\n            return lkrpDataSource.putCommands(trustchainId, path, block, jwt);\n        }\n      })\n      .mapLeft((error) =>\n        error instanceof LKRPDataSourceError && error.status === \"BAD_REQUEST\"\n          ? new LKRPOutdatedTrustchainError()\n          : error,\n      );\n  }\n\n  signBlockHeader(\n    parent: Uint8Array,\n    commandCount: number,\n  ): EitherAsync<SignBlockError, HeaderPayload> {\n    return EitherAsync.fromPromise(async () => {\n      try {\n        const response = await this.api.sendCommand(\n          new SignBlockHeaderCommand({ parent, commandCount }),\n        );\n        if (response.status !== CommandResultStatus.Success) {\n          return Left(response.error);\n        }\n        const trustedProps = new TrustedProperties(response.data);\n        return eitherSeqRecord({\n          iv: () => trustedProps.getIv(),\n          issuer: () => trustedProps.getIssuer(),\n        }) as Either<SignBlockError, HeaderPayload>;\n      } catch (error) {\n        return Left(new LKRPUnknownError(String(error)));\n      }\n    });\n  }\n\n  signBlockSignature(\n    sessionKeypair: Keypair,\n  ): EitherAsync<SignBlockError, SignaturePayload> {\n    return EitherAsync.fromPromise(async () => {\n      try {\n        const response = await this.api.sendCommand(\n          new SignBlockSignatureCommand(),\n        );\n        if (response.status !== CommandResultStatus.Success) {\n          return Left(response.error);\n        }\n        const { signature, deviceSessionKey } = response.data;\n        // At this step, the shared secret is used directly as an encryption key after removing the first byte\n        const secret = sessionKeypair.ecdh(deviceSessionKey).slice(1);\n        return Right({ signature, secret });\n      } catch (error) {\n        return Left(new LKRPUnknownError(String(error)));\n      }\n    });\n  }\n\n  signCommands(\n    applicationPath: string,\n    block: BlockFlow,\n  ): EitherAsync<SignBlockError, EncryptedCommand>[] {\n    switch (block.type) {\n      case \"derive\":\n        return [\n          this.signDeriveCommand(applicationPath),\n          this.signAddMemberCommand(block.data),\n          this.signPublishKeyCommand(block.data),\n        ];\n      case \"addMember\":\n        return [\n          this.signAddMemberCommand(block.data),\n          this.signPublishKeyCommand(block.data),\n        ];\n    }\n  }\n\n  signSingleCommand(command: Uint8Array) {\n    return EitherAsync.fromPromise(\n      async (): Promise<Either<SignBlockError, TrustedProperties>> => {\n        try {\n          const response = await this.api.sendCommand(\n            new SignBlockSingleCommand({ command }),\n          );\n          if (response.status !== CommandResultStatus.Success) {\n            return Left(response.error);\n          }\n          return Right(new TrustedProperties(response.data));\n        } catch (error) {\n          return Left(new LKRPUnknownError(String(error)));\n        }\n      },\n    );\n  }\n\n  signDeriveCommand(applicationPath: string) {\n    return this.signSingleCommand(\n      LKRPCommand.bytesFromUnsignedData({\n        type: CommandTags.Derive,\n        path: applicationPath,\n      }),\n    ).chain((trustedProps) =>\n      EitherAsync.liftEither<SignBlockError, EncryptedDeriveCommand>(\n        eitherSeqRecord({\n          type: CommandTags.Derive,\n          path: applicationPath,\n          iv: () => trustedProps.getIv(),\n          xpriv: () => trustedProps.getXPriv(),\n          ephemeralPublicKey: () => trustedProps.getEphemeralPublicKey(),\n          commandIv: () => trustedProps.getCommandIv(),\n          groupKey: () => trustedProps.getGroupKey(),\n          newMember: () => trustedProps.getNewMember(), // Just validate it's there\n        }),\n      ),\n    );\n  }\n\n  signAddMemberCommand({ name, publicKey, permissions }: AddMemberBlockData) {\n    return this.signSingleCommand(\n      LKRPCommand.bytesFromUnsignedData({\n        type: CommandTags.AddMember,\n        name,\n        publicKey,\n        permissions,\n      }),\n    ).chain((trustedProps) =>\n      EitherAsync.liftEither<SignBlockError, AddMemberUnsignedData>(\n        eitherSeqRecord({\n          type: CommandTags.AddMember,\n          name,\n          publicKey,\n          permissions,\n          iv: () => trustedProps.getIv(), // Just validate it's there\n          newMember: () => trustedProps.getNewMember(), // Just validate it's there\n        }),\n      ),\n    );\n  }\n\n  signPublishKeyCommand({ publicKey }: Pick<AddMemberBlockData, \"publicKey\">) {\n    return this.signSingleCommand(\n      LKRPCommand.bytesFromUnsignedData({\n        type: CommandTags.PublishKey,\n        recipient: publicKey,\n      }),\n    ).chain((trustedProps) =>\n      EitherAsync.liftEither<SignBlockError, EncryptedPublishKeyCommand>(\n        eitherSeqRecord({\n          type: CommandTags.PublishKey,\n          recipient: publicKey,\n          iv: () => trustedProps.getIv(),\n          xpriv: () => trustedProps.getXPriv(),\n          ephemeralPublicKey: () => trustedProps.getEphemeralPublicKey(),\n          commandIv: () => trustedProps.getCommandIv(),\n          newMember: () => trustedProps.getNewMember(), // Just validate it's there,\n        }),\n      ),\n    );\n  }\n\n  decryptBlock(\n    parent: Uint8Array,\n    { header, commands, signature }: EncryptedBlock,\n  ): Either<SignBlockError, LKRPBlock> {\n    const decryptedIssuer = CryptoUtils.decrypt(\n      signature.secret,\n      header.iv,\n      header.issuer,\n    );\n    return Either.sequence(\n      commands.map((command) => this.decryptCommand(signature.secret, command)),\n    ).map((decryptedCommands) =>\n      LKRPBlock.fromData({\n        parent: bufferToHexaString(parent),\n        issuer: decryptedIssuer,\n        commands: decryptedCommands,\n        signature: signature.signature,\n      }),\n    );\n  }\n\n  decryptCommand(\n    secret: Uint8Array,\n    command: EncryptedCommand,\n  ): Either<LKRPUnknownError, LKRPCommand> {\n    switch (command.type) {\n      case CommandTags.Derive:\n      case CommandTags.PublishKey: {\n        const encryptedXpriv = CryptoUtils.decrypt(\n          secret,\n          command.iv,\n          command.xpriv,\n        );\n        return Right(\n          LKRPCommand.fromData({\n            ...command,\n            initializationVector: command.commandIv,\n            encryptedXpriv,\n          }),\n        );\n      }\n      case CommandTags.AddMember:\n        return Right(LKRPCommand.fromData({ ...command }));\n      default:\n        return Left(new LKRPUnsupportedCommandError(command));\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["bufferToHexaString", "CommandResultStatus", "Either", "EitherAsync", "Left", "Right", "LKRPDataSourceError", "LKRPOutdatedTrustchainError", "LKRPUnknownError", "LKRPUnsupportedCommandError", "SignBlockHeaderCommand", "SignBlockSignatureCommand", "SignBlockSingleCommand", "CommandTags", "CryptoUtils", "eitherAsyncSeqRecord", "eitherSeqRecord", "LKRPBlock", "LKRPCommand", "TrustedProperties", "SignBlockTask", "api", "lkrpDataSource", "trustchainId", "path", "jwt", "parent", "blockFlow", "sessionKeypair", "commands", "encryptedBlock", "block", "error", "commandCount", "response", "trustedProps", "signature", "deviceSessionKey", "secret", "applicationPath", "command", "name", "publicKey", "permissions", "header", "decryptedIssuer", "decryptedCommands", "encryptedXpriv"]
 }

package/lib/esm/internal/app-binder/task/SignChallengeWithKeypairTask.js

@@ -1,2 +1,2 @@
-import{ByteArrayParser as s,UnknownDAError as g}from"@ledgerhq/device-management-kit";import{EitherAsync as p,Left as h,Maybe as y}from"purify-ts";import{LKRPMissingDataError as i}from"../../../api/app-binder/Errors";import{CryptoUtils as c}from"../../utils/crypto";import{eitherSeqRecord as m}from"../../utils/eitherSeqRecord";import{bytesToHex as o,hexToBytes as x}from"../../utils/hex";class f{constructor(r,n){this.keypair=r;this.trustchainId=n}run(r){const n=this.getAttestation(),a=this.getCredential(this.keypair.pubKeyToHex());return p.liftEither(this.getUnsignedChallengeTLV(r.tlv)).map(c.hash).map(e=>this.keypair.sign(e)).map(o).map(e=>({challenge:r.json,signature:{attestation:n,credential:a,signature:e}})).mapLeft(e=>e instanceof i?e:new g(String(e)))}getAttestation(){const r=new TextEncoder().encode(this.trustchainId),n=Uint8Array.from([2,r.length,...r]);return o(n)}getCredential(r){return{version:0,curveId:33,signAlgorithm:1,publicKey:r}}getUnsignedChallengeTLV(r){const n=new s(x(r)),a=new Map(function*(){for(;;){const t=n.extractFieldTLVEncoded();if(!t)break;yield[t.tag,t.value]}}());if(a.size>10)return h(new i("Challenge TLV contains unexpected data"));const e=(t,l)=>y.fromNullable(a.get(t)).toEither(new i(`Missing ${l} field`));return m({payloadType:()=>e(1,"Payload type"),version:()=>e(2,"Version"),challengeExpiry:()=>e(22,"Challenge expiry"),host:()=>e(32,"Host"),protocolVersion:()=>e(96,"Protocol version"),curveId:()=>e(50,"Curve ID"),publicKey:()=>e(51,"Public key"),challengeData:()=>e(18,"Challenge data"),signAlgorithm:()=>e(20,"Sign algorithm"),rpSignatureField:()=>e(21,"RP signature field")}).map(t=>Uint8Array.from([[1,t.payloadType.length,...t.payloadType],[2,t.version.length,...t.version],[18,t.challengeData.length,...t.challengeData],[22,t.challengeExpiry.length,...t.challengeExpiry],[32,t.host.length,...t.host],[96,t.protocolVersion.length,...t.protocolVersion]].flat()))}}export{f as SignChallengeWithKeypairTask};
+import{ByteArrayParser as s}from"@ledgerhq/device-management-kit";import{EitherAsync as g,Left as p,Maybe as h}from"purify-ts";import{LKRPMissingDataError as i,LKRPUnknownError as y}from"../../../api/app-binder/Errors";import{CryptoUtils as c}from"../../utils/crypto";import{eitherSeqRecord as m}from"../../utils/eitherSeqRecord";import{bytesToHex as o,hexToBytes as x}from"../../utils/hex";class T{constructor(r,n){this.keypair=r;this.trustchainId=n}run(r){const n=this.getAttestation(),a=this.getCredential(this.keypair.pubKeyToHex());return g.liftEither(this.getUnsignedChallengeTLV(r.tlv)).map(c.hash).map(e=>this.keypair.sign(e)).map(o).map(e=>({challenge:r.json,signature:{attestation:n,credential:a,signature:e}})).mapLeft(e=>e instanceof i?e:new y(String(e)))}getAttestation(){const r=new TextEncoder().encode(this.trustchainId),n=Uint8Array.from([2,r.length,...r]);return o(n)}getCredential(r){return{version:0,curveId:33,signAlgorithm:1,publicKey:r}}getUnsignedChallengeTLV(r){const n=new s(x(r)),a=new Map(function*(){for(;;){const t=n.extractFieldTLVEncoded();if(!t)break;yield[t.tag,t.value]}}());if(a.size>10)return p(new i("Challenge TLV contains unexpected data"));const e=(t,l)=>h.fromNullable(a.get(t)).toEither(new i(`Missing ${l} field`));return m({payloadType:()=>e(1,"Payload type"),version:()=>e(2,"Version"),challengeExpiry:()=>e(22,"Challenge expiry"),host:()=>e(32,"Host"),protocolVersion:()=>e(96,"Protocol version"),curveId:()=>e(50,"Curve ID"),publicKey:()=>e(51,"Public key"),challengeData:()=>e(18,"Challenge data"),signAlgorithm:()=>e(20,"Sign algorithm"),rpSignatureField:()=>e(21,"RP signature field")}).map(t=>Uint8Array.from([[1,t.payloadType.length,...t.payloadType],[2,t.version.length,...t.version],[18,t.challengeData.length,...t.challengeData],[22,t.challengeExpiry.length,...t.challengeExpiry],[32,t.host.length,...t.host],[96,t.protocolVersion.length,...t.protocolVersion]].flat()))}}export{T as SignChallengeWithKeypairTask};
 //# sourceMappingURL=SignChallengeWithKeypairTask.js.map

package/lib/esm/internal/app-binder/task/SignChallengeWithKeypairTask.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/task/SignChallengeWithKeypairTask.ts"],
-  "sourcesContent": ["import {\n  ByteArrayParser,\n  UnknownDAError,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either, EitherAsync, Left, Maybe } from \"purify-ts\";\n\nimport { LKRPMissingDataError } from \"@api/app-binder/Errors\";\nimport { type Keypair } from \"@api/app-binder/LKRPTypes\";\nimport {\n  type AuthenticationPayload,\n  type Challenge,\n} from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { CryptoUtils } from \"@internal/utils/crypto\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\nimport { bytesToHex, hexToBytes } from \"@internal/utils/hex\";\n\nexport class SignChallengeWithKeypairTask {\n  constructor(\n    private readonly keypair: Keypair,\n    private readonly trustchainId: string,\n  ) {}\n\n  run(\n    challenge: Challenge,\n  ): EitherAsync<LKRPMissingDataError | UnknownDAError, AuthenticationPayload> {\n    const attestation = this.getAttestation();\n    const credential = this.getCredential(this.keypair.pubKeyToHex());\n\n    return EitherAsync.liftEither(this.getUnsignedChallengeTLV(challenge.tlv))\n      .map(CryptoUtils.hash)\n      .map((hash) => this.keypair.sign(hash))\n      .map(bytesToHex)\n      .map((signature) => ({\n        challenge: challenge.json,\n        signature: { attestation, credential, signature },\n      }))\n      .mapLeft((error) =>\n        error instanceof LKRPMissingDataError\n          ? error\n          : new UnknownDAError(String(error)),\n      );\n  }\n\n  // Spec https://ledgerhq.atlassian.net/wiki/spaces/TA/pages/4335960138/ARCH+LedgerLive+Auth+specifications\n  private getAttestation() {\n    const bytes = new TextEncoder().encode(this.trustchainId);\n    const attestation = Uint8Array.from([0x02, bytes.length, ...bytes]);\n    return bytesToHex(attestation);\n  }\n\n  private getCredential(publicKey: string) {\n    return { version: 0, curveId: 33, signAlgorithm: 1, publicKey };\n  }\n\n  private getUnsignedChallengeTLV(\n    tlv: string,\n  ): Either<LKRPMissingDataError, Uint8Array> {\n    const parser = new ByteArrayParser(hexToBytes(tlv));\n    const parsed = new Map(\n      (function* () {\n        while (true) {\n          const field = parser.extractFieldTLVEncoded();\n          if (!field) break; // No more fields to extract\n          yield [field.tag, field.value];\n        }\n      })(),\n    );\n\n    // We expect 10 fields in the TLV\n    if (parsed.size > 10) {\n      return Left(\n        new LKRPMissingDataError(\"Challenge TLV contains unexpected data\"),\n      );\n    }\n\n    const getField = (tag: number, fieldName: string) =>\n      Maybe.fromNullable(parsed.get(tag)).toEither(\n        new LKRPMissingDataError(`Missing ${fieldName} field`),\n      );\n\n    return eitherSeqRecord({\n      // Unsigned fields\n      payloadType: () => getField(0x01, \"Payload type\"),\n      version: () => getField(0x02, \"Version\"),\n      challengeExpiry: () => getField(0x16, \"Challenge expiry\"),\n      host: () => getField(0x20, \"Host\"),\n      protocolVersion: () => getField(0x60, \"Protocol version\"),\n\n      // Signed fields\n      curveId: () => getField(0x32, \"Curve ID\"),\n      publicKey: () => getField(0x33, \"Public key\"),\n      challengeData: () => getField(0x12, \"Challenge data\"),\n      signAlgorithm: () => getField(0x14, \"Sign algorithm\"),\n      rpSignatureField: () => getField(0x15, \"RP signature field\"),\n    }).map((fields) =>\n      Uint8Array.from(\n        [\n          [0x01, fields.payloadType.length, ...fields.payloadType],\n          [0x02, fields.version.length, ...fields.version],\n          [0x12, fields.challengeData.length, ...fields.challengeData],\n          [0x16, fields.challengeExpiry.length, ...fields.challengeExpiry],\n          [0x20, fields.host.length, ...fields.host],\n          [0x60, fields.protocolVersion.length, ...fields.protocolVersion],\n        ].flat(),\n      ),\n    );\n  }\n}\n"],
-  "mappings": "AAAA,OACE,mBAAAA,EACA,kBAAAC,MACK,kCACP,OAAsB,eAAAC,EAAa,QAAAC,EAAM,SAAAC,MAAa,YAEtD,OAAS,wBAAAC,MAA4B,yBAMrC,OAAS,eAAAC,MAAmB,yBAC5B,OAAS,mBAAAC,MAAuB,kCAChC,OAAS,cAAAC,EAAY,cAAAC,MAAkB,sBAEhC,MAAMC,CAA6B,CACxC,YACmBC,EACAC,EACjB,CAFiB,aAAAD,EACA,kBAAAC,CAChB,CAEH,IACEC,EAC2E,CAC3E,MAAMC,EAAc,KAAK,eAAe,EAClCC,EAAa,KAAK,cAAc,KAAK,QAAQ,YAAY,CAAC,EAEhE,OAAOb,EAAY,WAAW,KAAK,wBAAwBW,EAAU,GAAG,CAAC,EACtE,IAAIP,EAAY,IAAI,EACpB,IAAKU,GAAS,KAAK,QAAQ,KAAKA,CAAI,CAAC,EACrC,IAAIR,CAAU,EACd,IAAKS,IAAe,CACnB,UAAWJ,EAAU,KACrB,UAAW,CAAE,YAAAC,EAAa,WAAAC,EAAY,UAAAE,CAAU,CAClD,EAAE,EACD,QAASC,GACRA,aAAiBb,EACba,EACA,IAAIjB,EAAe,OAAOiB,CAAK,CAAC,CACtC,CACJ,CAGQ,gBAAiB,CACvB,MAAMC,EAAQ,IAAI,YAAY,EAAE,OAAO,KAAK,YAAY,EAClDL,EAAc,WAAW,KAAK,CAAC,EAAMK,EAAM,OAAQ,GAAGA,CAAK,CAAC,EAClE,OAAOX,EAAWM,CAAW,CAC/B,CAEQ,cAAcM,EAAmB,CACvC,MAAO,CAAE,QAAS,EAAG,QAAS,GAAI,cAAe,EAAG,UAAAA,CAAU,CAChE,CAEQ,wBACNC,EAC0C,CAC1C,MAAMC,EAAS,IAAItB,EAAgBS,EAAWY,CAAG,CAAC,EAC5CE,EAAS,IAAI,IAChB,WAAa,CACZ,OAAa,CACX,MAAMC,EAAQF,EAAO,uBAAuB,EAC5C,GAAI,CAACE,EAAO,MACZ,KAAM,CAACA,EAAM,IAAKA,EAAM,KAAK,CAC/B,CACF,EAAG,CACL,EAGA,GAAID,EAAO,KAAO,GAChB,OAAOpB,EACL,IAAIE,EAAqB,wCAAwC,CACnE,EAGF,MAAMoB,EAAW,CAACC,EAAaC,IAC7BvB,EAAM,aAAamB,EAAO,IAAIG,CAAG,CAAC,EAAE,SAClC,IAAIrB,EAAqB,WAAWsB,CAAS,QAAQ,CACvD,EAEF,OAAOpB,EAAgB,CAErB,YAAa,IAAMkB,EAAS,EAAM,cAAc,EAChD,QAAS,IAAMA,EAAS,EAAM,SAAS,EACvC,gBAAiB,IAAMA,EAAS,GAAM,kBAAkB,EACxD,KAAM,IAAMA,EAAS,GAAM,MAAM,EACjC,gBAAiB,IAAMA,EAAS,GAAM,kBAAkB,EAGxD,QAAS,IAAMA,EAAS,GAAM,UAAU,EACxC,UAAW,IAAMA,EAAS,GAAM,YAAY,EAC5C,cAAe,IAAMA,EAAS,GAAM,gBAAgB,EACpD,cAAe,IAAMA,EAAS,GAAM,gBAAgB,EACpD,iBAAkB,IAAMA,EAAS,GAAM,oBAAoB,CAC7D,CAAC,EAAE,IAAKG,GACN,WAAW,KACT,CACE,CAAC,EAAMA,EAAO,YAAY,OAAQ,GAAGA,EAAO,WAAW,EACvD,CAAC,EAAMA,EAAO,QAAQ,OAAQ,GAAGA,EAAO,OAAO,EAC/C,CAAC,GAAMA,EAAO,cAAc,OAAQ,GAAGA,EAAO,aAAa,EAC3D,CAAC,GAAMA,EAAO,gBAAgB,OAAQ,GAAGA,EAAO,eAAe,EAC/D,CAAC,GAAMA,EAAO,KAAK,OAAQ,GAAGA,EAAO,IAAI,EACzC,CAAC,GAAMA,EAAO,gBAAgB,OAAQ,GAAGA,EAAO,eAAe,CACjE,EAAE,KAAK,CACT,CACF,CACF,CACF",
-  "names": ["ByteArrayParser", "UnknownDAError", "EitherAsync", "Left", "Maybe", "LKRPMissingDataError", "CryptoUtils", "eitherSeqRecord", "bytesToHex", "hexToBytes", "SignChallengeWithKeypairTask", "keypair", "trustchainId", "challenge", "attestation", "credential", "hash", "signature", "error", "bytes", "publicKey", "tlv", "parser", "parsed", "field", "getField", "tag", "fieldName", "fields"]
+  "sourcesContent": ["import { ByteArrayParser } from \"@ledgerhq/device-management-kit\";\nimport { type Either, EitherAsync, Left, Maybe } from \"purify-ts\";\n\nimport { LKRPMissingDataError, LKRPUnknownError } from \"@api/app-binder/Errors\";\nimport { type Keypair } from \"@api/app-binder/LKRPTypes\";\nimport {\n  type AuthenticationPayload,\n  type Challenge,\n} from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { CryptoUtils } from \"@internal/utils/crypto\";\nimport { eitherSeqRecord } from \"@internal/utils/eitherSeqRecord\";\nimport { bytesToHex, hexToBytes } from \"@internal/utils/hex\";\n\nexport class SignChallengeWithKeypairTask {\n  constructor(\n    private readonly keypair: Keypair,\n    private readonly trustchainId: string,\n  ) {}\n\n  run(\n    challenge: Challenge,\n  ): EitherAsync<\n    LKRPMissingDataError | LKRPUnknownError,\n    AuthenticationPayload\n  > {\n    const attestation = this.getAttestation();\n    const credential = this.getCredential(this.keypair.pubKeyToHex());\n\n    return EitherAsync.liftEither(this.getUnsignedChallengeTLV(challenge.tlv))\n      .map(CryptoUtils.hash)\n      .map((hash) => this.keypair.sign(hash))\n      .map(bytesToHex)\n      .map((signature) => ({\n        challenge: challenge.json,\n        signature: { attestation, credential, signature },\n      }))\n      .mapLeft((error) =>\n        error instanceof LKRPMissingDataError\n          ? error\n          : new LKRPUnknownError(String(error)),\n      );\n  }\n\n  // Spec https://ledgerhq.atlassian.net/wiki/spaces/TA/pages/4335960138/ARCH+LedgerLive+Auth+specifications\n  private getAttestation() {\n    const bytes = new TextEncoder().encode(this.trustchainId);\n    const attestation = Uint8Array.from([0x02, bytes.length, ...bytes]);\n    return bytesToHex(attestation);\n  }\n\n  private getCredential(publicKey: string) {\n    return { version: 0, curveId: 33, signAlgorithm: 1, publicKey };\n  }\n\n  private getUnsignedChallengeTLV(\n    tlv: string,\n  ): Either<LKRPMissingDataError, Uint8Array> {\n    const parser = new ByteArrayParser(hexToBytes(tlv));\n    const parsed = new Map(\n      (function* () {\n        while (true) {\n          const field = parser.extractFieldTLVEncoded();\n          if (!field) break; // No more fields to extract\n          yield [field.tag, field.value];\n        }\n      })(),\n    );\n\n    // We expect 10 fields in the TLV\n    if (parsed.size > 10) {\n      return Left(\n        new LKRPMissingDataError(\"Challenge TLV contains unexpected data\"),\n      );\n    }\n\n    const getField = (tag: number, fieldName: string) =>\n      Maybe.fromNullable(parsed.get(tag)).toEither(\n        new LKRPMissingDataError(`Missing ${fieldName} field`),\n      );\n\n    return eitherSeqRecord({\n      // Unsigned fields\n      payloadType: () => getField(0x01, \"Payload type\"),\n      version: () => getField(0x02, \"Version\"),\n      challengeExpiry: () => getField(0x16, \"Challenge expiry\"),\n      host: () => getField(0x20, \"Host\"),\n      protocolVersion: () => getField(0x60, \"Protocol version\"),\n\n      // Signed fields\n      curveId: () => getField(0x32, \"Curve ID\"),\n      publicKey: () => getField(0x33, \"Public key\"),\n      challengeData: () => getField(0x12, \"Challenge data\"),\n      signAlgorithm: () => getField(0x14, \"Sign algorithm\"),\n      rpSignatureField: () => getField(0x15, \"RP signature field\"),\n    }).map((fields) =>\n      Uint8Array.from(\n        [\n          [0x01, fields.payloadType.length, ...fields.payloadType],\n          [0x02, fields.version.length, ...fields.version],\n          [0x12, fields.challengeData.length, ...fields.challengeData],\n          [0x16, fields.challengeExpiry.length, ...fields.challengeExpiry],\n          [0x20, fields.host.length, ...fields.host],\n          [0x60, fields.protocolVersion.length, ...fields.protocolVersion],\n        ].flat(),\n      ),\n    );\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,kCAChC,OAAsB,eAAAC,EAAa,QAAAC,EAAM,SAAAC,MAAa,YAEtD,OAAS,wBAAAC,EAAsB,oBAAAC,MAAwB,yBAMvD,OAAS,eAAAC,MAAmB,yBAC5B,OAAS,mBAAAC,MAAuB,kCAChC,OAAS,cAAAC,EAAY,cAAAC,MAAkB,sBAEhC,MAAMC,CAA6B,CACxC,YACmBC,EACAC,EACjB,CAFiB,aAAAD,EACA,kBAAAC,CAChB,CAEH,IACEC,EAIA,CACA,MAAMC,EAAc,KAAK,eAAe,EAClCC,EAAa,KAAK,cAAc,KAAK,QAAQ,YAAY,CAAC,EAEhE,OAAOd,EAAY,WAAW,KAAK,wBAAwBY,EAAU,GAAG,CAAC,EACtE,IAAIP,EAAY,IAAI,EACpB,IAAKU,GAAS,KAAK,QAAQ,KAAKA,CAAI,CAAC,EACrC,IAAIR,CAAU,EACd,IAAKS,IAAe,CACnB,UAAWJ,EAAU,KACrB,UAAW,CAAE,YAAAC,EAAa,WAAAC,EAAY,UAAAE,CAAU,CAClD,EAAE,EACD,QAASC,GACRA,aAAiBd,EACbc,EACA,IAAIb,EAAiB,OAAOa,CAAK,CAAC,CACxC,CACJ,CAGQ,gBAAiB,CACvB,MAAMC,EAAQ,IAAI,YAAY,EAAE,OAAO,KAAK,YAAY,EAClDL,EAAc,WAAW,KAAK,CAAC,EAAMK,EAAM,OAAQ,GAAGA,CAAK,CAAC,EAClE,OAAOX,EAAWM,CAAW,CAC/B,CAEQ,cAAcM,EAAmB,CACvC,MAAO,CAAE,QAAS,EAAG,QAAS,GAAI,cAAe,EAAG,UAAAA,CAAU,CAChE,CAEQ,wBACNC,EAC0C,CAC1C,MAAMC,EAAS,IAAItB,EAAgBS,EAAWY,CAAG,CAAC,EAC5CE,EAAS,IAAI,IAChB,WAAa,CACZ,OAAa,CACX,MAAMC,EAAQF,EAAO,uBAAuB,EAC5C,GAAI,CAACE,EAAO,MACZ,KAAM,CAACA,EAAM,IAAKA,EAAM,KAAK,CAC/B,CACF,EAAG,CACL,EAGA,GAAID,EAAO,KAAO,GAChB,OAAOrB,EACL,IAAIE,EAAqB,wCAAwC,CACnE,EAGF,MAAMqB,EAAW,CAACC,EAAaC,IAC7BxB,EAAM,aAAaoB,EAAO,IAAIG,CAAG,CAAC,EAAE,SAClC,IAAItB,EAAqB,WAAWuB,CAAS,QAAQ,CACvD,EAEF,OAAOpB,EAAgB,CAErB,YAAa,IAAMkB,EAAS,EAAM,cAAc,EAChD,QAAS,IAAMA,EAAS,EAAM,SAAS,EACvC,gBAAiB,IAAMA,EAAS,GAAM,kBAAkB,EACxD,KAAM,IAAMA,EAAS,GAAM,MAAM,EACjC,gBAAiB,IAAMA,EAAS,GAAM,kBAAkB,EAGxD,QAAS,IAAMA,EAAS,GAAM,UAAU,EACxC,UAAW,IAAMA,EAAS,GAAM,YAAY,EAC5C,cAAe,IAAMA,EAAS,GAAM,gBAAgB,EACpD,cAAe,IAAMA,EAAS,GAAM,gBAAgB,EACpD,iBAAkB,IAAMA,EAAS,GAAM,oBAAoB,CAC7D,CAAC,EAAE,IAAKG,GACN,WAAW,KACT,CACE,CAAC,EAAMA,EAAO,YAAY,OAAQ,GAAGA,EAAO,WAAW,EACvD,CAAC,EAAMA,EAAO,QAAQ,OAAQ,GAAGA,EAAO,OAAO,EAC/C,CAAC,GAAMA,EAAO,cAAc,OAAQ,GAAGA,EAAO,aAAa,EAC3D,CAAC,GAAMA,EAAO,gBAAgB,OAAQ,GAAGA,EAAO,eAAe,EAC/D,CAAC,GAAMA,EAAO,KAAK,OAAQ,GAAGA,EAAO,IAAI,EACzC,CAAC,GAAMA,EAAO,gBAAgB,OAAQ,GAAGA,EAAO,eAAe,CACjE,EAAE,KAAK,CACT,CACF,CACF,CACF",
+  "names": ["ByteArrayParser", "EitherAsync", "Left", "Maybe", "LKRPMissingDataError", "LKRPUnknownError", "CryptoUtils", "eitherSeqRecord", "bytesToHex", "hexToBytes", "SignChallengeWithKeypairTask", "keypair", "trustchainId", "challenge", "attestation", "credential", "hash", "signature", "error", "bytes", "publicKey", "tlv", "parser", "parsed", "field", "getField", "tag", "fieldName", "fields"]
 }

package/lib/esm/internal/app-binder/task/utils/TrustedProperties.js

@@ -1,2 +1,2 @@
-import{ByteArrayParser as a}from"@ledgerhq/device-management-kit";import{Either as p,Left as o,Right as i}from"purify-ts";import{LKRPParsingError as P}from"../../../../api/app-binder/Errors";import{required as e}from"../../../utils/required";import{TPTags as t}from"../../../utils/TLVTags";class h{constructor(r){this.bytes=r;this.parser=new a(r)}parser;iv=null;encryptedProps=null;getIv(){if(!this.iv){const r=this.parser.extractFieldTLVEncoded();if(!r||r.tag!==0)return o(new P("Invalid trusted property: missing IV"));this.iv=r.value}return i(this.iv)}getIssuer(){return this.parseEncryptedProps().chain(r=>e(r.get(t.ISSUER)?.value,"Missing issuer in trusted properties"))}getXPriv(){return this.parseEncryptedProps().chain(r=>e(r.get(t.XPRIV)?.value,"Missing xpriv in trusted properties"))}getEphemeralPublicKey(){return this.parseEncryptedProps().chain(r=>e(r.get(t.EPHEMERAL_PUBLIC_KEY)?.value,"Missing ephemeral public key in trusted properties"))}getCommandIv(){return this.parseEncryptedProps().chain(r=>e(r.get(t.COMMAND_IV)?.value,"Missing command IV in trusted properties"))}getGroupKey(){return this.parseEncryptedProps().chain(r=>e(r.get(t.GROUPKEY)?.value,"Missing group key in trusted properties"))}getNewMember(){return this.parseEncryptedProps().chain(r=>e(r.get(t.NEW_MEMBER)?.tlv,"Missing new member in trusted properties"))}parseEncryptedProps(){return this.encryptedProps?i(this.encryptedProps):this.getIv().chain(()=>p.sequence(Array.from(E(this.parser)))).map(r=>new Map(r.map(n=>[n.tag,n]))).ifRight(r=>{this.encryptedProps=r})}}function*E(s){for(;;){const r=s.extractFieldTLVEncoded();if(!r)return;yield i(r)}}export{h as TrustedProperties};
+import{ByteArrayParser as a}from"@ledgerhq/device-management-kit";import{Either as p,Left as o,Right as i}from"purify-ts";import{LKRPParsingError as P}from"../../../../api/app-binder/Errors";import{TPTags as e}from"../../../models/Tags";import{required as t}from"../../../utils/required";class h{constructor(r){this.bytes=r;this.parser=new a(r)}parser;iv=null;encryptedProps=null;getIv(){if(!this.iv){const r=this.parser.extractFieldTLVEncoded();if(!r||r.tag!==0)return o(new P("Invalid trusted property: missing IV"));this.iv=r.value}return i(this.iv)}getIssuer(){return this.parseEncryptedProps().chain(r=>t(r.get(e.ISSUER)?.value,"Missing issuer in trusted properties"))}getXPriv(){return this.parseEncryptedProps().chain(r=>t(r.get(e.XPRIV)?.value,"Missing xpriv in trusted properties"))}getEphemeralPublicKey(){return this.parseEncryptedProps().chain(r=>t(r.get(e.EPHEMERAL_PUBLIC_KEY)?.value,"Missing ephemeral public key in trusted properties"))}getCommandIv(){return this.parseEncryptedProps().chain(r=>t(r.get(e.COMMAND_IV)?.value,"Missing command IV in trusted properties"))}getGroupKey(){return this.parseEncryptedProps().chain(r=>t(r.get(e.GROUPKEY)?.value,"Missing group key in trusted properties"))}getNewMember(){return this.parseEncryptedProps().chain(r=>t(r.get(e.NEW_MEMBER)?.tlv,"Missing new member in trusted properties"))}parseEncryptedProps(){return this.encryptedProps?i(this.encryptedProps):this.getIv().chain(()=>p.sequence(Array.from(E(this.parser)))).map(r=>new Map(r.map(n=>[n.tag,n]))).ifRight(r=>{this.encryptedProps=r})}}function*E(s){for(;;){const r=s.extractFieldTLVEncoded();if(!r)return;yield i(r)}}export{h as TrustedProperties};
 //# sourceMappingURL=TrustedProperties.js.map

package/lib/esm/internal/app-binder/task/utils/TrustedProperties.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/app-binder/task/utils/TrustedProperties.ts"],
-  "sourcesContent": ["import { ByteArrayParser } from \"@ledgerhq/device-management-kit\";\nimport { Either, Left, Right } from \"purify-ts\";\n\nimport {\n  type LKRPMissingDataError,\n  LKRPParsingError,\n} from \"@api/app-binder/Errors\";\nimport { required } from \"@internal/utils/required\";\nimport { TPTags } from \"@internal/utils/TLVTags\";\n\ntype EncryptedTPTag = Exclude<TPTags, TPTags.IV>;\ntype EncryptedTP = { tag: EncryptedTPTag; value: Uint8Array; tlv: Uint8Array };\n\nexport class TrustedProperties {\n  private readonly parser: ByteArrayParser;\n  private iv: Uint8Array | null = null;\n  private encryptedProps: Map<EncryptedTPTag, EncryptedTP> | null = null;\n\n  constructor(public readonly bytes: Uint8Array) {\n    this.parser = new ByteArrayParser(bytes);\n  }\n\n  getIv(): Either<LKRPParsingError, Uint8Array> {\n    if (!this.iv) {\n      const field = this.parser.extractFieldTLVEncoded();\n      if (!field || field.tag !== 0x00) {\n        return Left(\n          new LKRPParsingError(\"Invalid trusted property: missing IV\"),\n        );\n      }\n\n      this.iv = field.value;\n    }\n    return Right(this.iv);\n  }\n\n  getIssuer(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.ISSUER)?.value,\n        \"Missing issuer in trusted properties\",\n      ),\n    );\n  }\n\n  getXPriv(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.XPRIV)?.value,\n        \"Missing xpriv in trusted properties\",\n      ),\n    );\n  }\n\n  getEphemeralPublicKey(): Either<\n    LKRPParsingError | LKRPMissingDataError,\n    Uint8Array\n  > {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.EPHEMERAL_PUBLIC_KEY)?.value,\n        \"Missing ephemeral public key in trusted properties\",\n      ),\n    );\n  }\n\n  getCommandIv(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.COMMAND_IV)?.value,\n        \"Missing command IV in trusted properties\",\n      ),\n    );\n  }\n\n  getGroupKey(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.GROUPKEY)?.value,\n        \"Missing group key in trusted properties\",\n      ),\n    );\n  }\n\n  getNewMember(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.NEW_MEMBER)?.tlv,\n        \"Missing new member in trusted properties\",\n      ),\n    );\n  }\n\n  parseEncryptedProps(): Either<\n    LKRPParsingError,\n    Map<EncryptedTPTag, EncryptedTP>\n  > {\n    return this.encryptedProps\n      ? Right(this.encryptedProps)\n      : this.getIv()\n          .chain(() => Either.sequence(Array.from(parseTPs(this.parser))))\n          .map((fields) => new Map(fields.map((field) => [field.tag, field])))\n          .ifRight((props) => {\n            this.encryptedProps = props;\n          });\n  }\n}\n\nfunction* parseTPs(\n  parser: ByteArrayParser,\n): Generator<Either<LKRPParsingError, EncryptedTP>> {\n  while (true) {\n    const field = parser.extractFieldTLVEncoded();\n    if (!field) return;\n    yield Right(field);\n  }\n}\n"],
-  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,kCAChC,OAAS,UAAAC,EAAQ,QAAAC,EAAM,SAAAC,MAAa,YAEpC,OAEE,oBAAAC,MACK,yBACP,OAAS,YAAAC,MAAgB,2BACzB,OAAS,UAAAC,MAAc,0BAKhB,MAAMC,CAAkB,CAK7B,YAA4BC,EAAmB,CAAnB,WAAAA,EAC1B,KAAK,OAAS,IAAIR,EAAgBQ,CAAK,CACzC,CANiB,OACT,GAAwB,KACxB,eAA0D,KAMlE,OAA8C,CAC5C,GAAI,CAAC,KAAK,GAAI,CACZ,MAAMC,EAAQ,KAAK,OAAO,uBAAuB,EACjD,GAAI,CAACA,GAASA,EAAM,MAAQ,EAC1B,OAAOP,EACL,IAAIE,EAAiB,sCAAsC,CAC7D,EAGF,KAAK,GAAKK,EAAM,KAClB,CACA,OAAON,EAAM,KAAK,EAAE,CACtB,CAEA,WAAyE,CACvE,OAAO,KAAK,oBAAoB,EAAE,MAAOO,GACvCL,EACEK,EAAM,IAAIJ,EAAO,MAAM,GAAG,MAC1B,sCACF,CACF,CACF,CAEA,UAAwE,CACtE,OAAO,KAAK,oBAAoB,EAAE,MAAOI,GACvCL,EACEK,EAAM,IAAIJ,EAAO,KAAK,GAAG,MACzB,qCACF,CACF,CACF,CAEA,uBAGE,CACA,OAAO,KAAK,oBAAoB,EAAE,MAAOI,GACvCL,EACEK,EAAM,IAAIJ,EAAO,oBAAoB,GAAG,MACxC,oDACF,CACF,CACF,CAEA,cAA4E,CAC1E,OAAO,KAAK,oBAAoB,EAAE,MAAOI,GACvCL,EACEK,EAAM,IAAIJ,EAAO,UAAU,GAAG,MAC9B,0CACF,CACF,CACF,CAEA,aAA2E,CACzE,OAAO,KAAK,oBAAoB,EAAE,MAAOI,GACvCL,EACEK,EAAM,IAAIJ,EAAO,QAAQ,GAAG,MAC5B,yCACF,CACF,CACF,CAEA,cAA4E,CAC1E,OAAO,KAAK,oBAAoB,EAAE,MAAOI,GACvCL,EACEK,EAAM,IAAIJ,EAAO,UAAU,GAAG,IAC9B,0CACF,CACF,CACF,CAEA,qBAGE,CACA,OAAO,KAAK,eACRH,EAAM,KAAK,cAAc,EACzB,KAAK,MAAM,EACR,MAAM,IAAMF,EAAO,SAAS,MAAM,KAAKU,EAAS,KAAK,MAAM,CAAC,CAAC,CAAC,EAC9D,IAAKC,GAAW,IAAI,IAAIA,EAAO,IAAKH,GAAU,CAACA,EAAM,IAAKA,CAAK,CAAC,CAAC,CAAC,EAClE,QAASC,GAAU,CAClB,KAAK,eAAiBA,CACxB,CAAC,CACT,CACF,CAEA,SAAUC,EACRE,EACkD,CAClD,OAAa,CACX,MAAMJ,EAAQI,EAAO,uBAAuB,EAC5C,GAAI,CAACJ,EAAO,OACZ,MAAMN,EAAMM,CAAK,CACnB,CACF",
-  "names": ["ByteArrayParser", "Either", "Left", "Right", "LKRPParsingError", "required", "TPTags", "TrustedProperties", "bytes", "field", "props", "parseTPs", "fields", "parser"]
+  "sourcesContent": ["import { ByteArrayParser } from \"@ledgerhq/device-management-kit\";\nimport { Either, Left, Right } from \"purify-ts\";\n\nimport {\n  type LKRPMissingDataError,\n  LKRPParsingError,\n} from \"@api/app-binder/Errors\";\nimport { TPTags } from \"@internal/models/Tags\";\nimport { required } from \"@internal/utils/required\";\n\ntype EncryptedTPTag = Exclude<TPTags, TPTags.IV>;\ntype EncryptedTP = { tag: EncryptedTPTag; value: Uint8Array; tlv: Uint8Array };\n\nexport class TrustedProperties {\n  private readonly parser: ByteArrayParser;\n  private iv: Uint8Array | null = null;\n  private encryptedProps: Map<EncryptedTPTag, EncryptedTP> | null = null;\n\n  constructor(public readonly bytes: Uint8Array) {\n    this.parser = new ByteArrayParser(bytes);\n  }\n\n  getIv(): Either<LKRPParsingError, Uint8Array> {\n    if (!this.iv) {\n      const field = this.parser.extractFieldTLVEncoded();\n      if (!field || field.tag !== 0x00) {\n        return Left(\n          new LKRPParsingError(\"Invalid trusted property: missing IV\"),\n        );\n      }\n\n      this.iv = field.value;\n    }\n    return Right(this.iv);\n  }\n\n  getIssuer(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.ISSUER)?.value,\n        \"Missing issuer in trusted properties\",\n      ),\n    );\n  }\n\n  getXPriv(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.XPRIV)?.value,\n        \"Missing xpriv in trusted properties\",\n      ),\n    );\n  }\n\n  getEphemeralPublicKey(): Either<\n    LKRPParsingError | LKRPMissingDataError,\n    Uint8Array\n  > {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.EPHEMERAL_PUBLIC_KEY)?.value,\n        \"Missing ephemeral public key in trusted properties\",\n      ),\n    );\n  }\n\n  getCommandIv(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.COMMAND_IV)?.value,\n        \"Missing command IV in trusted properties\",\n      ),\n    );\n  }\n\n  getGroupKey(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.GROUPKEY)?.value,\n        \"Missing group key in trusted properties\",\n      ),\n    );\n  }\n\n  getNewMember(): Either<LKRPParsingError | LKRPMissingDataError, Uint8Array> {\n    return this.parseEncryptedProps().chain((props) =>\n      required(\n        props.get(TPTags.NEW_MEMBER)?.tlv,\n        \"Missing new member in trusted properties\",\n      ),\n    );\n  }\n\n  parseEncryptedProps(): Either<\n    LKRPParsingError,\n    Map<EncryptedTPTag, EncryptedTP>\n  > {\n    return this.encryptedProps\n      ? Right(this.encryptedProps)\n      : this.getIv()\n          .chain(() => Either.sequence(Array.from(parseTPs(this.parser))))\n          .map((fields) => new Map(fields.map((field) => [field.tag, field])))\n          .ifRight((props) => {\n            this.encryptedProps = props;\n          });\n  }\n}\n\nfunction* parseTPs(\n  parser: ByteArrayParser,\n): Generator<Either<LKRPParsingError, EncryptedTP>> {\n  while (true) {\n    const field = parser.extractFieldTLVEncoded();\n    if (!field) return;\n    yield Right(field);\n  }\n}\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,kCAChC,OAAS,UAAAC,EAAQ,QAAAC,EAAM,SAAAC,MAAa,YAEpC,OAEE,oBAAAC,MACK,yBACP,OAAS,UAAAC,MAAc,wBACvB,OAAS,YAAAC,MAAgB,2BAKlB,MAAMC,CAAkB,CAK7B,YAA4BC,EAAmB,CAAnB,WAAAA,EAC1B,KAAK,OAAS,IAAIR,EAAgBQ,CAAK,CACzC,CANiB,OACT,GAAwB,KACxB,eAA0D,KAMlE,OAA8C,CAC5C,GAAI,CAAC,KAAK,GAAI,CACZ,MAAMC,EAAQ,KAAK,OAAO,uBAAuB,EACjD,GAAI,CAACA,GAASA,EAAM,MAAQ,EAC1B,OAAOP,EACL,IAAIE,EAAiB,sCAAsC,CAC7D,EAGF,KAAK,GAAKK,EAAM,KAClB,CACA,OAAON,EAAM,KAAK,EAAE,CACtB,CAEA,WAAyE,CACvE,OAAO,KAAK,oBAAoB,EAAE,MAAOO,GACvCJ,EACEI,EAAM,IAAIL,EAAO,MAAM,GAAG,MAC1B,sCACF,CACF,CACF,CAEA,UAAwE,CACtE,OAAO,KAAK,oBAAoB,EAAE,MAAOK,GACvCJ,EACEI,EAAM,IAAIL,EAAO,KAAK,GAAG,MACzB,qCACF,CACF,CACF,CAEA,uBAGE,CACA,OAAO,KAAK,oBAAoB,EAAE,MAAOK,GACvCJ,EACEI,EAAM,IAAIL,EAAO,oBAAoB,GAAG,MACxC,oDACF,CACF,CACF,CAEA,cAA4E,CAC1E,OAAO,KAAK,oBAAoB,EAAE,MAAOK,GACvCJ,EACEI,EAAM,IAAIL,EAAO,UAAU,GAAG,MAC9B,0CACF,CACF,CACF,CAEA,aAA2E,CACzE,OAAO,KAAK,oBAAoB,EAAE,MAAOK,GACvCJ,EACEI,EAAM,IAAIL,EAAO,QAAQ,GAAG,MAC5B,yCACF,CACF,CACF,CAEA,cAA4E,CAC1E,OAAO,KAAK,oBAAoB,EAAE,MAAOK,GACvCJ,EACEI,EAAM,IAAIL,EAAO,UAAU,GAAG,IAC9B,0CACF,CACF,CACF,CAEA,qBAGE,CACA,OAAO,KAAK,eACRF,EAAM,KAAK,cAAc,EACzB,KAAK,MAAM,EACR,MAAM,IAAMF,EAAO,SAAS,MAAM,KAAKU,EAAS,KAAK,MAAM,CAAC,CAAC,CAAC,EAC9D,IAAKC,GAAW,IAAI,IAAIA,EAAO,IAAKH,GAAU,CAACA,EAAM,IAAKA,CAAK,CAAC,CAAC,CAAC,EAClE,QAASC,GAAU,CAClB,KAAK,eAAiBA,CACxB,CAAC,CACT,CACF,CAEA,SAAUC,EACRE,EACkD,CAClD,OAAa,CACX,MAAMJ,EAAQI,EAAO,uBAAuB,EAC5C,GAAI,CAACJ,EAAO,OACZ,MAAMN,EAAMM,CAAK,CACnB,CACF",
+  "names": ["ByteArrayParser", "Either", "Left", "Right", "LKRPParsingError", "TPTags", "required", "TrustedProperties", "bytes", "field", "props", "parseTPs", "fields", "parser"]
 }

package/lib/esm/internal/lkrp-datasource/data/HttpLKRPDataSource.js

@@ -1,2 +1,2 @@
-var d=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var m=(n,t,e,r)=>{for(var i=r>1?void 0:r?f(t,e):t,s=n.length-1,o;s>=0;s--)(o=n[s])&&(i=(r?o(t,e,i):o(i))||i);return r&&i&&d(t,e,i),i},c=(n,t)=>(e,r)=>t(e,r,n);import{inject as g,injectable as y}from"inversify";import{EitherAsync as R,Just as u,Maybe as b,Nothing as l,Right as p}from"purify-ts";import{LKRPHttpRequestError as h,LKRPUnauthorizedError as T}from"../../../api/app-binder/Errors";import{lkrpDatasourceTypes as P}from"../../lkrp-datasource/di/lkrpDatasourceTypes";import{LKRPBlockStream as $}from"../../utils/LKRPBlockStream";let a=class{constructor(t){this.baseUrl=t}getChallenge(){return this.request("/challenge",l)}authenticate(t){return this.request("/authenticate",l,{method:"POST",body:JSON.stringify(t)}).map(e=>({jwt:e,trustchainId:b.fromNullable(Object.keys(e.permissions).find(r=>!!e.permissions[r]?.["m/"]))}))}getTrustchainById(t,e){return this.request(`/trustchain/${t}`,u(e)).map(r=>Object.fromEntries(Object.entries(r).map(([i,s])=>[i,$.fromHex(s)])))}postDerivation(t,e,r){return this.request(`/trustchain/${t}/derivation`,u(r),{method:"POST",body:JSON.stringify(e.toString())})}putCommands(t,e,r,i){return this.request(`/trustchain/${t}/commands`,u(i),{method:"PUT",body:JSON.stringify({path:e,blocks:[r.toString()]})})}request(t,e,r){const i=this.baseUrl+t;return R.fromPromise(async()=>{const s=await fetch(i,{...r,headers:{...r?.headers,"Content-Type":"application/json",...e.mapOrDefault(({access_token:o})=>({Authorization:`Bearer ${o}`}),{})}});switch(s.status){case 204:return p(void 0);case 401:throw new T(`Unauthorized request to ${i}: [${s.status}] ${s.statusText}`);default:if(!s.ok)throw new h(`Failed to fetch ${i}: [${s.status}] ${s.statusText}`);return p(await s.json())}}).mapLeft(s=>s instanceof h?s:new h(s))}};a=m([y(),c(0,g(P.BaseUrl))],a);export{a as HttpLKRPDataSource};
+var p=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var h=(o,t,r,e)=>{for(var a=e>1?void 0:e?d(t,r):t,i=o.length-1,s;i>=0;i--)(s=o[i])&&(a=(e?s(t,r,a):s(a))||a);return e&&a&&p(t,r,a),a},l=(o,t)=>(r,e)=>t(r,e,o);import{inject as y,injectable as R}from"inversify";import{EitherAsync as u,Just as c,Left as P,Maybe as S,Nothing as g,Right as f}from"purify-ts";import{LKRPDataSourceError as T}from"../../../api/app-binder/Errors";import{lkrpDatasourceTypes as b}from"../../lkrp-datasource/di/lkrpDatasourceTypes";import{LKRPBlockStream as E}from"../../utils/LKRPBlockStream";let m=class{constructor(t){this.baseUrl=t}getChallenge(){return this.request("/challenge",g)}authenticate(t){return this.request("/authenticate",g,{method:"POST",body:JSON.stringify(t)}).map(r=>({jwt:r,trustchainId:S.fromNullable(Object.keys(r.permissions).find(e=>!!r.permissions[e]?.["m/"]))}))}getTrustchainById(t,r){return this.request(`/trustchain/${t}`,c(r)).map(e=>Object.fromEntries(Object.entries(e).map(([a,i])=>[a,E.fromHex(i)])))}postDerivation(t,r,e){return this.request(`/trustchain/${t}/derivation`,c(e),{method:"POST",body:JSON.stringify(r.toString())})}putCommands(t,r,e,a){return this.request(`/trustchain/${t}/commands`,c(a),{method:"PUT",body:JSON.stringify({path:r,blocks:[e.toString()]})})}request(t,r,e){const a=this.baseUrl+t,i={...e?.headers,"Content-Type":"application/json",...r.mapOrDefault(({access_token:s})=>({Authorization:`Bearer ${s}`}),{})};return u(()=>fetch(a,{...e,headers:i})).mapLeft(s=>({status:"UNKNOWN",message:s.message||"Unknown error"})).chain(async s=>{switch(s.status){case 204:return f(void 0);default:return u(()=>s.json()).mapLeft(n=>n.message).map(n=>s.ok?f(n):P(n.message)).chain(u.liftEither).mapLeft(n=>({status:k.get(s.status)??"UNKNOWN",message:`[${s.status}] ${n||s.statusText}`}))}}).mapLeft(({status:s,message:n})=>new T({status:s,message:`${n??"Unknown error"} (from: ${a})`}))}};m=h([R(),l(0,y(b.BaseUrl))],m);const k=new Map([[400,"BAD_REQUEST"],[401,"UNAUTHORIZED"]]);export{m as HttpLKRPDataSource};
 //# sourceMappingURL=HttpLKRPDataSource.js.map

package/lib/esm/internal/lkrp-datasource/data/HttpLKRPDataSource.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/lkrp-datasource/data/HttpLKRPDataSource.ts"],
-  "sourcesContent": ["import { inject, injectable } from \"inversify\";\nimport { EitherAsync, Just, Maybe, Nothing, Right } from \"purify-ts\";\n\nimport {\n  LKRPHttpRequestError,\n  LKRPUnauthorizedError,\n} from \"@api/app-binder/Errors\";\nimport { JWT } from \"@api/app-binder/LKRPTypes\";\nimport { lkrpDatasourceTypes } from \"@internal/lkrp-datasource/di/lkrpDatasourceTypes\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\n\nimport {\n  AuthenticationPayload,\n  Challenge,\n  LKRPDataSource,\n} from \"./LKRPDataSource\";\n\n@injectable()\nexport class HttpLKRPDataSource implements LKRPDataSource {\n  constructor(\n    @inject(lkrpDatasourceTypes.BaseUrl) private readonly baseUrl: string,\n  ) {}\n\n  getChallenge() {\n    return this.request<Challenge>(\"/challenge\", Nothing);\n  }\n\n  authenticate(payload: AuthenticationPayload) {\n    return this.request<JWT>(\"/authenticate\", Nothing, {\n      method: \"POST\",\n      body: JSON.stringify(payload),\n    }).map((jwt) => ({\n      jwt,\n      trustchainId: Maybe.fromNullable(\n        Object.keys(jwt.permissions).find((id) =>\n          Boolean(jwt.permissions[id]?.[\"m/\"]),\n        ),\n      ),\n    }));\n  }\n\n  getTrustchainById(id: string, jwt: JWT) {\n    return this.request<{ [path: string]: string }>(\n      `/trustchain/${id}`,\n      Just(jwt),\n    ).map((serialized) =>\n      Object.fromEntries(\n        Object.entries(serialized).map(([path, stream]) => [\n          path,\n          LKRPBlockStream.fromHex(stream),\n        ]),\n      ),\n    );\n  }\n\n  postDerivation(id: string, block: LKRPBlock, jwt: JWT) {\n    return this.request<void>(`/trustchain/${id}/derivation`, Just(jwt), {\n      method: \"POST\",\n      body: JSON.stringify(block.toString()),\n    });\n  }\n\n  putCommands(id: string, path: string, block: LKRPBlock, jwt: JWT) {\n    return this.request<void>(`/trustchain/${id}/commands`, Just(jwt), {\n      method: \"PUT\",\n      body: JSON.stringify({ path, blocks: [block.toString()] }),\n    });\n  }\n\n  private request<Res>(\n    endpoint: `/${string}`,\n    jwt: Maybe<{ access_token: string }>,\n    init?: RequestInit,\n  ): EitherAsync<LKRPHttpRequestError, Res> {\n    const href = this.baseUrl + endpoint;\n\n    return EitherAsync.fromPromise(async () => {\n      const response = await fetch(href, {\n        ...init,\n        headers: {\n          ...init?.headers,\n          \"Content-Type\": \"application/json\",\n          ...jwt.mapOrDefault<{ Authorization?: string }>(\n            ({ access_token }) => ({ Authorization: `Bearer ${access_token}` }),\n            {},\n          ),\n        },\n      });\n      switch (response.status) {\n        case 204:\n          return Right(undefined as Res);\n\n        case 401:\n          throw new LKRPUnauthorizedError(\n            `Unauthorized request to ${href}: [${response.status}] ${response.statusText}`,\n          );\n\n        default:\n          if (!response.ok) {\n            throw new LKRPHttpRequestError(\n              `Failed to fetch ${href}: [${response.status}] ${response.statusText}`,\n            );\n          }\n          return Right((await response.json()) as Res);\n      }\n    }).mapLeft((error: unknown) =>\n      error instanceof LKRPHttpRequestError\n        ? error\n        : new LKRPHttpRequestError(error),\n    );\n  }\n}\n"],
-  "mappings": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YACnC,OAAS,eAAAC,EAAa,QAAAC,EAAM,SAAAC,EAAO,WAAAC,EAAS,SAAAC,MAAa,YAEzD,OACE,wBAAAC,EACA,yBAAAC,MACK,yBAEP,OAAS,uBAAAC,MAA2B,mDAEpC,OAAS,mBAAAC,MAAuB,kCASzB,IAAMC,EAAN,KAAmD,CACxD,YACwDC,EACtD,CADsD,aAAAA,CACrD,CAEH,cAAe,CACb,OAAO,KAAK,QAAmB,aAAcC,CAAO,CACtD,CAEA,aAAaC,EAAgC,CAC3C,OAAO,KAAK,QAAa,gBAAiBD,EAAS,CACjD,OAAQ,OACR,KAAM,KAAK,UAAUC,CAAO,CAC9B,CAAC,EAAE,IAAKC,IAAS,CACf,IAAAA,EACA,aAAcC,EAAM,aAClB,OAAO,KAAKD,EAAI,WAAW,EAAE,KAAME,GACjC,EAAQF,EAAI,YAAYE,CAAE,IAAI,IAAI,CACpC,CACF,CACF,EAAE,CACJ,CAEA,kBAAkBA,EAAYF,EAAU,CACtC,OAAO,KAAK,QACV,eAAeE,CAAE,GACjBC,EAAKH,CAAG,CACV,EAAE,IAAKI,GACL,OAAO,YACL,OAAO,QAAQA,CAAU,EAAE,IAAI,CAAC,CAACC,EAAMC,CAAM,IAAM,CACjDD,EACAE,EAAgB,QAAQD,CAAM,CAChC,CAAC,CACH,CACF,CACF,CAEA,eAAeJ,EAAYM,EAAkBR,EAAU,CACrD,OAAO,KAAK,QAAc,eAAeE,CAAE,cAAeC,EAAKH,CAAG,EAAG,CACnE,OAAQ,OACR,KAAM,KAAK,UAAUQ,EAAM,SAAS,CAAC,CACvC,CAAC,CACH,CAEA,YAAYN,EAAYG,EAAcG,EAAkBR,EAAU,CAChE,OAAO,KAAK,QAAc,eAAeE,CAAE,YAAaC,EAAKH,CAAG,EAAG,CACjE,OAAQ,MACR,KAAM,KAAK,UAAU,CAAE,KAAAK,EAAM,OAAQ,CAACG,EAAM,SAAS,CAAC,CAAE,CAAC,CAC3D,CAAC,CACH,CAEQ,QACNC,EACAT,EACAU,EACwC,CACxC,MAAMC,EAAO,KAAK,QAAUF,EAE5B,OAAOG,EAAY,YAAY,SAAY,CACzC,MAAMC,EAAW,MAAM,MAAMF,EAAM,CACjC,GAAGD,EACH,QAAS,CACP,GAAGA,GAAM,QACT,eAAgB,mBAChB,GAAGV,EAAI,aACL,CAAC,CAAE,aAAAc,CAAa,KAAO,CAAE,cAAe,UAAUA,CAAY,EAAG,GACjE,CAAC,CACH,CACF,CACF,CAAC,EACD,OAAQD,EAAS,OAAQ,CACvB,IAAK,KACH,OAAOE,EAAM,MAAgB,EAE/B,IAAK,KACH,MAAM,IAAIC,EACR,2BAA2BL,CAAI,MAAME,EAAS,MAAM,KAAKA,EAAS,UAAU,EAC9E,EAEF,QACE,GAAI,CAACA,EAAS,GACZ,MAAM,IAAII,EACR,mBAAmBN,CAAI,MAAME,EAAS,MAAM,KAAKA,EAAS,UAAU,EACtE,EAEF,OAAOE,EAAO,MAAMF,EAAS,KAAK,CAAS,CAC/C,CACF,CAAC,EAAE,QAASK,GACVA,aAAiBD,EACbC,EACA,IAAID,EAAqBC,CAAK,CACpC,CACF,CACF,EA7FatB,EAANuB,EAAA,CADNC,EAAW,EAGPC,EAAA,EAAAC,EAAOC,EAAoB,OAAO,IAF1B3B",
-  "names": ["inject", "injectable", "EitherAsync", "Just", "Maybe", "Nothing", "Right", "LKRPHttpRequestError", "LKRPUnauthorizedError", "lkrpDatasourceTypes", "LKRPBlockStream", "HttpLKRPDataSource", "baseUrl", "Nothing", "payload", "jwt", "Maybe", "id", "Just", "serialized", "path", "stream", "LKRPBlockStream", "block", "endpoint", "init", "href", "EitherAsync", "response", "access_token", "Right", "LKRPUnauthorizedError", "LKRPHttpRequestError", "error", "__decorateClass", "injectable", "__decorateParam", "inject", "lkrpDatasourceTypes"]
+  "sourcesContent": ["import { inject, injectable } from \"inversify\";\nimport { EitherAsync, Just, Left, Maybe, Nothing, Right } from \"purify-ts\";\n\nimport {\n  LKRPDataSourceError,\n  LKRPDataSourceErrorStatus,\n} from \"@api/app-binder/Errors\";\nimport { JWT } from \"@api/app-binder/LKRPTypes\";\nimport { lkrpDatasourceTypes } from \"@internal/lkrp-datasource/di/lkrpDatasourceTypes\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\n\nimport {\n  AuthenticationPayload,\n  Challenge,\n  LKRPDataSource,\n} from \"./LKRPDataSource\";\n\n@injectable()\nexport class HttpLKRPDataSource implements LKRPDataSource {\n  constructor(\n    @inject(lkrpDatasourceTypes.BaseUrl) private readonly baseUrl: string,\n  ) {}\n\n  getChallenge() {\n    return this.request<Challenge>(\"/challenge\", Nothing);\n  }\n\n  authenticate(payload: AuthenticationPayload) {\n    return this.request<JWT>(\"/authenticate\", Nothing, {\n      method: \"POST\",\n      body: JSON.stringify(payload),\n    }).map((jwt) => ({\n      jwt,\n      trustchainId: Maybe.fromNullable(\n        Object.keys(jwt.permissions).find((id) =>\n          Boolean(jwt.permissions[id]?.[\"m/\"]),\n        ),\n      ),\n    }));\n  }\n\n  getTrustchainById(id: string, jwt: JWT) {\n    return this.request<{ [path: string]: string }>(\n      `/trustchain/${id}`,\n      Just(jwt),\n    ).map((serialized) =>\n      Object.fromEntries(\n        Object.entries(serialized).map(([path, stream]) => [\n          path,\n          LKRPBlockStream.fromHex(stream),\n        ]),\n      ),\n    );\n  }\n\n  postDerivation(id: string, block: LKRPBlock, jwt: JWT) {\n    return this.request<void>(`/trustchain/${id}/derivation`, Just(jwt), {\n      method: \"POST\",\n      body: JSON.stringify(block.toString()),\n    });\n  }\n\n  putCommands(id: string, path: string, block: LKRPBlock, jwt: JWT) {\n    return this.request<void>(`/trustchain/${id}/commands`, Just(jwt), {\n      method: \"PUT\",\n      body: JSON.stringify({ path, blocks: [block.toString()] }),\n    });\n  }\n\n  private request<Res>(\n    endpoint: `/${string}`,\n    jwt: Maybe<{ access_token: string }>,\n    init?: RequestInit,\n  ): EitherAsync<LKRPDataSourceError, Res> {\n    const href = this.baseUrl + endpoint;\n    const headers = {\n      ...init?.headers,\n      \"Content-Type\": \"application/json\",\n      ...jwt.mapOrDefault<{ Authorization?: string }>(\n        ({ access_token }) => ({ Authorization: `Bearer ${access_token}` }),\n        {},\n      ),\n    };\n\n    return EitherAsync(() => fetch(href, { ...init, headers }))\n      .mapLeft((err) => ({\n        status: \"UNKNOWN\" as const,\n        message: (err as Partial<Error>).message || \"Unknown error\",\n      }))\n      .chain(async (response) => {\n        switch (response.status) {\n          case 204:\n            return Right(undefined as Res);\n\n          default:\n            return EitherAsync(() => response.json())\n              .mapLeft((err) => (err as Partial<Error>).message)\n              .map((data) =>\n                response.ok\n                  ? Right(data as Res)\n                  : Left((data as { message?: string }).message),\n              )\n              .chain(EitherAsync.liftEither)\n              .mapLeft((message) => ({\n                status: statusMap.get(response.status) ?? \"UNKNOWN\",\n                message: `[${response.status}] ${message || response.statusText}`,\n              }));\n        }\n      })\n      .mapLeft(\n        ({ status, message }) =>\n          new LKRPDataSourceError({\n            status,\n            message: `${message ?? \"Unknown error\"} (from: ${href})`,\n          }),\n      );\n  }\n}\n\nconst statusMap = new Map<unknown, LKRPDataSourceErrorStatus>([\n  [400, \"BAD_REQUEST\"],\n  [401, \"UNAUTHORIZED\"],\n]);\n"],
+  "mappings": "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",
+  "names": ["inject", "injectable", "EitherAsync", "Just", "Left", "Maybe", "Nothing", "Right", "LKRPDataSourceError", "lkrpDatasourceTypes", "LKRPBlockStream", "HttpLKRPDataSource", "baseUrl", "Nothing", "payload", "jwt", "Maybe", "id", "Just", "serialized", "path", "stream", "LKRPBlockStream", "block", "endpoint", "init", "href", "headers", "access_token", "EitherAsync", "err", "response", "Right", "data", "Left", "message", "statusMap", "status", "LKRPDataSourceError", "__decorateClass", "injectable", "__decorateParam", "inject", "lkrpDatasourceTypes"]
 }

package/lib/esm/internal/lkrp-datasource/data/HttpLKRPDataSource.test.js

@@ -1,2 +1,2 @@
-import{Just as b,Left as d,Nothing as S,Right as r}from"purify-ts";import{LKRPHttpRequestError as h,LKRPUnauthorizedError as T}from"../../../api/app-binder/Errors";import{LKRPBlock as m}from"../../utils/LKRPBlock";import{LKRPBlockStream as p}from"../../utils/LKRPBlockStream";import{HttpLKRPDataSource as c}from"./HttpLKRPDataSource";const n={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 s=await new c(t).getChallenge();expect(a).toHaveBeenCalledWith(`${t}/challenge`,{headers:{"Content-Type":"application/json"}}),expect(s).toEqual(r(e))}),it("should handle fetch error",async()=>{const e=new Error("Random error");a.mockRejectedValueOnce(e);const s=await new c(t).getChallenge();expect(s).toEqual(d(new h(e)))})}),describe("authenticate",()=>{it("should fetch a JWT when the authentication is successful",async()=>{a.mockResolvedValueOnce({ok:!0,json:()=>Promise.resolve(n)});const o=await new c(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(o).toEqual(r({jwt:n,trustchainId:b("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 s=await new c(t).authenticate({challenge:i,signature:u});expect(s).toEqual(r({jwt:e,trustchainId:S}))}),it("should handle authentication error",async()=>{a.mockResolvedValueOnce({ok:!1,status:401,statusText:"Unauthorized"});const o=await new c(t).authenticate({challenge:i,signature:u});expect(o).toEqual(d(new T(`Unauthorized request to ${t}/authenticate: [401] Unauthorized`)))})}),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 s=await new c(t).getTrustchainById("TRUSTCHAIN_ID",n);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID`,{headers:{"Content-Type":"application/json",Authorization:`Bearer ${n.access_token}`}}),expect(s).toEqual(r({"m/":p.fromHex("0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d"),"m/16'":p.fromHex("1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b")}))}),it("should handle errors",async()=>{a.mockResolvedValueOnce({ok:!1,status:500,statusText:"Internal Server Error"});const o=await new c(t).getTrustchainById("TRUSTCHAIN_ID",n);expect(o).toEqual(d(new h(`Failed to fetch ${t}/trustchain/TRUSTCHAIN_ID: [500] Internal Server Error`)))})}),describe("postDerivation",()=>{it("should post derivation successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",o=m.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const l=await new c(t).postDerivation("TRUSTCHAIN_ID",o,n);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/derivation`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${n.access_token}`},body:JSON.stringify(e)}),expect(l).toEqual(r(void 0))})}),describe("putCommands",()=>{it("should put commands successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",o=m.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const l=await new c(t).putCommands("TRUSTCHAIN_ID","m/0'/16'/0'",o,n);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/commands`,{method:"PUT",headers:{"Content-Type":"application/json",Authorization:`Bearer ${n.access_token}`},body:JSON.stringify({path:"m/0'/16'/0'",blocks:[e]})}),expect(l).toEqual(r(void 0))})})});
+import{Just as b,Left as d,Nothing as S,Right as r}from"purify-ts";import{LKRPDataSourceError as h}from"../../../api/app-binder/Errors";import{LKRPBlock as m}from"../../utils/LKRPBlock";import{LKRPBlockStream as p}from"../../utils/LKRPBlockStream";import{HttpLKRPDataSource as c}from"./HttpLKRPDataSource";const n={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 s=await new c(t).getChallenge();expect(a).toHaveBeenCalledWith(`${t}/challenge`,{headers:{"Content-Type":"application/json"}}),expect(s).toEqual(r(e))}),it("should handle fetch error",async()=>{const e={status:"UNKNOWN",message:"Random error"};a.mockRejectedValueOnce(e);const s=await new c(t).getChallenge();expect(s).toEqual(d(new h({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(n)});const o=await new c(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(o).toEqual(r({jwt:n,trustchainId:b("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 s=await new c(t).authenticate({challenge:i,signature:u});expect(s).toEqual(r({jwt:e,trustchainId:S}))}),it("should handle authentication error",async()=>{a.mockResolvedValueOnce({ok:!1,status:401,statusText:"Unauthorized",json:()=>Promise.resolve({message:"Unauthorized access"})});const o=await new c(t).authenticate({challenge:i,signature:u});expect(o).toEqual(d(new h({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 s=await new c(t).getTrustchainById("TRUSTCHAIN_ID",n);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID`,{headers:{"Content-Type":"application/json",Authorization:`Bearer ${n.access_token}`}}),expect(s).toEqual(r({"m/":p.fromHex("0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d"),"m/16'":p.fromHex("1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b")}))}),it("should handle errors",async()=>{a.mockResolvedValueOnce({ok:!1,status:500,statusText:"Internal Server Error",json:()=>Promise.resolve({})});const o=await new c(t).getTrustchainById("TRUSTCHAIN_ID",n);expect(o).toEqual(d(new h({status:"UNKNOWN",message:`[500] Internal Server Error (from: ${t}/trustchain/TRUSTCHAIN_ID)`})))})}),describe("postDerivation",()=>{it("should post derivation successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",o=m.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const l=await new c(t).postDerivation("TRUSTCHAIN_ID",o,n);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/derivation`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${n.access_token}`},body:JSON.stringify(e)}),expect(l).toEqual(r(void 0))})}),describe("putCommands",()=>{it("should put commands successfully",async()=>{const e="0102030405060708090a0b0c0d0e0f",o=m.fromHex(e);a.mockResolvedValueOnce({ok:!0,status:204});const l=await new c(t).putCommands("TRUSTCHAIN_ID","m/0'/16'/0'",o,n);expect(a).toHaveBeenCalledWith(`${t}/trustchain/TRUSTCHAIN_ID/commands`,{method:"PUT",headers:{"Content-Type":"application/json",Authorization:`Bearer ${n.access_token}`},body:JSON.stringify({path:"m/0'/16'/0'",blocks:[e]})}),expect(l).toEqual(r(void 0))})})});
 //# sourceMappingURL=HttpLKRPDataSource.test.js.map

package/lib/esm/internal/lkrp-datasource/data/HttpLKRPDataSource.test.js.map

@@ -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 {\n  LKRPHttpRequestError,\n  LKRPUnauthorizedError,\n} from \"@api/app-binder/Errors\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\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 = new Error(\"Random error\");\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(Left(new LKRPHttpRequestError(error)));\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      } 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 LKRPUnauthorizedError(\n            `Unauthorized request to ${baseUrl}/authenticate: [401] Unauthorized`,\n          ),\n        ),\n      );\n    });\n  });\n\n  describe(\"getTrustchainById\", () => {\n    it(\"should fetch trustchain by ID successfully\", async () => {\n      // GIVEN\n      const mockTrustchain = {\n        \"m/\": \"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d\",\n        \"m/16'\": \"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b\",\n      };\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockTrustchain),\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({\n          \"m/\": LKRPBlockStream.fromHex(\n            \"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d\",\n          ),\n          \"m/16'\": LKRPBlockStream.fromHex(\n            \"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b\",\n          ),\n        }),\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      } 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 LKRPHttpRequestError(\n            `Failed to fetch ${baseUrl}/trustchain/TRUSTCHAIN_ID: [500] Internal Server Error`,\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": ["Just", "Left", "Nothing", "Right", "LKRPHttpRequestError", "LKRPUnauthorizedError", "LKRPBlock", "LKRPBlockStream", "HttpLKRPDataSource", "mockJwt", "mockChallengeJSON", "mockSignature", "fetchSpy", "baseUrl", "mockChallenge", "result", "error", "jwtWithoutTrustchainId", "mockTrustchain", "hex", "mockBlock"]
+  "sourcesContent": ["import { Just, Left, Nothing, Right } from \"purify-ts\";\n\nimport { LKRPDataSourceError } from \"@api/app-binder/Errors\";\nimport { LKRPBlock } from \"@internal/utils/LKRPBlock\";\nimport { LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\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 mockTrustchain = {\n        \"m/\": \"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d\",\n        \"m/16'\": \"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b\",\n      };\n      fetchSpy.mockResolvedValueOnce({\n        ok: true,\n        json: () => Promise.resolve(mockTrustchain),\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({\n          \"m/\": LKRPBlockStream.fromHex(\n            \"0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d\",\n          ),\n          \"m/16'\": LKRPBlockStream.fromHex(\n            \"1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b\",\n          ),\n        }),\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": ["Just", "Left", "Nothing", "Right", "LKRPDataSourceError", "LKRPBlock", "LKRPBlockStream", "HttpLKRPDataSource", "mockJwt", "mockChallengeJSON", "mockSignature", "fetchSpy", "baseUrl", "mockChallenge", "result", "error", "jwtWithoutTrustchainId", "mockTrustchain", "hex", "mockBlock"]
 }

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

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

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/esm/internal/{utils/TLVTags.js → models/Tags.js}

@@ -1,2 +1,2 @@
 var u=(x=>(x[x.Null=0]="Null",x[x.Int=1]="Int",x[x.Hash=2]="Hash",x[x.Signature=3]="Signature",x[x.String=4]="String",x[x.Bytes=5]="Bytes",x[x.PublicKey=6]="PublicKey",x))(u||{}),M=(E=>(E[E.Seed=16]="Seed",E[E.AddMember=17]="AddMember",E[E.PublishKey=18]="PublishKey",E[E.CloseStream=19]="CloseStream",E[E.EditMember=20]="EditMember",E[E.Derive=21]="Derive",E))(M||{});const t=128;var i=(x=>(x[x.IV=0]="IV",x[x.ISSUER=1|t]="ISSUER",x[x.XPRIV=2|t]="XPRIV",x[x.EPHEMERAL_PUBLIC_KEY=3]="EPHEMERAL_PUBLIC_KEY",x[x.COMMAND_IV=4]="COMMAND_IV",x[x.GROUPKEY=5]="GROUPKEY",x[x.NEW_MEMBER=6|t]="NEW_MEMBER",x))(i||{});export{M as CommandTags,u as GeneralTags,i as TPTags};
-//# sourceMappingURL=TLVTags.js.map
+//# sourceMappingURL=Tags.js.map

package/lib/esm/internal/{utils/TLVTags.js.map → models/Tags.js.map}

@@ -1,6 +1,6 @@
 {
   "version": 3,
-  "sources": ["../../../../src/internal/utils/TLVTags.ts"],
+  "sources": ["../../../../src/internal/models/Tags.ts"],
   "sourcesContent": ["export enum GeneralTags {\n  Null = 0x00,\n  Int = 0x01,\n  Hash = 0x02,\n  Signature = 0x03,\n  String = 0x04,\n  Bytes = 0x05,\n  PublicKey = 0x06,\n}\n\nexport enum CommandTags {\n  Seed = 0x10,\n  AddMember = 0x11,\n  PublishKey = 0x12,\n  CloseStream = 0x13,\n  EditMember = 0x14,\n  Derive = 0x15,\n}\n\nconst TP_ENCRYPT = 1 << 7;\n\nexport enum TPTags {\n  IV = 0x00,\n  ISSUER = 0x01 | TP_ENCRYPT,\n  XPRIV = 0x02 | TP_ENCRYPT,\n  EPHEMERAL_PUBLIC_KEY = 0x03,\n  COMMAND_IV = 0x04,\n  GROUPKEY = 0x05,\n  NEW_MEMBER = 0x06 | TP_ENCRYPT,\n}\n"],
   "mappings": "AAAO,IAAKA,OACVA,IAAA,KAAO,GAAP,OACAA,IAAA,IAAM,GAAN,MACAA,IAAA,KAAO,GAAP,OACAA,IAAA,UAAY,GAAZ,YACAA,IAAA,OAAS,GAAT,SACAA,IAAA,MAAQ,GAAR,QACAA,IAAA,UAAY,GAAZ,YAPUA,OAAA,IAUAC,OACVA,IAAA,KAAO,IAAP,OACAA,IAAA,UAAY,IAAZ,YACAA,IAAA,WAAa,IAAb,aACAA,IAAA,YAAc,IAAd,cACAA,IAAA,WAAa,IAAb,aACAA,IAAA,OAAS,IAAT,SANUA,OAAA,IASZ,MAAMC,EAAa,IAEZ,IAAKC,OACVA,IAAA,GAAK,GAAL,KACAA,IAAA,OAAS,EAAOD,GAAhB,SACAC,IAAA,MAAQ,EAAOD,GAAf,QACAC,IAAA,qBAAuB,GAAvB,uBACAA,IAAA,WAAa,GAAb,aACAA,IAAA,SAAW,GAAX,WACAA,IAAA,WAAa,EAAOD,GAApB,aAPUC,OAAA",
   "names": ["GeneralTags", "CommandTags", "TP_ENCRYPT", "TPTags"]

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/esm/internal/utils/LKRPBlock.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/utils/LKRPBlock.ts"],
-  "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\";\n\nimport { CryptoUtils } from \"./crypto\";\nimport { TLVBuilder } from \"./TLVBuilder\";\nimport { TLVParser } from \"./TLVParser\";\nimport { type LKRPBlockData, type LKRPBlockParsedData } from \"./types\";\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": "AAAA,OACE,sBAAAA,EACA,sBAAAC,MACK,kCACP,OAAS,UAAAC,EAAQ,QAAAC,EAAkB,WAAAC,EAAS,SAAAC,MAAa,YAIzD,OAAS,eAAAC,MAAmB,WAC5B,OAAS,cAAAC,MAAkB,eAC3B,OAAS,aAAAC,MAAiB,cAGnB,MAAMC,CAAU,CAId,YACYC,EACjBC,EACA,CAFiB,WAAAD,EAGjB,KAAK,KAAOC,EAAOR,EAAKE,EAAMM,CAAI,CAAC,EAAIP,CACzC,CARQ,UAA2BA,EAC3B,KASR,OAAO,QAAQQ,EAAwB,CACrC,OAAO,IAAIH,EAAUR,EAAmBW,CAAG,GAAK,IAAI,UAAY,CAClE,CAEA,OAAO,SAASD,EAAgC,CAC9C,MAAME,EAAU,IAAIN,EAAW,EAC5B,OAAO,EAAG,CAAC,EACX,QAAQN,EAAmBU,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,IAAID,EAAUC,EAAO,CAAE,GAAGC,EAAM,OAAAG,EAAQ,UAAAG,CAAU,CAAC,CAC5D,CAEA,UAAmB,CACjB,OAAOjB,EAAmB,KAAK,KAAK,EAAE,MAAM,CAAC,CAC/C,CAEA,OAAoB,CAClB,OAAO,KAAK,KACd,CAEA,OAAuD,CACrD,OAAO,KAAK,KAAK,cAAc,IAAM,CACnC,MAAMW,EAAO,IAAIH,EAAU,KAAK,KAAK,EAAE,eAAe,EACtD,YAAK,KAAOL,EAAKQ,CAAI,EACdA,CACT,CAAC,CACH,CAEA,SAA4C,CAC1C,OAAO,KAAK,MAAM,EACf,MAAOA,GACNT,EAAO,SAASS,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,WAAWX,EAAmBW,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,cAAcnB,EAAmBW,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,EAAYd,EAAY,KAAK,KAAK,KAAK,EAC7C,OAAON,EAAmBoB,CAAS,EAAE,MAAM,CAAC,CAC9C,CAAC,CACH,CACF",
+  "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": "AAAA,OACE,sBAAAA,EACA,sBAAAC,MACK,kCACP,OAAS,UAAAC,EAAQ,QAAAC,EAAkB,WAAAC,EAAS,SAAAC,MAAa,YAQzD,OAAS,eAAAC,MAAmB,WAC5B,OAAS,cAAAC,MAAkB,eAC3B,OAAS,aAAAC,MAAiB,cAEnB,MAAMC,CAAU,CAId,YACYC,EACjBC,EACA,CAFiB,WAAAD,EAGjB,KAAK,KAAOC,EAAOR,EAAKE,EAAMM,CAAI,CAAC,EAAIP,CACzC,CARQ,UAA2BA,EAC3B,KASR,OAAO,QAAQQ,EAAwB,CACrC,OAAO,IAAIH,EAAUR,EAAmBW,CAAG,GAAK,IAAI,UAAY,CAClE,CAEA,OAAO,SAASD,EAAgC,CAC9C,MAAME,EAAU,IAAIN,EAAW,EAC5B,OAAO,EAAG,CAAC,EACX,QAAQN,EAAmBU,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,IAAID,EAAUC,EAAO,CAAE,GAAGC,EAAM,OAAAG,EAAQ,UAAAG,CAAU,CAAC,CAC5D,CAEA,UAAmB,CACjB,OAAOjB,EAAmB,KAAK,KAAK,EAAE,MAAM,CAAC,CAC/C,CAEA,OAAoB,CAClB,OAAO,KAAK,KACd,CAEA,OAAuD,CACrD,OAAO,KAAK,KAAK,cAAc,IAAM,CACnC,MAAMW,EAAO,IAAIH,EAAU,KAAK,KAAK,EAAE,eAAe,EACtD,YAAK,KAAOL,EAAKQ,CAAI,EACdA,CACT,CAAC,CACH,CAEA,SAA4C,CAC1C,OAAO,KAAK,MAAM,EACf,MAAOA,GACNT,EAAO,SAASS,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,WAAWX,EAAmBW,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,cAAcnB,EAAmBW,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,EAAYd,EAAY,KAAK,KAAK,KAAK,EAC7C,OAAON,EAAmBoB,CAAS,EAAE,MAAM,CAAC,CAC9C,CAAC,CACH,CACF",
   "names": ["bufferToHexaString", "hexaStringToBuffer", "Either", "Just", "Nothing", "Right", "CryptoUtils", "TLVBuilder", "TLVParser", "LKRPBlock", "bytes", "data", "hex", "builder", "header", "cmd", "sigStart", "signature", "commands", "l", "hashValue"]
 }

package/lib/esm/internal/utils/LKRPBlock.test.js

@@ -1,4 +1,4 @@
-import{Left as n,Right as b}from"purify-ts";import{LKRPParsingError as s}from"../../api/app-binder/Errors";import{hexToBytes as l}from"./hex";import{LKRPBlock as d}from"./LKRPBlock";import{LKRPCommand as t}from"./LKRPCommand";import{GeneralTags as m}from"./TLVTags";const f={parent:"0000",issuer:new Uint8Array([1,2,3]),commands:[t.fromHex("10020102"),t.fromHex("11020304")],signature:new Uint8Array([4,5,6])},r=["010101","02020000","0603010203","010102"].join(""),a=[...r,"10020102","11020304","0303040506"].join(""),o={...f,header:l(r),signature:Uint8Array.from([m.Signature,3,...f.signature])};describe("LKRPBlock",()=>{describe("fromData",()=>{it("should create a Block from data",()=>{const e=d.fromData(f);expect(e.parse()).toStrictEqual(b(o)),expect(e.toString()).toBe(a)})}),describe("toString",()=>{it("should return the hex representation of the block",()=>{const e=d.fromHex(a);expect(e.toString()).toBe(a)})}),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(e);expect(c.toU8A()).toBe(e)})}),describe("parse",()=>{it("should parse the block data correctly",()=>{const c=d.fromHex(a).parse();expect(c).toStrictEqual(b(o))}),it("should fail if the block data is invalid",()=>{const e=d.fromHex("invalid");expect(e.parse()).toStrictEqual(n(new s("Unexpected end of TLV")))})}),describe("toHuman",()=>{it("should return a human-readable representation of the block",()=>{const e=`
+import{Left as n,Right as b}from"purify-ts";import{LKRPParsingError as s}from"../../api/app-binder/Errors";import{GeneralTags as l}from"../models/Tags";import{hexToBytes as m}from"./hex";import{LKRPBlock as d}from"./LKRPBlock";import{LKRPCommand as t}from"./LKRPCommand";const f={parent:"0000",issuer:new Uint8Array([1,2,3]),commands:[t.fromHex("10020102"),t.fromHex("11020304")],signature:new Uint8Array([4,5,6])},r=["010101","02020000","0603010203","010102"].join(""),a=[...r,"10020102","11020304","0303040506"].join(""),o={...f,header:m(r),signature:Uint8Array.from([l.Signature,3,...f.signature])};describe("LKRPBlock",()=>{describe("fromData",()=>{it("should create a Block from data",()=>{const e=d.fromData(f);expect(e.parse()).toStrictEqual(b(o)),expect(e.toString()).toBe(a)})}),describe("toString",()=>{it("should return the hex representation of the block",()=>{const e=d.fromHex(a);expect(e.toString()).toBe(a)})}),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(e);expect(c.toU8A()).toBe(e)})}),describe("parse",()=>{it("should parse the block data correctly",()=>{const c=d.fromHex(a).parse();expect(c).toStrictEqual(b(o))}),it("should fail if the block data is invalid",()=>{const e=d.fromHex("invalid");expect(e.parse()).toStrictEqual(n(new s("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

package/lib/esm/internal/utils/LKRPBlock.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/utils/LKRPBlock.test.ts"],
-  "sourcesContent": ["import { Left, Right } from \"purify-ts\";\n\nimport { LKRPParsingError } from \"@api/app-binder/Errors\";\n\nimport { hexToBytes } from \"./hex\";\nimport { LKRPBlock } from \"./LKRPBlock\";\nimport { LKRPCommand } from \"./LKRPCommand\";\nimport { GeneralTags } from \"./TLVTags\";\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,OAAS,QAAAA,EAAM,SAAAC,MAAa,YAE5B,OAAS,oBAAAC,MAAwB,yBAEjC,OAAS,cAAAC,MAAkB,QAC3B,OAAS,aAAAC,MAAiB,cAC1B,OAAS,eAAAC,MAAmB,gBAC5B,OAAS,eAAAC,MAAmB,YAG5B,MAAMC,EAAkB,CACtB,OAAQ,OACR,OAAQ,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,EAChC,SAAU,CAACF,EAAY,QAAQ,UAAU,EAAGA,EAAY,QAAQ,UAAU,CAAC,EAC3E,UAAW,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,CACrC,EACMG,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,OAAQJ,EAAWK,CAAe,EAClC,UAAW,WAAW,KAAK,CACzBF,EAAY,UACZ,EACA,GAAGC,EAAgB,SACrB,CAAC,CACH,EAEA,SAAS,YAAa,IAAM,CAC1B,SAAS,WAAY,IAAM,CACzB,GAAG,kCAAmC,IAAM,CAE1C,MAAMI,EAAQP,EAAU,SAASG,CAAe,EAEhD,OAAOI,EAAM,MAAM,CAAC,EAAE,cAAcV,EAAMS,CAAqB,CAAC,EAChE,OAAOC,EAAM,SAAS,CAAC,EAAE,KAAKF,CAAc,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,WAAY,IAAM,CACzB,GAAG,oDAAqD,IAAM,CAE5D,MAAME,EAAQP,EAAU,QAAQK,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,IAAIP,EAAUQ,CAAK,EAEjC,OAAOD,EAAM,MAAM,CAAC,EAAE,KAAKC,CAAK,CAClC,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,wCAAyC,IAAM,CAIhD,MAAMC,EAFQT,EAAU,QAAQK,CAAc,EAErB,MAAM,EAE/B,OAAOI,CAAU,EAAE,cAAcZ,EAAMS,CAAqB,CAAC,CAC/D,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMI,EAAeV,EAAU,QAAQ,SAAS,EAEhD,OAAOU,EAAa,MAAM,CAAC,EAAE,cAC3Bd,EAAK,IAAIE,EAAiB,uBAAuB,CAAC,CACpD,CACF,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6DAA8D,IAAM,CAErE,MAAMa,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,EADQZ,EAAU,QAAQW,CAAG,EACP,QAAQ,EAGpC,OAAOC,CAAa,EAAE,cACpBf,EACE,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,MAAMgB,EAFQb,EAAU,QAAQK,CAAc,EAE3B,KAAK,EAExB,OAAOQ,CAAI,EAAE,KACX,kEACF,CACF,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["Left", "Right", "LKRPParsingError", "hexToBytes", "LKRPBlock", "LKRPCommand", "GeneralTags", "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,OAAS,QAAAA,EAAM,SAAAC,MAAa,YAE5B,OAAS,oBAAAC,MAAwB,yBACjC,OAAS,eAAAC,MAAmB,wBAE5B,OAAS,cAAAC,MAAkB,QAC3B,OAAS,aAAAC,MAAiB,cAC1B,OAAS,eAAAC,MAAmB,gBAG5B,MAAMC,EAAkB,CACtB,OAAQ,OACR,OAAQ,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,EAChC,SAAU,CAACD,EAAY,QAAQ,UAAU,EAAGA,EAAY,QAAQ,UAAU,CAAC,EAC3E,UAAW,IAAI,WAAW,CAAC,EAAG,EAAG,CAAC,CAAC,CACrC,EACME,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,OAAQH,EAAWI,CAAe,EAClC,UAAW,WAAW,KAAK,CACzBL,EAAY,UACZ,EACA,GAAGI,EAAgB,SACrB,CAAC,CACH,EAEA,SAAS,YAAa,IAAM,CAC1B,SAAS,WAAY,IAAM,CACzB,GAAG,kCAAmC,IAAM,CAE1C,MAAMI,EAAQN,EAAU,SAASE,CAAe,EAEhD,OAAOI,EAAM,MAAM,CAAC,EAAE,cAAcV,EAAMS,CAAqB,CAAC,EAChE,OAAOC,EAAM,SAAS,CAAC,EAAE,KAAKF,CAAc,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,WAAY,IAAM,CACzB,GAAG,oDAAqD,IAAM,CAE5D,MAAME,EAAQN,EAAU,QAAQI,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,IAAIN,EAAUO,CAAK,EAEjC,OAAOD,EAAM,MAAM,CAAC,EAAE,KAAKC,CAAK,CAClC,CAAC,CACH,CAAC,EAED,SAAS,QAAS,IAAM,CACtB,GAAG,wCAAyC,IAAM,CAIhD,MAAMC,EAFQR,EAAU,QAAQI,CAAc,EAErB,MAAM,EAE/B,OAAOI,CAAU,EAAE,cAAcZ,EAAMS,CAAqB,CAAC,CAC/D,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMI,EAAeT,EAAU,QAAQ,SAAS,EAEhD,OAAOS,EAAa,MAAM,CAAC,EAAE,cAC3Bd,EAAK,IAAIE,EAAiB,uBAAuB,CAAC,CACpD,CACF,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6DAA8D,IAAM,CAErE,MAAMa,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,EADQX,EAAU,QAAQU,CAAG,EACP,QAAQ,EAGpC,OAAOC,CAAa,EAAE,cACpBf,EACE,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,MAAMgB,EAFQZ,EAAU,QAAQI,CAAc,EAE3B,KAAK,EAExB,OAAOQ,CAAI,EAAE,KACX,kEACF,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["Left", "Right", "LKRPParsingError", "GeneralTags", "hexToBytes", "LKRPBlock", "LKRPCommand", "mockedBlockData", "mockedHeaderHex", "mockedBlockHex", "parsedMockedBlockData", "block", "bytes", "parsedData", "invalidBlock", "hex", "humanReadable", "hash"]
 }

package/lib/esm/internal/utils/LKRPBlockStream.js

@@ -1,4 +1,4 @@
-import{Either as l,Just as c,Maybe as p,Nothing as i,Right as f}from"purify-ts";import{CryptoUtils as b}from"../utils/crypto";import{bytesToHex as m,hexToBytes as P}from"./hex";import{LKRPBlock as y}from"./LKRPBlock";import{TLVParser as g}from"./TLVParser";import{CommandTags as u}from"./TLVTags";class h{constructor(t,r,e){this.bytes=t;this.blocks=r?c(f(r)):i,this.path=p.fromNullable(e)}validation=i;blocks=i;path=i;static fromHex(t){return new h(P(t))}static fromPath(t){return new h(new Uint8Array,[],t)}static async fromData(t,r){const e=[];let a=r??m(crypto.getRandomValues(new Uint8Array(32)));for(const s of t){const n=y.fromData({...s,parent:a});a=n.hash(),e.push(n)}const o=e.reduce((s,n)=>new Uint8Array([...s,...n.toU8A()]),new Uint8Array);return new h(o,e)}toU8A(){return this.bytes}toString(){return m(this.bytes)}parse(){return this.blocks.orDefaultLazy(()=>{const t=new g(this.bytes),r=[];for(;!t.state.isDone;){const a=t.state.offset,o=t.parseBlockData().map(s=>{const n=t.state.offset;return new y(this.bytes.slice(a,n),s)});if(r.push(o),o.isLeft())break}const e=l.sequence(r);return this.blocks=c(e),e})}toHuman(){return this.parse().map(t=>t.map(r=>r.toHuman())).chain(l.sequence).map(t=>t.join(`
+import{Either as l,Just as c,Maybe as p,Nothing as i,Right as f}from"purify-ts";import{CommandTags as m}from"../models/Tags";import{CryptoUtils as b}from"../utils/crypto";import{bytesToHex as y,hexToBytes as P}from"./hex";import{LKRPBlock as u}from"./LKRPBlock";import{TLVParser as g}from"./TLVParser";class h{constructor(t,r,e){this.bytes=t;this.blocks=r?c(f(r)):i,this.path=p.fromNullable(e)}validation=i;blocks=i;path=i;static fromHex(t){return new h(P(t))}static fromPath(t){return new h(new Uint8Array,[],t)}static fromData(t,r){const e=[];let a=r??y(crypto.getRandomValues(new Uint8Array(32)));for(const s of t){const n=u.fromData({...s,parent:a});a=n.hash(),e.push(n)}const o=e.reduce((s,n)=>new Uint8Array([...s,...n.toU8A()]),new Uint8Array);return new h(o,e)}toU8A(){return this.bytes}toString(){return y(this.bytes)}parse(){return this.blocks.orDefaultLazy(()=>{const t=new g(this.bytes),r=[];for(;!t.state.isDone;){const a=t.state.offset,o=t.parseBlockData().map(s=>{const n=t.state.offset;return new u(this.bytes.slice(a,n),s)});if(r.push(o),o.isLeft())break}const e=l.sequence(r);return this.blocks=c(e),e})}toHuman(){return this.parse().map(t=>t.map(r=>r.toHuman())).chain(l.sequence).map(t=>t.join(`
 
-`))}async validate(t){return this.validation.orDefaultLazy(async()=>this.parse().map(e=>e.map(a=>a.parse().map(({parent:o})=>({parent:o,hash:()=>a.hash()})))).chain(l.sequence).toMaybe().map(async e=>{if(t&&e[0]&&t!==e[0].parent)return!1;for await(const[a,o]of e.entries()){const s=e[a+1];if(s&&o.hash()!==s.parent)return!1}return!0}).orDefault(Promise.resolve(!1)))}getPath(){return this.path.ifNothing(()=>{this.path=this.parse().toMaybe().chain(t=>p.fromNullable(t[0])).chain(t=>t.parse().toMaybe()).chain(({commands:t})=>p.fromNullable(t[0])).chain(t=>t.parse().toMaybe()).chain(t=>{switch(t.type){case u.Derive:return c(t.path);case u.Seed:return c("m/0'");default:return i}})}),this.path}getMemberBlock(t){return this.parse().toMaybe().chain(r=>{for(const e of r){const a=e.parse();if(a.isRight()){const o=a.extract();for(const s of o.commands){const n=s.getPublicKey();if(n.isJust()&&n.extract()===t)return p.of(o)}}}return i})}hasMember(t){return this.getMemberBlock(t).isJust()}getPublishedKey(t){return this.getMemberBlock(t.pubKeyToHex()).chain(r=>{for(const e of r.commands){const a=e.getEncryptedPublichedKey();if(a.isJust())return a}return i}).map(r=>{const e=t.ecdh(r.ephemeralPublicKey).slice(1),a=b.decrypt(e,r.initializationVector,r.encryptedXpriv);return{privateKey:a.slice(0,32),chainCode:a.slice(32)}})}}export{h as LKRPBlockStream};
+`))}async validate(t){return this.validation.orDefaultLazy(async()=>this.parse().map(e=>e.map(a=>a.parse().map(({parent:o})=>({parent:o,hash:()=>a.hash()})))).chain(l.sequence).toMaybe().map(async e=>{if(t&&e[0]&&t!==e[0].parent)return!1;for await(const[a,o]of e.entries()){const s=e[a+1];if(s&&o.hash()!==s.parent)return!1}return!0}).orDefault(Promise.resolve(!1)))}getPath(){return this.path.ifNothing(()=>{this.path=this.parse().toMaybe().chain(t=>p.fromNullable(t[0])).chain(t=>t.parse().toMaybe()).chain(({commands:t})=>p.fromNullable(t[0])).chain(t=>t.parse().toMaybe()).chain(t=>{switch(t.type){case m.Derive:return c(t.path);case m.Seed:return c("m/0'");default:return i}})}),this.path}getMemberBlock(t){return this.parse().toMaybe().chain(r=>{for(const e of r){const a=e.parse();if(a.isRight()){const o=a.extract();for(const s of o.commands){const n=s.getPublicKey();if(n.isJust()&&n.extract()===t)return p.of(o)}}}return i})}hasMember(t){return this.getMemberBlock(t).isJust()}getPublishedKey(t){return this.getMemberBlock(t.pubKeyToHex()).chain(r=>{for(const e of r.commands){const a=e.getEncryptedPublishedKey();if(a.isJust())return a}return i}).map(r=>{const e=t.ecdh(r.ephemeralPublicKey).slice(1),a=b.decrypt(e,r.initializationVector,r.encryptedXpriv);return{privateKey:a.slice(0,32),chainCode:a.slice(32)}})}}export{h as LKRPBlockStream};
 //# sourceMappingURL=LKRPBlockStream.js.map