@ledgerhq/device-trusted-app-kit-ledger-keyring-protocol 0.0.0-rn-ble-pairing-removed-while-reconnecting-20250807094338 → 0.0.0-transaction-unfunded-20250917151052

package/lib/cjs/api/LedgerKeyringProtocol.js

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

package/lib/cjs/api/LedgerKeyringProtocol.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/LedgerKeyringProtocol.ts"],
-  "sourcesContent": ["import { type Maybe } from \"purify-ts\";\n\nimport { type AuthenticateDAReturnType } from \"./app-binder/AuthenticateDeviceActionTypes\";\nimport {\n  type JWT,\n  type Keypair,\n  type Permissions,\n} from \"./app-binder/LKRPTypes\";\n\nexport interface LedgerKeyringProtocol {\n  authenticate: (\n    keypair: Keypair,\n    applicationId: number,\n    clientName: string,\n    permissions: Permissions,\n    trustchainId?: string,\n    JWT?: JWT,\n  ) => AuthenticateDAReturnType;\n\n  encryptData: (xpriv: Uint8Array, data: Uint8Array) => Uint8Array;\n\n  decryptData: (xpriv: Uint8Array, data: Uint8Array) => Maybe<Uint8Array>;\n}\n"],
+  "sourcesContent": ["import { type AuthenticateUsecaseInput } from \"@internal/use-cases/authentication/AuthenticateUseCase\";\n\nimport { type AuthenticateDAReturnType } from \"./app-binder/AuthenticateDeviceActionTypes\";\n\nexport interface LedgerKeyringProtocol {\n  authenticate: (input: AuthenticateUsecaseInput) => AuthenticateDAReturnType;\n\n  encryptData: (\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ) => Promise<Uint8Array>;\n\n  decryptData: (\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ) => Promise<Uint8Array>;\n}\n"],
   "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
   "names": ["LedgerKeyringProtocol_exports", "__toCommonJS"]
 }

package/lib/cjs/api/LedgerKeyringProtocolBuilder.js

@@ -1,2 +1,2 @@
-"use strict";var t=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var a=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var m=(i,e)=>{for(var r in e)t(i,r,{get:e[r],enumerable:!0})},c=(i,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of a(e))!l.call(i,s)&&s!==r&&t(i,s,{get:()=>e[s],enumerable:!(o=d(e,s))||o.enumerable});return i};var g=i=>c(t({},"__esModule",{value:!0}),i);var y={};m(y,{LedgerKeyringProtocolBuilder:()=>p});module.exports=g(y);var n=require("../internal/DefaultLedgerKeyringProtocol");class p{dmk;sessionId;baseUrl;constructor({dmk:e,sessionId:r,baseUrl:o}){this.dmk=e,this.sessionId=r,this.baseUrl=o}build(){return new n.DefaultLedgerKeyringProtocol({dmk:this.dmk,sessionId:this.sessionId,baseUrl:this.baseUrl})}}0&&(module.exports={LedgerKeyringProtocolBuilder});
+"use strict";var o=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var v=Object.prototype.hasOwnProperty;var d=(r,e)=>{for(var i in e)o(r,i,{get:e[i],enumerable:!0})},m=(r,e,i,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of l(e))!v.call(r,t)&&t!==i&&o(r,t,{get:()=>e[t],enumerable:!(n=c(e,t))||n.enumerable});return r};var y=r=>m(o({},"__esModule",{value:!0}),r);var g={};d(g,{LedgerKeyringProtocolBuilder:()=>s});module.exports=y(g);var p=require("./crypto/noble/NobleCryptoService"),a=require("../internal/DefaultLedgerKeyringProtocol");class s{dmk;applicationId;env;baseUrl;cryptoService=new p.NobleCryptoService;constructor(e){this.dmk=e.dmk,this.applicationId=e.applicationId,this.env=e.env,this.baseUrl=e.baseUrl}withCryptoService(e){return this.cryptoService=e,this}build(){return new a.DefaultLedgerKeyringProtocol({dmk:this.dmk,applicationId:this.applicationId,cryptoService:this.cryptoService,env:this.env,baseUrl:this.baseUrl})}}0&&(module.exports={LedgerKeyringProtocolBuilder});
 //# sourceMappingURL=LedgerKeyringProtocolBuilder.js.map

package/lib/cjs/api/LedgerKeyringProtocolBuilder.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/LedgerKeyringProtocolBuilder.ts"],
-  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type LedgerKeyringProtocol } from \"@api/LedgerKeyringProtocol\";\nimport { DefaultLedgerKeyringProtocol } from \"@internal/DefaultLedgerKeyringProtocol\";\n\nexport class LedgerKeyringProtocolBuilder {\n  private readonly dmk: DeviceManagementKit;\n  private readonly sessionId: DeviceSessionId;\n  private readonly baseUrl: string;\n\n  constructor({\n    dmk,\n    sessionId,\n    baseUrl,\n  }: {\n    dmk: DeviceManagementKit;\n    sessionId: DeviceSessionId;\n    baseUrl: string;\n  }) {\n    this.dmk = dmk;\n    this.sessionId = sessionId;\n    this.baseUrl = baseUrl;\n  }\n\n  build(): LedgerKeyringProtocol {\n    return new DefaultLedgerKeyringProtocol({\n      dmk: this.dmk,\n      sessionId: this.sessionId,\n      baseUrl: this.baseUrl,\n    });\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kCAAAE,IAAA,eAAAC,EAAAH,GAMA,IAAAI,EAA6C,kDAEtC,MAAMF,CAA6B,CACvB,IACA,UACA,QAEjB,YAAY,CACV,IAAAG,EACA,UAAAC,EACA,QAAAC,CACF,EAIG,CACD,KAAK,IAAMF,EACX,KAAK,UAAYC,EACjB,KAAK,QAAUC,CACjB,CAEA,OAA+B,CAC7B,OAAO,IAAI,+BAA6B,CACtC,IAAK,KAAK,IACV,UAAW,KAAK,UAChB,QAAS,KAAK,OAChB,CAAC,CACH,CACF",
-  "names": ["LedgerKeyringProtocolBuilder_exports", "__export", "LedgerKeyringProtocolBuilder", "__toCommonJS", "import_DefaultLedgerKeyringProtocol", "dmk", "sessionId", "baseUrl"]
+  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { NobleCryptoService } from \"@api/crypto/noble/NobleCryptoService\";\nimport { type LedgerKeyringProtocol } from \"@api/LedgerKeyringProtocol\";\nimport { type LKRPEnv } from \"@api/model/Env\";\nimport { DefaultLedgerKeyringProtocol } from \"@internal/DefaultLedgerKeyringProtocol\";\n\nexport class LedgerKeyringProtocolBuilder {\n  private readonly dmk: DeviceManagementKit;\n  private readonly applicationId: number;\n  private readonly env?: LKRPEnv;\n  private readonly baseUrl?: string;\n  private cryptoService: CryptoService = new NobleCryptoService();\n\n  constructor(args: {\n    dmk: DeviceManagementKit;\n    applicationId: number;\n    env?: LKRPEnv;\n    baseUrl?: string;\n  }) {\n    this.dmk = args.dmk;\n    this.applicationId = args.applicationId;\n    this.env = args.env;\n    this.baseUrl = args.baseUrl;\n  }\n\n  withCryptoService(service: CryptoService): LedgerKeyringProtocolBuilder {\n    this.cryptoService = service;\n    return this;\n  }\n\n  build(): LedgerKeyringProtocol {\n    return new DefaultLedgerKeyringProtocol({\n      dmk: this.dmk,\n      applicationId: this.applicationId,\n      cryptoService: this.cryptoService,\n      env: this.env,\n      baseUrl: this.baseUrl,\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kCAAAE,IAAA,eAAAC,EAAAH,GAGA,IAAAI,EAAmC,gDAGnCC,EAA6C,kDAEtC,MAAMH,CAA6B,CACvB,IACA,cACA,IACA,QACT,cAA+B,IAAI,qBAE3C,YAAYI,EAKT,CACD,KAAK,IAAMA,EAAK,IAChB,KAAK,cAAgBA,EAAK,cAC1B,KAAK,IAAMA,EAAK,IAChB,KAAK,QAAUA,EAAK,OACtB,CAEA,kBAAkBC,EAAsD,CACtE,YAAK,cAAgBA,EACd,IACT,CAEA,OAA+B,CAC7B,OAAO,IAAI,+BAA6B,CACtC,IAAK,KAAK,IACV,cAAe,KAAK,cACpB,cAAe,KAAK,cACpB,IAAK,KAAK,IACV,QAAS,KAAK,OAChB,CAAC,CACH,CACF",
+  "names": ["LedgerKeyringProtocolBuilder_exports", "__export", "LedgerKeyringProtocolBuilder", "__toCommonJS", "import_NobleCryptoService", "import_DefaultLedgerKeyringProtocol", "args", "service"]
 }

package/lib/cjs/api/app-binder/AddToTrustchainDeviceActionTypes.js

@@ -1,2 +1,2 @@
-"use strict";var i=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var y=(t,r,n,o)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of p(r))!s.call(t,e)&&e!==n&&i(t,e,{get:()=>r[e],enumerable:!(o=a(r,e))||o.enumerable});return t};var d=t=>y(i({},"__esModule",{value:!0}),t);var m={};module.exports=d(m);
+"use strict";var i=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var y=(e,r)=>{for(var a in r)i(e,a,{get:r[a],enumerable:!0})},u=(e,r,a,t)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of s(r))!m.call(e,o)&&o!==a&&i(e,o,{get:()=>r[o],enumerable:!(t=d(r,o))||t.enumerable});return e};var c=e=>u(i({},"__esModule",{value:!0}),e);var P={};y(P,{AddToTrustchainDAState:()=>n,AddToTrustchaineDAStep:()=>p});module.exports=c(P);var n=(r=>(r.AddMember="lkrp-add-member",r))(n||{}),p=(t=>(t.Initialize="lkrp-init-transaction",t.ParseStream="lkrp-parse-stream",t.AddMember="lkrp-add-member",t))(p||{});0&&(module.exports={AddToTrustchainDAState,AddToTrustchaineDAStep});
 //# sourceMappingURL=AddToTrustchainDeviceActionTypes.js.map

package/lib/cjs/api/app-binder/AddToTrustchainDeviceActionTypes.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/api/app-binder/AddToTrustchainDeviceActionTypes.ts"],
-  "sourcesContent": ["import {\n  type OpenAppDAError,\n  type UnknownDAError,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either } from \"purify-ts\";\n\nimport { type LKRPDeviceCommandError } from \"@internal/app-binder/command/utils/ledgerKeyringProtocolErrors\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { type LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\nimport { type Trustchain } from \"@internal/utils/types\";\n\nimport {\n  type LKRPHttpRequestError,\n  type LKRPMissingDataError,\n  type LKRPParsingError,\n} from \"./Errors\";\nimport { type JWT, type Keypair, type Permissions } from \"./LKRPTypes\";\n\nexport type AddToTrustchainDAOutput = undefined;\n\nexport type AddToTrustchainDAInput = Either<\n  LKRPMissingDataError,\n  {\n    readonly lkrpDataSource: LKRPDataSource;\n    readonly keypair: Keypair;\n    readonly jwt: JWT;\n    readonly trustchainId: string;\n    readonly trustchain: Trustchain;\n    readonly applicationStream: LKRPBlockStream;\n    readonly clientName: string;\n    readonly permissions: Permissions;\n  }\n>;\n\nexport type AddToTrustchainDAError =\n  | LKRPDeviceCommandError\n  | LKRPHttpRequestError\n  | LKRPParsingError\n  | LKRPMissingDataError\n  | OpenAppDAError\n  | UnknownDAError;\n\nexport type AddToTrustchainDAIntermediateValue = {\n  readonly requiredUserInteraction: string;\n};\n\nexport type AddToTrustchainDAInternalState = Either<\n  AddToTrustchainDAError,\n  {\n    readonly sessionKeypair: Keypair | null;\n  }\n>;\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["AddToTrustchainDeviceActionTypes_exports", "__toCommonJS"]
+  "sourcesContent": ["import {\n  type OpenAppDAError,\n  type UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either } from \"purify-ts\";\n\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type KeyPair } from \"@api/crypto/KeyPair\";\nimport {\n  type LKRPDataSourceError,\n  type LKRPMissingDataError,\n  type LKRPOutdatedTrustchainError,\n  type LKRPParsingError,\n  type LKRPTrustchainNotReady,\n  type LKRPUnknownError,\n} from \"@api/model/Errors\";\nimport { type JWT } from \"@api/model/JWT\";\nimport { type Permissions } from \"@api/model/Permissions\";\nimport { type LKRPDeviceCommandError } from \"@internal/app-binder/command/utils/ledgerKeyringProtocolErrors\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { type Trustchain } from \"@internal/utils/Trustchain\";\n\nexport type AddToTrustchainDAOutput = undefined;\n\nexport type AddToTrustchainDAInput = Either<\n  LKRPMissingDataError,\n  {\n    readonly lkrpDataSource: LKRPDataSource;\n    readonly cryptoService: CryptoService;\n    readonly keypair: KeyPair;\n    readonly jwt: JWT;\n    readonly appId: number;\n    readonly trustchain: Trustchain;\n    readonly clientName: string;\n    readonly permissions: Permissions;\n  }\n>;\n\nexport type AddToTrustchainDAError =\n  | LKRPDeviceCommandError\n  | LKRPDataSourceError\n  | LKRPParsingError\n  | LKRPMissingDataError\n  | LKRPOutdatedTrustchainError\n  | LKRPTrustchainNotReady\n  | OpenAppDAError\n  | LKRPUnknownError;\n\nexport type AddToTrustchainDAIntermediateValue =\n  | {\n      requiredUserInteraction: UserInteractionRequired.None;\n      step?:\n        | AddToTrustchaineDAStep.Initialize\n        | AddToTrustchaineDAStep.ParseStream;\n    }\n  | {\n      requiredUserInteraction: AddToTrustchainDAState.AddMember;\n      step: AddToTrustchaineDAStep.AddMember;\n    };\n\nexport enum AddToTrustchainDAState {\n  AddMember = \"lkrp-add-member\",\n}\n\nexport enum AddToTrustchaineDAStep {\n  Initialize = \"lkrp-init-transaction\",\n  ParseStream = \"lkrp-parse-stream\",\n  AddMember = \"lkrp-add-member\",\n}\n\nexport type AddToTrustchainDAInternalState = Either<\n  AddToTrustchainDAError,\n  {\n    readonly sessionKeypair: KeyPair | null;\n  }\n>;\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,EAAA,2BAAAC,IAAA,eAAAC,EAAAJ,GA4DO,IAAKE,OACVA,EAAA,UAAY,kBADFA,OAAA,IAIAC,OACVA,EAAA,WAAa,wBACbA,EAAA,YAAc,oBACdA,EAAA,UAAY,kBAHFA,OAAA",
+  "names": ["AddToTrustchainDeviceActionTypes_exports", "__export", "AddToTrustchainDAState", "AddToTrustchaineDAStep", "__toCommonJS"]
 }

package/lib/cjs/api/app-binder/AuthenticateDeviceActionTypes.js

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var l=Object.prototype.hasOwnProperty;var y=(r,t,o,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of p(t))!l.call(r,e)&&e!==o&&a(r,e,{get:()=>t[e],enumerable:!(n=i(t,e))||n.enumerable});return r};var u=r=>y(a({},"__esModule",{value:!0}),r);var c={};module.exports=u(c);
+"use strict";var p=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var y=(r,t)=>{for(var n in t)p(r,n,{get:t[n],enumerable:!0})},s=(r,t,n,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of c(t))!A.call(r,e)&&e!==n&&p(r,e,{get:()=>t[e],enumerable:!(i=u(t,e))||i.enumerable});return r};var d=r=>s(p({},"__esModule",{value:!0}),r);var h={};y(h,{AuthenticateDAState:()=>a,AuthenticateDAStep:()=>o});module.exports=d(h);var a=(t=>(t.Authenticate="lkrp-authenticate",t))(a||{}),o=(e=>(e.OpenApp="lkrp.steps.openApp",e.Authenticate="lkrp.steps.authenticate",e.GetTrustchain="lkrp.steps.getTrustchain",e.ExtractEncryptionKey="lkrp.steps.extractEncryptionKey",e))(o||{});0&&(module.exports={AuthenticateDAState,AuthenticateDAStep});
 //# sourceMappingURL=AuthenticateDeviceActionTypes.js.map

package/lib/cjs/api/app-binder/AuthenticateDeviceActionTypes.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/api/app-binder/AuthenticateDeviceActionTypes.ts"],
-  "sourcesContent": ["import {\n  type ExecuteDeviceActionReturnType,\n  type OpenAppDAError,\n  type UnknownDAError,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Either } from \"purify-ts\";\n\nimport { type LKRPDeviceCommandError } from \"@internal/app-binder/command/utils/ledgerKeyringProtocolErrors\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { type LKRPBlockStream } from \"@internal/utils/LKRPBlockStream\";\nimport { type Trustchain } from \"@internal/utils/types\";\n\nimport {\n  type LKRPHttpRequestError,\n  type LKRPMissingDataError,\n  type LKRPParsingError,\n  type LKRPUnhandledState,\n} from \"./Errors\";\nimport { type JWT, type Keypair, type Permissions } from \"./LKRPTypes\";\n\nexport type AuthenticateDAReturnType = ExecuteDeviceActionReturnType<\n  AuthenticateDAOutput,\n  AuthenticateDAError,\n  AuthenticateDAIntermediateValue\n>;\n\nexport type AuthenticateDAInput = {\n  readonly lkrpDataSource: LKRPDataSource;\n  readonly applicationId: number;\n  readonly keypair: Keypair;\n  readonly clientName: string;\n  readonly permissions: Permissions;\n  readonly trustchainId: string | null;\n  readonly jwt: JWT | null;\n};\n\nexport type AuthenticateDAOutput = {\n  readonly jwt: JWT | null;\n  readonly trustchainId: string | null;\n  readonly applicationPath: string | null;\n  readonly encryptionKey: Uint8Array | null;\n};\n\nexport type AuthenticateDAError =\n  | LKRPDeviceCommandError\n  | LKRPHttpRequestError\n  | LKRPParsingError\n  | LKRPMissingDataError\n  | LKRPUnhandledState\n  | OpenAppDAError\n  | UnknownDAError;\n\nexport type AuthenticateDAIntermediateValue = {\n  readonly requiredUserInteraction: string;\n};\n\nexport type AuthenticateDAInternalState = Either<\n  AuthenticateDAError,\n  {\n    readonly trustchainId: string | null;\n    readonly jwt: JWT | null;\n    readonly trustchain: Trustchain | null;\n    readonly applicationStream: LKRPBlockStream | null;\n    readonly encryptionKey: Uint8Array | null;\n    readonly wasAddedToTrustchain: boolean;\n  }\n>;\n"],
-  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["AuthenticateDeviceActionTypes_exports", "__toCommonJS"]
+  "sourcesContent": ["import {\n  type ExecuteDeviceActionReturnType,\n  type OpenAppDAError,\n  type OpenAppDARequiredInteraction,\n  type UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  type LKRPDataSourceError,\n  type LKRPMissingDataError,\n  type LKRPParsingError,\n  type LKRPTrustchainNotReady,\n  type LKRPUnauthorizedError,\n  type LKRPUnknownError,\n} from \"@api/model/Errors\";\nimport { type JWT } from \"@api/model/JWT\";\nimport { type LKRPDeviceCommandError } from \"@internal/app-binder/command/utils/ledgerKeyringProtocolErrors\";\n\nimport {\n  type AddToTrustchainDAError,\n  type AddToTrustchainDAIntermediateValue,\n} from \"./AddToTrustchainDeviceActionTypes\";\n\nexport type AuthenticateDAReturnType = ExecuteDeviceActionReturnType<\n  AuthenticateDAOutput,\n  AuthenticateDAError,\n  AuthenticateDAIntermediateValue\n>;\n\nexport type AuthenticateDAOutput = {\n  readonly jwt: JWT;\n  readonly trustchainId: string;\n  readonly applicationPath: string;\n  readonly encryptionKey: Uint8Array;\n};\n\nexport type AuthenticateDAError =\n  | LKRPUnauthorizedError\n  | AddToTrustchainDAError\n  | LKRPDeviceCommandError\n  | LKRPDataSourceError\n  | LKRPParsingError\n  | LKRPMissingDataError\n  | LKRPTrustchainNotReady\n  | OpenAppDAError\n  | LKRPUnknownError;\n\nexport type AuthenticateDAIntermediateValue =\n  | {\n      requiredUserInteraction: OpenAppDARequiredInteraction;\n      step: AuthenticateDAStep.OpenApp;\n    }\n  | {\n      requiredUserInteraction: AuthenticateDAState.Authenticate;\n      step: AuthenticateDAStep.Authenticate;\n    }\n  | {\n      requiredUserInteraction: UserInteractionRequired.None;\n      step?:\n        | AuthenticateDAStep.Authenticate\n        | AuthenticateDAStep.GetTrustchain\n        | AuthenticateDAStep.ExtractEncryptionKey;\n    }\n  | AddToTrustchainDAIntermediateValue;\n\nexport enum AuthenticateDAState {\n  Authenticate = \"lkrp-authenticate\",\n}\nexport enum AuthenticateDAStep {\n  OpenApp = \"lkrp.steps.openApp\",\n  Authenticate = \"lkrp.steps.authenticate\",\n  GetTrustchain = \"lkrp.steps.getTrustchain\",\n  ExtractEncryptionKey = \"lkrp.steps.extractEncryptionKey\",\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,EAAA,uBAAAC,IAAA,eAAAC,EAAAJ,GAiEO,IAAKE,OACVA,EAAA,aAAe,oBADLA,OAAA,IAGAC,OACVA,EAAA,QAAU,qBACVA,EAAA,aAAe,0BACfA,EAAA,cAAgB,2BAChBA,EAAA,qBAAuB,kCAJbA,OAAA",
+  "names": ["AuthenticateDeviceActionTypes_exports", "__export", "AuthenticateDAState", "AuthenticateDAStep", "__toCommonJS"]
 }

package/lib/cjs/api/app-binder/GetVersionCommandTypes.js

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

package/lib/cjs/api/app-binder/GetVersionCommandTypes.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/api/app-binder/GetVersionCommandTypes.ts"],
-  "sourcesContent": ["export type GetVersionCommandResponse = {\n  readonly version: string;\n};\n\nexport type GetVersionCommandArgs = undefined;\n"],
+  "sourcesContent": ["export type GetVersionCommandResponse = {\n  readonly version: string;\n};\n"],
   "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
   "names": ["GetVersionCommandTypes_exports", "__toCommonJS"]
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleCryptoService.test.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\n\nimport { Curve, EncryptionAlgo, HashAlgo } from \"@api/crypto/CryptoService\";\n\nimport { NobleCryptoService } from \"./NobleCryptoService\";\nimport { NobleKey } from \"./NobleKey\";\nimport { NobleKeyPair } from \"./NobleKeyPair\";\n\ndescribe(\"NobleCryptoService\", () => {\n  let cryptoService: NobleCryptoService;\n\n  beforeEach(() => {\n    cryptoService = new NobleCryptoService();\n  });\n\n  it(\"should generate random bytes of correct length\", () => {\n    const length = 32;\n    const bytes = cryptoService.randomBytes(length);\n    expect(bytes.length).toBe(length);\n  });\n\n  it(\"should hash data correctly with SHA256\", () => {\n    const data = new TextEncoder().encode(\"test\");\n    const hashResult = cryptoService.hash(data, HashAlgo.SHA256);\n    expect(hashResult).toEqual(\n      hexaStringToBuffer(\n        \"9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08\",\n      )!,\n    );\n  });\n\n  it(\"should compute HMAC correctly with SHA256\", () => {\n    const key = new Uint8Array(32).fill(0x61);\n    const message = new TextEncoder().encode(\"test message\");\n    const hmacResult = cryptoService.hmac(key, message, HashAlgo.SHA256);\n    expect(hmacResult).toEqual(\n      hexaStringToBuffer(\n        \"0b19ad8fef1660f7a191465effeea922079633ada962f52cb60103d9935cc460\",\n      )!,\n    );\n  });\n\n  it(\"should create a key pair\", async () => {\n    const keyPair = await cryptoService.createKeyPair(Curve.K256);\n    expect(keyPair instanceof NobleKeyPair).toBeTruthy();\n  });\n\n  it(\"should import a key pair\", () => {\n    const privateKey = new Uint8Array(32).fill(1);\n    const keyPair = cryptoService.importKeyPair(privateKey, Curve.K256);\n    expect(keyPair instanceof NobleKeyPair).toBeTruthy();\n  });\n\n  it(\"should create a symmetric key\", async () => {\n    const symmetricKey = await cryptoService.createSymmetricKey(\n      EncryptionAlgo.AES256_GCM,\n    );\n    expect(symmetricKey instanceof NobleKey).toBeTruthy();\n  });\n\n  it(\"should import a symmetric key\", () => {\n    const keyMaterial = new Uint8Array(32).fill(1);\n    const symmetricKey = cryptoService.importSymmetricKey(\n      keyMaterial,\n      EncryptionAlgo.AES256_GCM,\n    );\n    expect(symmetricKey instanceof NobleKey).toBeTruthy();\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAAmC,2CAEnCC,EAAgD,qCAEhDC,EAAmC,gCACnCC,EAAyB,sBACzBC,EAA6B,0BAE7B,SAAS,qBAAsB,IAAM,CACnC,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAgB,IAAI,oBACtB,CAAC,EAED,GAAG,iDAAkD,IAAM,CAEzD,MAAMC,EAAQD,EAAc,YAAY,EAAM,EAC9C,OAAOC,EAAM,MAAM,EAAE,KAAK,EAAM,CAClC,CAAC,EAED,GAAG,yCAA0C,IAAM,CACjD,MAAMC,EAAO,IAAI,YAAY,EAAE,OAAO,MAAM,EACtCC,EAAaH,EAAc,KAAKE,EAAM,WAAS,MAAM,EAC3D,OAAOC,CAAU,EAAE,WACjB,sBACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,MAAMC,EAAM,IAAI,WAAW,EAAE,EAAE,KAAK,EAAI,EAClCC,EAAU,IAAI,YAAY,EAAE,OAAO,cAAc,EACjDC,EAAaN,EAAc,KAAKI,EAAKC,EAAS,WAAS,MAAM,EACnE,OAAOC,CAAU,EAAE,WACjB,sBACE,kEACF,CACF,CACF,CAAC,EAED,GAAG,2BAA4B,SAAY,CACzC,MAAMC,EAAU,MAAMP,EAAc,cAAc,QAAM,IAAI,EAC5D,OAAOO,aAAmB,cAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,2BAA4B,IAAM,CACnC,MAAMC,EAAa,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACtCD,EAAUP,EAAc,cAAcQ,EAAY,QAAM,IAAI,EAClE,OAAOD,aAAmB,cAAY,EAAE,WAAW,CACrD,CAAC,EAED,GAAG,gCAAiC,SAAY,CAC9C,MAAME,EAAe,MAAMT,EAAc,mBACvC,iBAAe,UACjB,EACA,OAAOS,aAAwB,UAAQ,EAAE,WAAW,CACtD,CAAC,EAED,GAAG,gCAAiC,IAAM,CACxC,MAAMC,EAAc,IAAI,WAAW,EAAE,EAAE,KAAK,CAAC,EACvCD,EAAeT,EAAc,mBACjCU,EACA,iBAAe,UACjB,EACA,OAAOD,aAAwB,UAAQ,EAAE,WAAW,CACtD,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_CryptoService", "import_NobleCryptoService", "import_NobleKey", "import_NobleKeyPair", "cryptoService", "bytes", "data", "hashResult", "key", "message", "hmacResult", "keyPair", "privateKey", "symmetricKey", "keyMaterial"]
+}

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKey.ts"],
+  "sourcesContent": ["import { gcm } from \"@noble/ciphers/aes\";\nimport { randomBytes } from \"@noble/ciphers/webcrypto\";\n\nimport { EncryptionAlgo } from \"@api/crypto/CryptoService\";\nimport { AES256_BLOCK_SIZE, AES256_KEY_SIZE, type Key } from \"@api/crypto/Key\";\n\nexport class NobleKey implements Key {\n  static async generate(\n    algo: EncryptionAlgo = EncryptionAlgo.AES256_GCM,\n  ): Promise<NobleKey> {\n    if (algo !== EncryptionAlgo.AES256_GCM) {\n      throw new Error(`Unsupported encryption algorithm ${algo}`);\n    }\n    return new NobleKey(randomBytes(AES256_KEY_SIZE));\n  }\n\n  static from(\n    keyMaterial: Uint8Array,\n    algo: EncryptionAlgo = EncryptionAlgo.AES256_GCM,\n  ): NobleKey {\n    if (algo !== EncryptionAlgo.AES256_GCM) {\n      throw new Error(`Unsupported encryption algorithm ${algo}`);\n    }\n    return new NobleKey(keyMaterial);\n  }\n\n  private constructor(private key: Uint8Array) {}\n\n  async encrypt(iv: Uint8Array, data: Uint8Array): Promise<Uint8Array> {\n    const cipher = gcm(this.key, iv.slice(0, AES256_BLOCK_SIZE));\n    return cipher.encrypt(data);\n  }\n\n  async decrypt(\n    iv: Uint8Array,\n    encryptedData: Uint8Array,\n  ): Promise<Uint8Array> {\n    const cipher = gcm(this.key, iv.slice(0, AES256_BLOCK_SIZE));\n    return cipher.decrypt(encryptedData);\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,cAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAoB,8BACpBC,EAA4B,oCAE5BC,EAA+B,qCAC/BC,EAA6D,2BAEtD,MAAML,CAAwB,CAoB3B,YAAoBM,EAAiB,CAAjB,SAAAA,CAAkB,CAnB9C,aAAa,SACXC,EAAuB,iBAAe,WACnB,CACnB,GAAIA,IAAS,iBAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCA,CAAI,EAAE,EAE5D,OAAO,IAAIP,KAAS,eAAY,iBAAe,CAAC,CAClD,CAEA,OAAO,KACLQ,EACAD,EAAuB,iBAAe,WAC5B,CACV,GAAIA,IAAS,iBAAe,WAC1B,MAAM,IAAI,MAAM,oCAAoCA,CAAI,EAAE,EAE5D,OAAO,IAAIP,EAASQ,CAAW,CACjC,CAIA,MAAM,QAAQC,EAAgBC,EAAuC,CAEnE,SADe,OAAI,KAAK,IAAKD,EAAG,MAAM,EAAG,mBAAiB,CAAC,EAC7C,QAAQC,CAAI,CAC5B,CAEA,MAAM,QACJD,EACAE,EACqB,CAErB,SADe,OAAI,KAAK,IAAKF,EAAG,MAAM,EAAG,mBAAiB,CAAC,EAC7C,QAAQE,CAAa,CACrC,CACF",
+  "names": ["NobleKey_exports", "__export", "NobleKey", "__toCommonJS", "import_aes", "import_webcrypto", "import_CryptoService", "import_Key", "key", "algo", "keyMaterial", "iv", "data", "encryptedData"]
+}

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKey.test.ts"],
+  "sourcesContent": ["import { AES256_BLOCK_SIZE, AES256_KEY_SIZE } from \"@api/crypto/Key\";\n\nimport { NobleKey } from \"./NobleKey\";\n\ndescribe(\"NobleKey\", () => {\n  const testData = new TextEncoder().encode(\"Test Data\");\n\n  it(\"should encrypt and decrypt data correctly\", async () => {\n    const key = await NobleKey.generate();\n    const iv = new Uint8Array(AES256_BLOCK_SIZE).fill(0x02);\n    const encryptedData = await key.encrypt(iv, testData);\n    const decryptedData = await key.decrypt(iv, encryptedData);\n\n    expect(encryptedData).not.toEqual(testData);\n    expect(decryptedData).toEqual(testData);\n  });\n\n  it(\"should encrypt and decrypt data from key material\", async () => {\n    const keyMaterial = new Uint8Array(AES256_KEY_SIZE).fill(0x01);\n    const key = NobleKey.from(keyMaterial);\n    const iv = new Uint8Array(AES256_BLOCK_SIZE).fill(0x02);\n    const encryptedData = await key.encrypt(iv, testData);\n    const decryptedData = await key.decrypt(iv, encryptedData);\n\n    expect(encryptedData).not.toEqual(testData);\n    expect(decryptedData).toEqual(testData);\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAAmD,2BAEnDC,EAAyB,sBAEzB,SAAS,WAAY,IAAM,CACzB,MAAMC,EAAW,IAAI,YAAY,EAAE,OAAO,WAAW,EAErD,GAAG,4CAA6C,SAAY,CAC1D,MAAMC,EAAM,MAAM,WAAS,SAAS,EAC9BC,EAAK,IAAI,WAAW,mBAAiB,EAAE,KAAK,CAAI,EAChDC,EAAgB,MAAMF,EAAI,QAAQC,EAAIF,CAAQ,EAC9CI,EAAgB,MAAMH,EAAI,QAAQC,EAAIC,CAAa,EAEzD,OAAOA,CAAa,EAAE,IAAI,QAAQH,CAAQ,EAC1C,OAAOI,CAAa,EAAE,QAAQJ,CAAQ,CACxC,CAAC,EAED,GAAG,oDAAqD,SAAY,CAClE,MAAMK,EAAc,IAAI,WAAW,iBAAe,EAAE,KAAK,CAAI,EACvDJ,EAAM,WAAS,KAAKI,CAAW,EAC/BH,EAAK,IAAI,WAAW,mBAAiB,EAAE,KAAK,CAAI,EAChDC,EAAgB,MAAMF,EAAI,QAAQC,EAAIF,CAAQ,EAC9CI,EAAgB,MAAMH,EAAI,QAAQC,EAAIC,CAAa,EAEzD,OAAOA,CAAa,EAAE,IAAI,QAAQH,CAAQ,EAC1C,OAAOI,CAAa,EAAE,QAAQJ,CAAQ,CACxC,CAAC,CACH,CAAC",
+  "names": ["import_Key", "import_NobleKey", "testData", "key", "iv", "encryptedData", "decryptedData", "keyMaterial"]
+}

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/api/crypto/noble/NobleKeyPair.ts"],
+  "sourcesContent": ["import { bufferToHexaString } from \"@ledgerhq/device-management-kit\";\nimport type { CurveFn } from \"@noble/curves/abstract/weierstrass.js\";\nimport { p256 } from \"@noble/curves/nist.js\";\nimport { secp256k1 } from \"@noble/curves/secp256k1.js\";\n\nimport { Curve } from \"@api/crypto/CryptoService\";\nimport { type KeyPair, SigFormat } from \"@api/crypto/KeyPair\";\n\nexport class NobleKeyPair implements KeyPair {\n  static async generate(curve: Curve): Promise<NobleKeyPair> {\n    const curveImpl = NobleKeyPair.getCurve(curve);\n    const { secretKey, publicKey } = curveImpl.keygen();\n    return new NobleKeyPair(curveImpl, secretKey, publicKey);\n  }\n\n  static from(privateKey: Uint8Array, curve: Curve): NobleKeyPair {\n    const curveImpl = NobleKeyPair.getCurve(curve);\n    const publicKey = curveImpl.getPublicKey(privateKey);\n    return new NobleKeyPair(curveImpl, privateKey, publicKey);\n  }\n\n  private static getCurve(curve: Curve): CurveFn {\n    switch (curve) {\n      case Curve.K256:\n        return secp256k1;\n      case Curve.P256:\n        return p256;\n      default:\n        throw new Error(`Unsupported curve ${curve}`);\n    }\n  }\n\n  private constructor(\n    private curve: CurveFn,\n    private privateKey: Uint8Array,\n    private publicKey: Uint8Array,\n  ) {}\n\n  get id() {\n    return bufferToHexaString(this.privateKey);\n  }\n\n  async sign(data: Uint8Array, format?: SigFormat): Promise<Uint8Array> {\n    return this.curve\n      .sign(data, this.privateKey)\n      .toBytes(format === SigFormat.DER ? \"der\" : \"compact\");\n  }\n\n  async verify(\n    data: Uint8Array,\n    signature: Uint8Array,\n    format?: SigFormat,\n  ): Promise<boolean> {\n    return this.curve.verify(signature, data, this.publicKey, {\n      format: format === SigFormat.DER ? \"der\" : \"compact\",\n    });\n  }\n\n  async deriveSharedSecret(\n    peerPublicKey: Uint8Array,\n    isCompressed: boolean = true,\n  ): Promise<Uint8Array> {\n    return this.curve.getSharedSecret(\n      this.privateKey,\n      peerPublicKey,\n      isCompressed,\n    );\n  }\n\n  getPublicKey(): Uint8Array {\n    return this.publicKey;\n  }\n\n  getPublicKeyToHex(): string {\n    return bufferToHexaString(this.publicKey, false);\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,2CAEnCC,EAAqB,iCACrBC,EAA0B,sCAE1BC,EAAsB,qCACtBC,EAAwC,+BAEjC,MAAMN,CAAgC,CAwBnC,YACEO,EACAC,EACAC,EACR,CAHQ,WAAAF,EACA,gBAAAC,EACA,eAAAC,CACP,CA3BH,aAAa,SAASF,EAAqC,CACzD,MAAMG,EAAYV,EAAa,SAASO,CAAK,EACvC,CAAE,UAAAI,EAAW,UAAAF,CAAU,EAAIC,EAAU,OAAO,EAClD,OAAO,IAAIV,EAAaU,EAAWC,EAAWF,CAAS,CACzD,CAEA,OAAO,KAAKD,EAAwBD,EAA4B,CAC9D,MAAMG,EAAYV,EAAa,SAASO,CAAK,EACvCE,EAAYC,EAAU,aAAaF,CAAU,EACnD,OAAO,IAAIR,EAAaU,EAAWF,EAAYC,CAAS,CAC1D,CAEA,OAAe,SAASF,EAAuB,CAC7C,OAAQA,EAAO,CACb,KAAK,QAAM,KACT,OAAO,YACT,KAAK,QAAM,KACT,OAAO,OACT,QACE,MAAM,IAAI,MAAM,qBAAqBA,CAAK,EAAE,CAChD,CACF,CAQA,IAAI,IAAK,CACP,SAAO,sBAAmB,KAAK,UAAU,CAC3C,CAEA,MAAM,KAAKK,EAAkBC,EAAyC,CACpE,OAAO,KAAK,MACT,KAAKD,EAAM,KAAK,UAAU,EAC1B,QAAQC,IAAW,YAAU,IAAM,MAAQ,SAAS,CACzD,CAEA,MAAM,OACJD,EACAE,EACAD,EACkB,CAClB,OAAO,KAAK,MAAM,OAAOC,EAAWF,EAAM,KAAK,UAAW,CACxD,OAAQC,IAAW,YAAU,IAAM,MAAQ,SAC7C,CAAC,CACH,CAEA,MAAM,mBACJE,EACAC,EAAwB,GACH,CACrB,OAAO,KAAK,MAAM,gBAChB,KAAK,WACLD,EACAC,CACF,CACF,CAEA,cAA2B,CACzB,OAAO,KAAK,SACd,CAEA,mBAA4B,CAC1B,SAAO,sBAAmB,KAAK,UAAW,EAAK,CACjD,CACF",
+  "names": ["NobleKeyPair_exports", "__export", "NobleKeyPair", "__toCommonJS", "import_device_management_kit", "import_nist", "import_secp256k1", "import_CryptoService", "import_KeyPair", "curve", "privateKey", "publicKey", "curveImpl", "secretKey", "data", "format", "signature", "peerPublicKey", "isCompressed"]
+}

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

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

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

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

package/lib/cjs/api/index.js

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var t=(f,e,p,x)=>{if(e&&typeof e=="object"||typeof e=="function")for(let m of c(e))!d.call(f,m)&&m!==p&&a(f,m,{get:()=>e[m],enumerable:!(x=b(e,m))||x.enumerable});return f},r=(f,e,p)=>(t(f,e,"default"),p&&t(p,e,"default"));var g=f=>t(a({},"__esModule",{value:!0}),f);var o={};module.exports=g(o);r(o,require("./app-binder/AuthenticateDeviceActionTypes"),module.exports);r(o,require("./app-binder/KeypairFromBytes"),module.exports);r(o,require("./app-binder/LKRPTypes"),module.exports);r(o,require("./LedgerKeyringProtocol"),module.exports);r(o,require("./LedgerKeyringProtocolBuilder"),module.exports);r(o,require("../internal/externalTypes"),module.exports);0&&(module.exports={...require("./app-binder/AuthenticateDeviceActionTypes"),...require("./app-binder/KeypairFromBytes"),...require("./app-binder/LKRPTypes"),...require("./LedgerKeyringProtocol"),...require("./LedgerKeyringProtocolBuilder"),...require("../internal/externalTypes")});
+"use strict";var a=Object.defineProperty;var b=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var t=(f,e,p,x)=>{if(e&&typeof e=="object"||typeof e=="function")for(let m of c(e))!d.call(f,m)&&m!==p&&a(f,m,{get:()=>e[m],enumerable:!(x=b(e,m))||x.enumerable});return f},r=(f,e,p)=>(t(f,e,"default"),p&&t(p,e,"default"));var g=f=>t(a({},"__esModule",{value:!0}),f);var o={};module.exports=g(o);r(o,require("./app-binder/AuthenticateDeviceActionTypes"),module.exports);r(o,require("./crypto/CryptoService"),module.exports);r(o,require("./crypto/Key"),module.exports);r(o,require("./crypto/KeyPair"),module.exports);r(o,require("./crypto/noble/NobleCryptoService"),module.exports);r(o,require("./crypto/noble/NobleKey"),module.exports);r(o,require("./crypto/noble/NobleKeyPair"),module.exports);r(o,require("./model/Env"),module.exports);r(o,require("./model/Errors"),module.exports);r(o,require("./model/JWT"),module.exports);r(o,require("./model/Permissions"),module.exports);r(o,require("./LedgerKeyringProtocol"),module.exports);r(o,require("./LedgerKeyringProtocolBuilder"),module.exports);r(o,require("../internal/externalTypes"),module.exports);0&&(module.exports={...require("./app-binder/AuthenticateDeviceActionTypes"),...require("./crypto/CryptoService"),...require("./crypto/Key"),...require("./crypto/KeyPair"),...require("./crypto/noble/NobleCryptoService"),...require("./crypto/noble/NobleKey"),...require("./crypto/noble/NobleKeyPair"),...require("./model/Env"),...require("./model/Errors"),...require("./model/JWT"),...require("./model/Permissions"),...require("./LedgerKeyringProtocol"),...require("./LedgerKeyringProtocolBuilder"),...require("../internal/externalTypes")});
 //# sourceMappingURL=index.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/index.ts"],
-  "sourcesContent": ["export * from \"./app-binder/AuthenticateDeviceActionTypes\";\nexport * from \"./app-binder/KeypairFromBytes\";\nexport * from \"./app-binder/LKRPTypes\";\nexport * from \"@api/LedgerKeyringProtocol\";\nexport * from \"@api/LedgerKeyringProtocolBuilder\";\nexport * from \"@internal/externalTypes\";\n"],
-  "mappings": "iaAAA,IAAAA,EAAA,kBAAAC,EAAAD,GAAAE,EAAAF,EAAc,sDAAd,gBACAE,EAAAF,EAAc,yCADd,gBAEAE,EAAAF,EAAc,kCAFd,gBAGAE,EAAAF,EAAc,sCAHd,gBAIAE,EAAAF,EAAc,6CAJd,gBAKAE,EAAAF,EAAc,mCALd",
+  "sourcesContent": ["export * from \"./app-binder/AuthenticateDeviceActionTypes\";\nexport * from \"./crypto/CryptoService\";\nexport * from \"./crypto/Key\";\nexport * from \"./crypto/KeyPair\";\nexport * from \"./crypto/noble/NobleCryptoService\";\nexport * from \"./crypto/noble/NobleKey\";\nexport * from \"./crypto/noble/NobleKeyPair\";\nexport * from \"./model/Env\";\nexport * from \"./model/Errors\";\nexport * from \"./model/JWT\";\nexport * from \"./model/Permissions\";\nexport * from \"@api/LedgerKeyringProtocol\";\nexport * from \"@api/LedgerKeyringProtocolBuilder\";\nexport * from \"@internal/externalTypes\";\n"],
+  "mappings": "iaAAA,IAAAA,EAAA,kBAAAC,EAAAD,GAAAE,EAAAF,EAAc,sDAAd,gBACAE,EAAAF,EAAc,kCADd,gBAEAE,EAAAF,EAAc,wBAFd,gBAGAE,EAAAF,EAAc,4BAHd,gBAIAE,EAAAF,EAAc,6CAJd,gBAKAE,EAAAF,EAAc,mCALd,gBAMAE,EAAAF,EAAc,uCANd,gBAOAE,EAAAF,EAAc,uBAPd,gBAQAE,EAAAF,EAAc,0BARd,gBASAE,EAAAF,EAAc,uBATd,gBAUAE,EAAAF,EAAc,+BAVd,gBAWAE,EAAAF,EAAc,sCAXd,gBAYAE,EAAAF,EAAc,6CAZd,gBAaAE,EAAAF,EAAc,mCAbd",
   "names": ["api_exports", "__toCommonJS", "__reExport"]
 }

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/model/Errors.ts"],
+  "sourcesContent": ["import { GeneralDmkError } from \"@ledgerhq/device-management-kit\";\n\nexport type LKRPDataSourceErrorStatus =\n  | \"UNAUTHORIZED\"\n  | \"BAD_REQUEST\"\n  | \"UNKNOWN\";\n\nexport class LKRPDataSourceError extends GeneralDmkError {\n  override _tag = \"LedgerKeyringProtocolError\";\n  public readonly message: string;\n  public readonly status: LKRPDataSourceErrorStatus;\n\n  constructor(\n    readonly err: {\n      status: LKRPDataSourceErrorStatus;\n      message: string;\n    },\n  ) {\n    super(err.message);\n    this.status = err.status;\n    this.message = err.message;\n  }\n}\n\nexport class LKRPUnauthorizedError extends GeneralDmkError {\n  override _tag = \"LedgerKeyringProtocolError\";\n  constructor(\n    readonly trustchainId: string | null = null,\n    readonly message: string = `Current keypair is not a member of the trustchain${trustchainId ? ` ${trustchainId}` : \"\"}.`,\n  ) {\n    super(message);\n  }\n}\n\nexport class LKRPOutdatedTrustchainError extends GeneralDmkError {\n  override _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly message = \"The trustchain is outdated.\") {\n    super(message);\n  }\n}\n\nexport class LKRPTrustchainNotReady extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(\n    readonly message = \"Ledger Sync must be initialized from Ledger Live with this device.\",\n  ) {\n    super(message);\n  }\n}\n\nexport class LKRPParsingError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class LKRPMissingDataError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly err?: unknown) {\n    super(err);\n  }\n}\n\nexport class LKRPUnsupportedCommandError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  readonly message: string;\n  constructor(readonly command: unknown) {\n    const commandType =\n      command &&\n      typeof command === \"object\" &&\n      \"type\" in command &&\n      typeof command.type === \"number\" &&\n      `0x${command.type.toString(16).padStart(2, \"0\")}`;\n    let message = `Unsupported command`;\n    if (commandType) message += `: ${commandType}`;\n\n    super(message);\n\n    this.message = message;\n  }\n}\n\nexport class LKRPUnknownError extends GeneralDmkError {\n  override readonly _tag = \"LedgerKeyringProtocolError\";\n  constructor(readonly message: string) {\n    super(message);\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,yBAAAE,EAAA,yBAAAC,EAAA,gCAAAC,EAAA,qBAAAC,EAAA,2BAAAC,EAAA,0BAAAC,EAAA,qBAAAC,EAAA,gCAAAC,IAAA,eAAAC,EAAAV,GAAA,IAAAW,EAAgC,2CAOzB,MAAMT,UAA4B,iBAAgB,CAKvD,YACWU,EAIT,CACA,MAAMA,EAAI,OAAO,EALR,SAAAA,EAMT,KAAK,OAASA,EAAI,OAClB,KAAK,QAAUA,EAAI,OACrB,CAbS,KAAO,6BACA,QACA,MAYlB,CAEO,MAAML,UAA8B,iBAAgB,CAEzD,YACWM,EAA8B,KAC9BC,EAAkB,oDAAoDD,EAAe,IAAIA,CAAY,GAAK,EAAE,IACrH,CACA,MAAMC,CAAO,EAHJ,kBAAAD,EACA,aAAAC,CAGX,CANS,KAAO,4BAOlB,CAEO,MAAMV,UAAoC,iBAAgB,CAE/D,YAAqBU,EAAU,8BAA+B,CAC5D,MAAMA,CAAO,EADM,aAAAA,CAErB,CAHS,KAAO,4BAIlB,CAEO,MAAMR,UAA+B,iBAAgB,CAE1D,YACWQ,EAAU,qEACnB,CACA,MAAMA,CAAO,EAFJ,aAAAA,CAGX,CALkB,KAAO,4BAM3B,CAEO,MAAMT,UAAyB,iBAAgB,CAEpD,YAAqBO,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMT,UAA6B,iBAAgB,CAExD,YAAqBS,EAAe,CAClC,MAAMA,CAAG,EADU,SAAAA,CAErB,CAHkB,KAAO,4BAI3B,CAEO,MAAMH,UAAoC,iBAAgB,CAG/D,YAAqBM,EAAkB,CACrC,MAAMC,EACJD,GACA,OAAOA,GAAY,UACnB,SAAUA,GACV,OAAOA,EAAQ,MAAS,UACxB,KAAKA,EAAQ,KAAK,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,GACjD,IAAID,EAAU,sBACVE,IAAaF,GAAW,KAAKE,CAAW,IAE5C,MAAMF,CAAO,EAVM,aAAAC,EAYnB,KAAK,QAAUD,CACjB,CAfkB,KAAO,6BAChB,OAeX,CAEO,MAAMN,UAAyB,iBAAgB,CAEpD,YAAqBM,EAAiB,CACpC,MAAMA,CAAO,EADM,aAAAA,CAErB,CAHkB,KAAO,4BAI3B",
+  "names": ["Errors_exports", "__export", "LKRPDataSourceError", "LKRPMissingDataError", "LKRPOutdatedTrustchainError", "LKRPParsingError", "LKRPTrustchainNotReady", "LKRPUnauthorizedError", "LKRPUnknownError", "LKRPUnsupportedCommandError", "__toCommonJS", "import_device_management_kit", "err", "trustchainId", "message", "command", "commandType"]
+}

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

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

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

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

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

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

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

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

package/lib/cjs/internal/DefaultLedgerKeyringProtocol.js

@@ -1,2 +1,2 @@
-"use strict";var u=Object.defineProperty;var U=Object.getOwnPropertyDescriptor;var D=Object.getOwnPropertyNames;var B=Object.prototype.hasOwnProperty;var b=(o,e)=>{for(var a in e)u(o,a,{get:e[a],enumerable:!0})},L=(o,e,a,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of D(e))!B.call(o,r)&&r!==a&&u(o,r,{get:()=>e[r],enumerable:!(t=U(e,r))||t.enumerable});return o};var T=o=>L(u({},"__esModule",{value:!0}),o);var C={};b(C,{DefaultLedgerKeyringProtocol:()=>x});module.exports=T(C);var m=require("@ledgerhq/device-management-kit"),i=require("purify-ts"),d=require("../api/app-binder/KeypairFromBytes"),f=require("./di"),n=require("./utils/crypto"),h=require("./use-cases/di/useCasesTypes");class x{name;_container;constructor({dmk:e,sessionId:a,baseUrl:t}){this.name="Ledger Keyring Protocol",this._container=(0,f.makeContainer)({dmk:e,sessionId:a,baseUrl:t})}authenticate(e,a,t,r,c,s){return this._container.get(h.useCasesTypes.AuthenticateUseCase).execute(e,a,t,r,c,s)}encryptData(e,a){const t=new d.KeypairFromBytes(e),r=n.CryptoUtils.randomKeypair(),c=t.ecdh(r.pubKeyToU8a()).slice(1),s=n.CryptoUtils.hmac(new Uint8Array,c),y=n.CryptoUtils.randomBytes(16),p=n.CryptoUtils.encrypt(s,y,a),g=p.subarray(0,-n.AES_BLOCK_SIZE),l=p.subarray(-n.AES_BLOCK_SIZE);return new m.ByteArrayBuilder().add8BitUIntToData(0).addBufferToData(r.pubKeyToU8a()).addBufferToData(y).addBufferToData(l).addBufferToData(g).build()}decryptData(e,a){const t=new m.ByteArrayParser(a);return t.extract8BitUInt()!==0?i.Nothing:i.Maybe.sequence([i.Maybe.fromNullable(t.extractFieldByLength(33)),i.Maybe.fromNullable(t.extractFieldByLength(16)),i.Maybe.fromNullable(t.extractFieldByLength(16)),i.Maybe.fromNullable(t.extractFieldByLength(t.getUnparsedRemainingLength()))]).map(r=>{const c=r[0],s=r[1],y=r[2],p=r[3],l=new d.KeypairFromBytes(e).ecdh(c).slice(1),A=n.CryptoUtils.hmac(new Uint8Array,l),K=new Uint8Array([...p,...y]);return n.CryptoUtils.decrypt(A,s,K)})}}0&&(module.exports={DefaultLedgerKeyringProtocol});
+"use strict";var i=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var u=(r,e)=>{for(var t in e)i(r,t,{get:e[t],enumerable:!0})},g=(r,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of y(e))!m.call(r,a)&&a!==t&&i(r,a,{get:()=>e[a],enumerable:!(n=p(e,a))||n.enumerable});return r};var D=r=>g(i({},"__esModule",{value:!0}),r);var A={};u(A,{DefaultLedgerKeyringProtocol:()=>U});module.exports=D(A);var c=require("./di"),o=require("./use-cases/di/useCasesTypes");class U{name;_container;constructor({dmk:e,applicationId:t,cryptoService:n,env:a,baseUrl:s}){this.name="Ledger Keyring Protocol",this._container=(0,c.makeContainer)({dmk:e,applicationId:t,cryptoService:n,env:a,baseUrl:s})}authenticate(e){return this._container.get(o.useCasesTypes.AuthenticateUseCase).execute(e)}encryptData(e,t){return this._container.get(o.useCasesTypes.EncryptDataUseCase).execute(e,t)}decryptData(e,t){return this._container.get(o.useCasesTypes.DecryptDataUseCase).execute(e,t)}}0&&(module.exports={DefaultLedgerKeyringProtocol});
 //# sourceMappingURL=DefaultLedgerKeyringProtocol.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/DefaultLedgerKeyringProtocol.ts"],
-  "sourcesContent": ["import {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport {\n  ByteArrayBuilder,\n  ByteArrayParser,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\nimport { Maybe, Nothing } from \"purify-ts\";\n\nimport { type AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { KeypairFromBytes } from \"@api/app-binder/KeypairFromBytes\";\nimport {\n  type JWT,\n  type Keypair,\n  type Permissions,\n} from \"@api/app-binder/LKRPTypes\";\nimport { type LedgerKeyringProtocol } from \"@api/LedgerKeyringProtocol\";\nimport { makeContainer } from \"@internal/di\";\nimport { AES_BLOCK_SIZE, CryptoUtils } from \"@internal/utils/crypto\";\n\nimport { type AuthenticateUseCase } from \"./use-cases/authentication/AuthenticateUseCase\";\nimport { useCasesTypes } from \"./use-cases/di/useCasesTypes\";\n\ntype DefaultLedgerKeyringProtocolConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  baseUrl: string;\n};\n\nexport class DefaultLedgerKeyringProtocol implements LedgerKeyringProtocol {\n  name: string;\n  private _container: Container;\n\n  constructor({\n    dmk,\n    sessionId,\n    baseUrl,\n  }: DefaultLedgerKeyringProtocolConstructorArgs) {\n    this.name = \"Ledger Keyring Protocol\";\n    this._container = makeContainer({ dmk, sessionId, baseUrl });\n  }\n\n  authenticate(\n    keypair: Keypair,\n    applicationId: number,\n    clientName: string,\n    permissions: Permissions,\n    trustchainId?: string,\n    jwt?: JWT,\n  ): AuthenticateDAReturnType {\n    return this._container\n      .get<AuthenticateUseCase>(useCasesTypes.AuthenticateUseCase)\n      .execute(\n        keypair,\n        applicationId,\n        clientName,\n        permissions,\n        trustchainId,\n        jwt,\n      );\n  }\n\n  // TODO Better return type for error management instead of exceptions\n  encryptData(encryptionKey: Uint8Array, data: Uint8Array): Uint8Array {\n    // TODO move implem in a use case\n\n    // Derive the shared secret using ECDH with an ephemeral keypair\n    const privateKey = new KeypairFromBytes(encryptionKey);\n    const ephemeralKeypair = CryptoUtils.randomKeypair();\n    const sharedSecret = privateKey\n      .ecdh(ephemeralKeypair.pubKeyToU8a())\n      .slice(1);\n\n    // Key derivation using HMAC-SHA256\n    const key = CryptoUtils.hmac(new Uint8Array(), sharedSecret);\n\n    // Generate a random IV (nonce)\n    const iv = CryptoUtils.randomBytes(16);\n\n    // Encrypt data\n    const ciphertext = CryptoUtils.encrypt(key, iv, data);\n    const encryptedData = ciphertext.subarray(0, -AES_BLOCK_SIZE);\n    const tag = ciphertext.subarray(-AES_BLOCK_SIZE);\n\n    // Serialize the result\n    return new ByteArrayBuilder()\n      .add8BitUIntToData(0) // Version of the format\n      .addBufferToData(ephemeralKeypair.pubKeyToU8a())\n      .addBufferToData(iv)\n      .addBufferToData(tag)\n      .addBufferToData(encryptedData)\n      .build();\n  }\n\n  decryptData(encryptionKey: Uint8Array, data: Uint8Array): Maybe<Uint8Array> {\n    // TODO move implem in a use case\n\n    const parser = new ByteArrayParser(data);\n    if (parser.extract8BitUInt() !== 0) {\n      // Unsupported serialization version\n      return Nothing;\n    }\n    return Maybe.sequence([\n      Maybe.fromNullable(parser.extractFieldByLength(33)),\n      Maybe.fromNullable(parser.extractFieldByLength(16)),\n      Maybe.fromNullable(parser.extractFieldByLength(16)),\n      Maybe.fromNullable(\n        parser.extractFieldByLength(parser.getUnparsedRemainingLength()),\n      ),\n    ]).map((parsed) => {\n      const ephemeralPublicKey = parsed[0]!;\n      const iv = parsed[1]!;\n      const tag = parsed[2]!;\n      const encryptedData = parsed[3]!;\n\n      // Derive the shared secret using ECDH with an ephemeral keypair\n      const privateKey = new KeypairFromBytes(encryptionKey);\n      const sharedSecret = privateKey.ecdh(ephemeralPublicKey).slice(1);\n\n      // Key derivation using HMAC-SHA256\n      const key = CryptoUtils.hmac(new Uint8Array(), sharedSecret);\n\n      // Decrypt the data\n      const ciphertext = new Uint8Array([...encryptedData, ...tag]);\n      const cleartext = CryptoUtils.decrypt(key, iv, ciphertext);\n      return cleartext;\n    });\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kCAAAE,IAAA,eAAAC,EAAAH,GAIA,IAAAI,EAGO,2CAEPC,EAA+B,qBAG/BC,EAAiC,4CAOjCC,EAA8B,wBAC9BC,EAA4C,kCAG5CC,EAA8B,wCAQvB,MAAMP,CAA8D,CACzE,KACQ,WAER,YAAY,CACV,IAAAQ,EACA,UAAAC,EACA,QAAAC,CACF,EAAgD,CAC9C,KAAK,KAAO,0BACZ,KAAK,cAAa,iBAAc,CAAE,IAAAF,EAAK,UAAAC,EAAW,QAAAC,CAAQ,CAAC,CAC7D,CAEA,aACEC,EACAC,EACAC,EACAC,EACAC,EACAC,EAC0B,CAC1B,OAAO,KAAK,WACT,IAAyB,gBAAc,mBAAmB,EAC1D,QACCL,EACAC,EACAC,EACAC,EACAC,EACAC,CACF,CACJ,CAGA,YAAYC,EAA2BC,EAA8B,CAInE,MAAMC,EAAa,IAAI,mBAAiBF,CAAa,EAC/CG,EAAmB,cAAY,cAAc,EAC7CC,EAAeF,EAClB,KAAKC,EAAiB,YAAY,CAAC,EACnC,MAAM,CAAC,EAGJE,EAAM,cAAY,KAAK,IAAI,WAAcD,CAAY,EAGrDE,EAAK,cAAY,YAAY,EAAE,EAG/BC,EAAa,cAAY,QAAQF,EAAKC,EAAIL,CAAI,EAC9CO,EAAgBD,EAAW,SAAS,EAAG,CAAC,gBAAc,EACtDE,EAAMF,EAAW,SAAS,CAAC,gBAAc,EAG/C,OAAO,IAAI,mBAAiB,EACzB,kBAAkB,CAAC,EACnB,gBAAgBJ,EAAiB,YAAY,CAAC,EAC9C,gBAAgBG,CAAE,EAClB,gBAAgBG,CAAG,EACnB,gBAAgBD,CAAa,EAC7B,MAAM,CACX,CAEA,YAAYR,EAA2BC,EAAqC,CAG1E,MAAMS,EAAS,IAAI,kBAAgBT,CAAI,EACvC,OAAIS,EAAO,gBAAgB,IAAM,EAExB,UAEF,QAAM,SAAS,CACpB,QAAM,aAAaA,EAAO,qBAAqB,EAAE,CAAC,EAClD,QAAM,aAAaA,EAAO,qBAAqB,EAAE,CAAC,EAClD,QAAM,aAAaA,EAAO,qBAAqB,EAAE,CAAC,EAClD,QAAM,aACJA,EAAO,qBAAqBA,EAAO,2BAA2B,CAAC,CACjE,CACF,CAAC,EAAE,IAAKC,GAAW,CACjB,MAAMC,EAAqBD,EAAO,CAAC,EAC7BL,EAAKK,EAAO,CAAC,EACbF,EAAME,EAAO,CAAC,EACdH,EAAgBG,EAAO,CAAC,EAIxBP,EADa,IAAI,mBAAiBJ,CAAa,EACrB,KAAKY,CAAkB,EAAE,MAAM,CAAC,EAG1DP,EAAM,cAAY,KAAK,IAAI,WAAcD,CAAY,EAGrDG,EAAa,IAAI,WAAW,CAAC,GAAGC,EAAe,GAAGC,CAAG,CAAC,EAE5D,OADkB,cAAY,QAAQJ,EAAKC,EAAIC,CAAU,CAE3D,CAAC,CACH,CACF",
-  "names": ["DefaultLedgerKeyringProtocol_exports", "__export", "DefaultLedgerKeyringProtocol", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "import_KeypairFromBytes", "import_di", "import_crypto", "import_useCasesTypes", "dmk", "sessionId", "baseUrl", "keypair", "applicationId", "clientName", "permissions", "trustchainId", "jwt", "encryptionKey", "data", "privateKey", "ephemeralKeypair", "sharedSecret", "key", "iv", "ciphertext", "encryptedData", "tag", "parser", "parsed", "ephemeralPublicKey"]
+  "sourcesContent": ["import { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\n\nimport { type AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { type LedgerKeyringProtocol } from \"@api/LedgerKeyringProtocol\";\nimport { type LKRPEnv } from \"@api/model/Env\";\nimport { makeContainer } from \"@internal/di\";\n\nimport {\n  type AuthenticateUseCase,\n  type AuthenticateUsecaseInput,\n} from \"./use-cases/authentication/AuthenticateUseCase\";\nimport { type DecryptDataUseCase } from \"./use-cases/authentication/DecryptDataUseCase\";\nimport { type EncryptDataUseCase } from \"./use-cases/authentication/EncryptDataUseCase\";\nimport { useCasesTypes } from \"./use-cases/di/useCasesTypes\";\n\ntype DefaultLedgerKeyringProtocolConstructorArgs = {\n  dmk: DeviceManagementKit;\n  applicationId: number;\n  cryptoService: CryptoService;\n  env?: LKRPEnv;\n  baseUrl?: string;\n};\n\nexport class DefaultLedgerKeyringProtocol implements LedgerKeyringProtocol {\n  name: string;\n  private _container: Container;\n\n  constructor({\n    dmk,\n    applicationId,\n    cryptoService,\n    env,\n    baseUrl,\n  }: DefaultLedgerKeyringProtocolConstructorArgs) {\n    this.name = \"Ledger Keyring Protocol\";\n    this._container = makeContainer({\n      dmk,\n      applicationId,\n      cryptoService,\n      env,\n      baseUrl,\n    });\n  }\n\n  authenticate(input: AuthenticateUsecaseInput): AuthenticateDAReturnType {\n    return this._container\n      .get<AuthenticateUseCase>(useCasesTypes.AuthenticateUseCase)\n      .execute(input);\n  }\n\n  encryptData(\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\n    return this._container\n      .get<EncryptDataUseCase>(useCasesTypes.EncryptDataUseCase)\n      .execute(encryptionKey, data);\n  }\n\n  decryptData(\n    encryptionKey: Uint8Array,\n    data: Uint8Array,\n  ): Promise<Uint8Array> {\n    return this._container\n      .get<DecryptDataUseCase>(useCasesTypes.DecryptDataUseCase)\n      .execute(encryptionKey, data);\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,kCAAAE,IAAA,eAAAC,EAAAH,GAOA,IAAAI,EAA8B,wBAQ9BC,EAA8B,wCAUvB,MAAMH,CAA8D,CACzE,KACQ,WAER,YAAY,CACV,IAAAI,EACA,cAAAC,EACA,cAAAC,EACA,IAAAC,EACA,QAAAC,CACF,EAAgD,CAC9C,KAAK,KAAO,0BACZ,KAAK,cAAa,iBAAc,CAC9B,IAAAJ,EACA,cAAAC,EACA,cAAAC,EACA,IAAAC,EACA,QAAAC,CACF,CAAC,CACH,CAEA,aAAaC,EAA2D,CACtE,OAAO,KAAK,WACT,IAAyB,gBAAc,mBAAmB,EAC1D,QAAQA,CAAK,CAClB,CAEA,YACEC,EACAC,EACqB,CACrB,OAAO,KAAK,WACT,IAAwB,gBAAc,kBAAkB,EACxD,QAAQD,EAAeC,CAAI,CAChC,CAEA,YACED,EACAC,EACqB,CACrB,OAAO,KAAK,WACT,IAAwB,gBAAc,kBAAkB,EACxD,QAAQD,EAAeC,CAAI,CAChC,CACF",
+  "names": ["DefaultLedgerKeyringProtocol_exports", "__export", "DefaultLedgerKeyringProtocol", "__toCommonJS", "import_di", "import_useCasesTypes", "dmk", "applicationId", "cryptoService", "env", "baseUrl", "input", "encryptionKey", "data"]
 }

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

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

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/internal/app-binder/LedgerKeyringProtocolBinder.ts"],
-  "sourcesContent": ["import {\n  DeviceManagementKit,\n  type DeviceSessionId,\n  SendCommandInAppDeviceAction,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { GetVersionDAReturnType } from \"@api/app-binder/GetVersionDeviceActionTypes\";\nimport { JWT, Keypair, Permissions } from \"@api/app-binder/LKRPTypes\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { lkrpDatasourceTypes } from \"@internal/lkrp-datasource/di/lkrpDatasourceTypes\";\n\nimport { GetVersionCommand } from \"./command/GetVersionCommand\";\nimport { AuthenticateDeviceAction } from \"./device-action/AuthenticateDeviceAction\";\n\n@injectable()\nexport class LedgerKeyringProtocolBinder {\n  constructor(\n    @inject(externalTypes.Dmk) private readonly dmk: DeviceManagementKit,\n\n    @inject(externalTypes.SessionId)\n    private readonly sessionId: DeviceSessionId,\n\n    @inject(lkrpDatasourceTypes.LKRPDataSource)\n    private readonly lkrpDataSource: LKRPDataSource,\n  ) {}\n\n  authenticate(args: {\n    keypair: Keypair;\n    applicationId: number;\n    clientName: string;\n    permissions: Permissions;\n    trustchainId?: string;\n    jwt?: JWT;\n  }): AuthenticateDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new AuthenticateDeviceAction({\n        input: {\n          lkrpDataSource: this.lkrpDataSource,\n          applicationId: args.applicationId,\n          clientName: args.clientName,\n          permissions: args.permissions,\n          keypair: args.keypair,\n          trustchainId: args.trustchainId ?? null,\n          jwt: args.jwt ?? null,\n        },\n      }),\n    });\n  }\n\n  getVersion(args: { skipOpenApp: boolean }): GetVersionDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: this.sessionId,\n      deviceAction: new SendCommandInAppDeviceAction({\n        input: {\n          command: new GetVersionCommand(),\n          appName: \"Ledger Sync\",\n          requiredUserInteraction: UserInteractionRequired.None,\n          skipOpenApp: args.skipOpenApp,\n        },\n      }),\n    });\n  }\n\n  getAppName(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  getSeedId(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  init(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  parseStream(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  signBlock(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  setTrustedMember(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n}\n"],
-  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,iCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAKO,2CACPC,EAAmC,qBAKnCC,EAA8B,mCAE9BC,EAAoC,4DAEpCC,EAAkC,uCAClCC,EAAyC,oDAGlC,IAAMC,EAAN,KAAkC,CACvC,YAC8CC,EAG3BC,EAGAC,EACjB,CAP4C,SAAAF,EAG3B,eAAAC,EAGA,oBAAAC,CAChB,CAEH,aAAaC,EAOgB,CAC3B,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAI,2BAAyB,CACzC,MAAO,CACL,eAAgB,KAAK,eACrB,cAAeA,EAAK,cACpB,WAAYA,EAAK,WACjB,YAAaA,EAAK,YAClB,QAASA,EAAK,QACd,aAAcA,EAAK,cAAgB,KACnC,IAAKA,EAAK,KAAO,IACnB,CACF,CAAC,CACH,CAAC,CACH,CAEA,WAAWA,EAAwD,CACjE,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAW,KAAK,UAChB,aAAc,IAAI,+BAA6B,CAC7C,MAAO,CACL,QAAS,IAAI,oBACb,QAAS,cACT,wBAAyB,0BAAwB,KACjD,YAAaA,EAAK,WACpB,CACF,CAAC,CACH,CAAC,CACH,CAEA,YAAsB,CACpB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,MAAgB,CACd,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,aAAuB,CACrB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,kBAA4B,CAC1B,MAAM,IAAI,MAAM,iBAAiB,CACnC,CACF,EAxEaJ,EAANK,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,gBAAc,GAAG,GAExBA,EAAA,eAAO,gBAAc,SAAS,GAG9BA,EAAA,eAAO,sBAAoB,cAAc,IAPjCN",
-  "names": ["LedgerKeyringProtocolBinder_exports", "__export", "LedgerKeyringProtocolBinder", "__toCommonJS", "import_device_management_kit", "import_inversify", "import_externalTypes", "import_lkrpDatasourceTypes", "import_GetVersionCommand", "import_AuthenticateDeviceAction", "LedgerKeyringProtocolBinder", "dmk", "sessionId", "lkrpDataSource", "args", "__decorateClass", "__decorateParam"]
+  "sourcesContent": ["import {\n  DeviceManagementKit,\n  type DeviceSessionId,\n  SendCommandInAppDeviceAction,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { inject, injectable } from \"inversify\";\n\nimport { AuthenticateDAReturnType } from \"@api/app-binder/AuthenticateDeviceActionTypes\";\nimport { GetVersionDAReturnType } from \"@api/app-binder/GetVersionDeviceActionTypes\";\nimport { type CryptoService } from \"@api/crypto/CryptoService\";\nimport { KeyPair } from \"@api/crypto/KeyPair\";\nimport { Permissions } from \"@api/model/Permissions\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { type LKRPDataSource } from \"@internal/lkrp-datasource/data/LKRPDataSource\";\nimport { lkrpDatasourceTypes } from \"@internal/lkrp-datasource/di/lkrpDatasourceTypes\";\n\nimport { GetVersionCommand } from \"./command/GetVersionCommand\";\nimport { AuthenticateWithDeviceDeviceAction } from \"./device-action/AuthenticateWithDeviceDeviceAction\";\nimport { AuthenticateWithKeypairDeviceAction } from \"./device-action/AuthenticateWithKeypairDeviceAction\";\n\n@injectable()\nexport class LedgerKeyringProtocolBinder {\n  constructor(\n    @inject(externalTypes.Dmk) private readonly dmk: DeviceManagementKit,\n\n    @inject(externalTypes.ApplicationId)\n    private readonly applicationId: number,\n\n    @inject(externalTypes.CryptoService)\n    private readonly cryptoService: CryptoService,\n\n    @inject(lkrpDatasourceTypes.LKRPDataSource)\n    private readonly lkrpDataSource: LKRPDataSource,\n  ) {}\n\n  authenticateWithKeypair(args: {\n    keypair: KeyPair;\n    trustchainId: string;\n  }): AuthenticateDAReturnType {\n    return new AuthenticateWithKeypairDeviceAction({\n      input: {\n        lkrpDataSource: this.lkrpDataSource,\n        appId: this.applicationId,\n        cryptoService: this.cryptoService,\n        keypair: args.keypair,\n        trustchainId: args.trustchainId,\n      },\n    }).execute();\n  }\n\n  authenticateWithDevice(args: {\n    keypair: KeyPair;\n    clientName: string;\n    permissions: Permissions;\n    sessionId: DeviceSessionId;\n  }): AuthenticateDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: args.sessionId,\n      deviceAction: new AuthenticateWithDeviceDeviceAction({\n        input: {\n          lkrpDataSource: this.lkrpDataSource,\n          appId: this.applicationId,\n          cryptoService: this.cryptoService,\n          clientName: args.clientName,\n          permissions: args.permissions,\n          keypair: args.keypair,\n        },\n      }),\n    });\n  }\n\n  getVersion(args: {\n    skipOpenApp: boolean;\n    sessionId: DeviceSessionId;\n  }): GetVersionDAReturnType {\n    return this.dmk.executeDeviceAction({\n      sessionId: args.sessionId,\n      deviceAction: new SendCommandInAppDeviceAction({\n        input: {\n          command: new GetVersionCommand(),\n          appName: \"Ledger Sync\",\n          requiredUserInteraction: UserInteractionRequired.None,\n          skipOpenApp: args.skipOpenApp,\n        },\n      }),\n    });\n  }\n\n  getAppName(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  getSeedId(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  init(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  parseStream(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  signBlock(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n\n  setTrustedMember(): unknown {\n    throw new Error(\"Not implemented\");\n  }\n}\n"],
+  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,iCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAKO,2CACPC,EAAmC,qBAOnCC,EAA8B,mCAE9BC,EAAoC,4DAEpCC,EAAkC,uCAClCC,EAAmD,8DACnDC,EAAoD,+DAG7C,IAAMC,EAAN,KAAkC,CACvC,YAC8CC,EAG3BC,EAGAC,EAGAC,EACjB,CAV4C,SAAAH,EAG3B,mBAAAC,EAGA,mBAAAC,EAGA,oBAAAC,CAChB,CAEH,wBAAwBC,EAGK,CAC3B,OAAO,IAAI,sCAAoC,CAC7C,MAAO,CACL,eAAgB,KAAK,eACrB,MAAO,KAAK,cACZ,cAAe,KAAK,cACpB,QAASA,EAAK,QACd,aAAcA,EAAK,YACrB,CACF,CAAC,EAAE,QAAQ,CACb,CAEA,uBAAuBA,EAKM,CAC3B,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAWA,EAAK,UAChB,aAAc,IAAI,qCAAmC,CACnD,MAAO,CACL,eAAgB,KAAK,eACrB,MAAO,KAAK,cACZ,cAAe,KAAK,cACpB,WAAYA,EAAK,WACjB,YAAaA,EAAK,YAClB,QAASA,EAAK,OAChB,CACF,CAAC,CACH,CAAC,CACH,CAEA,WAAWA,EAGgB,CACzB,OAAO,KAAK,IAAI,oBAAoB,CAClC,UAAWA,EAAK,UAChB,aAAc,IAAI,+BAA6B,CAC7C,MAAO,CACL,QAAS,IAAI,oBACb,QAAS,cACT,wBAAyB,0BAAwB,KACjD,YAAaA,EAAK,WACpB,CACF,CAAC,CACH,CAAC,CACH,CAEA,YAAsB,CACpB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,MAAgB,CACd,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,aAAuB,CACrB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,WAAqB,CACnB,MAAM,IAAI,MAAM,iBAAiB,CACnC,CAEA,kBAA4B,CAC1B,MAAM,IAAI,MAAM,iBAAiB,CACnC,CACF,EA1FaL,EAANM,EAAA,IADN,cAAW,EAGPC,EAAA,eAAO,gBAAc,GAAG,GAExBA,EAAA,eAAO,gBAAc,aAAa,GAGlCA,EAAA,eAAO,gBAAc,aAAa,GAGlCA,EAAA,eAAO,sBAAoB,cAAc,IAVjCP",
+  "names": ["LedgerKeyringProtocolBinder_exports", "__export", "LedgerKeyringProtocolBinder", "__toCommonJS", "import_device_management_kit", "import_inversify", "import_externalTypes", "import_lkrpDatasourceTypes", "import_GetVersionCommand", "import_AuthenticateWithDeviceDeviceAction", "import_AuthenticateWithKeypairDeviceAction", "LedgerKeyringProtocolBinder", "dmk", "applicationId", "cryptoService", "lkrpDataSource", "args", "__decorateClass", "__decorateParam"]
 }

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

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var A=(o,e)=>{for(var p in e)a(o,p,{get:e[p],enumerable:!0})},g=(o,e,p,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let m of l(e))!u.call(o,m)&&m!==p&&a(o,m,{get:()=>e[m],enumerable:!(t=i(e,m))||t.enumerable});return o};var y=o=>g(a({},"__esModule",{value:!0}),o);var c={};A(c,{GetAppNameCommand:()=>C});module.exports=y(c);var r=require("@ledgerhq/device-management-kit"),d=require("@ledgerhq/signer-utils"),s=require("purify-ts"),n=require("./utils/ledgerKeyringProtocolErrors");class C{errorHelper=new d.CommandErrorHelper(n.LEDGER_SYNC_ERRORS,n.LedgerKeyringProtocolErrorFactory);getApdu(){const e={cla:224,ins:3,p1:0,p2:0};return new r.ApduBuilder(e).build()}parseResponse(e){return s.Maybe.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const t=new r.ApduParser(e).encodeToString(e.data);return t?(0,r.CommandResultFactory)({data:{name:t}}):(0,r.CommandResultFactory)({error:new r.InvalidStatusWordError("Name is missing")})})}}0&&(module.exports={GetAppNameCommand});
+"use strict";var d=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var A=(o,e)=>{for(var p in e)d(o,p,{get:e[p],enumerable:!0})},g=(o,e,p,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let m of l(e))!u.call(o,m)&&m!==p&&d(o,m,{get:()=>e[m],enumerable:!(t=i(e,m))||t.enumerable});return o};var y=o=>g(d({},"__esModule",{value:!0}),o);var c={};A(c,{GetAppNameCommand:()=>C});module.exports=y(c);var r=require("@ledgerhq/device-management-kit"),a=require("@ledgerhq/signer-utils"),s=require("purify-ts"),n=require("./utils/ledgerKeyringProtocolErrors");class C{errorHelper=new a.CommandErrorHelper(n.LEDGER_SYNC_ERRORS,n.LedgerKeyringProtocolErrorFactory);getApdu(){const e={cla:224,ins:3,p1:0,p2:0};return new r.ApduBuilder(e).build()}parseResponse(e){return s.Maybe.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const t=new r.ApduParser(e).encodeToString(e.data);return t?(0,r.CommandResultFactory)({data:{name:t}}):(0,r.CommandResultFactory)({error:new r.InvalidStatusWordError("Name is missing")})})}}0&&(module.exports={GetAppNameCommand});
 //# sourceMappingURL=GetAppNameCommand.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/GetAppNameCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  type GetAppNameCommandArgs,\n  type GetAppNameCommandResponse,\n} from \"@api/app-binder/GetAppNameCommandTypes\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport class GetAppNameCommand\n  implements\n    Command<\n      GetAppNameCommandResponse,\n      GetAppNameCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    GetAppNameCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const getAppNameArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x03,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(getAppNameArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetAppNameCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const name = parser.encodeToString(apduResponse.data);\n\n      if (!name) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(`Name is missing`),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { name },\n      });\n    });\n  }\n}\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAUO,2CACPC,EAAmC,kCACnCC,EAAsB,qBAOtBC,EAIO,+CAEA,MAAML,CAOb,CACmB,YAAc,IAAI,qBAGjC,qBAAoB,mCAAiC,EAEvD,SAAgB,CACd,MAAMM,EAAkC,CACtC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAGA,OADgB,IAAI,cAAYA,CAAc,EAC/B,MAAM,CACvB,CAEA,cACEC,EAC2E,CAC3E,OAAO,QAAM,aACX,KAAK,YAAY,SAASA,CAAY,CACxC,EAAE,cAAc,IAAM,CAGpB,MAAMC,EAFS,IAAI,aAAWD,CAAY,EAEtB,eAAeA,EAAa,IAAI,EAEpD,OAAKC,KAME,wBAAqB,CAC1B,KAAM,CAAE,KAAAA,CAAK,CACf,CAAC,KAPQ,wBAAqB,CAC1B,MAAO,IAAI,yBAAuB,iBAAiB,CACrD,CAAC,CAML,CAAC,CACH,CACF",
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  LEDGER_SYNC_ERRORS,\n  type LedgerKeyringProtocolErrorCodes,\n  LedgerKeyringProtocolErrorFactory,\n} from \"./utils/ledgerKeyringProtocolErrors\";\n\nexport type GetAppNameCommandResponse = {\n  readonly name: string;\n};\n\nexport type GetAppNameCommandArgs = undefined;\n\nexport class GetAppNameCommand\n  implements\n    Command<\n      GetAppNameCommandResponse,\n      GetAppNameCommandArgs,\n      LedgerKeyringProtocolErrorCodes\n    >\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    GetAppNameCommandResponse,\n    LedgerKeyringProtocolErrorCodes\n  >(LEDGER_SYNC_ERRORS, LedgerKeyringProtocolErrorFactory);\n\n  getApdu(): Apdu {\n    const getAppNameArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x03,\n      p1: 0x00,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(getAppNameArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<GetAppNameCommandResponse, LedgerKeyringProtocolErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      const name = parser.encodeToString(apduResponse.data);\n\n      if (!name) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(`Name is missing`),\n        });\n      }\n\n      return CommandResultFactory({\n        data: { name },\n      });\n    });\n  }\n}\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAUO,2CACPC,EAAmC,kCACnCC,EAAsB,qBAEtBC,EAIO,+CAQA,MAAML,CAOb,CACmB,YAAc,IAAI,qBAGjC,qBAAoB,mCAAiC,EAEvD,SAAgB,CACd,MAAMM,EAAkC,CACtC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAGA,OADgB,IAAI,cAAYA,CAAc,EAC/B,MAAM,CACvB,CAEA,cACEC,EAC2E,CAC3E,OAAO,QAAM,aACX,KAAK,YAAY,SAASA,CAAY,CACxC,EAAE,cAAc,IAAM,CAGpB,MAAMC,EAFS,IAAI,aAAWD,CAAY,EAEtB,eAAeA,EAAa,IAAI,EAEpD,OAAKC,KAME,wBAAqB,CAC1B,KAAM,CAAE,KAAAA,CAAK,CACf,CAAC,KAPQ,wBAAqB,CAC1B,MAAO,IAAI,yBAAuB,iBAAiB,CACrD,CAAC,CAML,CAAC,CACH,CACF",
   "names": ["GetAppNameCommand_exports", "__export", "GetAppNameCommand", "__toCommonJS", "import_device_management_kit", "import_signer_utils", "import_purify_ts", "import_ledgerKeyringProtocolErrors", "getAppNameArgs", "apduResponse", "name"]
 }