npm - @ledgerhq/device-signer-kit-ethereum - Versions diffs - 0.0.0-wrong-error-when-in-experimental-provider-20251021162636 → 0.0.0-z-intent-queue-7-20251204111630 - Mend

@ledgerhq/device-signer-kit-ethereum 0.0.0-wrong-error-when-in-experimental-provider-20251021162636 → 0.0.0-z-intent-queue-7-20251204111630

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

Files changed (357) hide show

package/lib/esm/internal/app-binder/command/SignEIP712Command.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignEIP712Command.test.ts"],
-  "sourcesContent": ["import {\n  type Command,\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { type EthErrorCodes } from \"./utils/ethAppErrors\";\nimport {\n  SignEIP712Command,\n  type SignEIP712CommandResponse,\n} from \"./SignEIP712Command\";\n\nconst SIGN_EIP712_APDU = Uint8Array.from([\n  0xe0, 0x0c, 0x00, 0x01, 0x15, 0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00,\n  0x3c, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\nconst SIGN_EIP712_APDU_V0 = Uint8Array.from([\n  0xe0, 0x0c, 0x00, 0x00, 0x55, 0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00,\n  0x3c, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,\n  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,\n  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\n  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\n  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\n]);\n\nconst LNX_RESPONSE_DATA_GOOD = Uint8Array.from([\n  0x1c, 0x8a, 0x54, 0x05, 0x10, 0xe1, 0x3b, 0x0f, 0x2b, 0x11, 0xa4, 0x51, 0x27,\n  0x57, 0x16, 0xd2, 0x9e, 0x08, 0xca, 0xad, 0x07, 0xe8, 0x9a, 0x1c, 0x84, 0x96,\n  0x47, 0x82, 0xfb, 0x5e, 0x1a, 0xd7, 0x88, 0x64, 0xa0, 0xde, 0x23, 0x5b, 0x27,\n  0x0f, 0xbe, 0x81, 0xe8, 0xe4, 0x06, 0x88, 0xf4, 0xa9, 0xf9, 0xad, 0x9d, 0x28,\n  0x3d, 0x69, 0x05, 0x52, 0xc9, 0x33, 0x1d, 0x77, 0x73, 0xce, 0xaf, 0xa5, 0x13,\n]);\n\nconst LNX_RESPONSE_GOOD = {\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA_GOOD,\n};\n\nconst LNX_RESPONSE_LOCKED = {\n  statusCode: Uint8Array.from([0x55, 0x15]),\n  data: new Uint8Array(),\n};\n\nconst LNX_RESPONSE_DATA_TOO_SHORT = Uint8Array.from([0x01, 0x02]);\n\nconst LNX_RESPONSE_TOO_SHORT = {\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA_TOO_SHORT,\n};\n\ndescribe(\"SignEIP712Command\", () => {\n  let command: Command<SignEIP712CommandResponse, void, EthErrorCodes>;\n\n  beforeEach(() => {\n    command = new SignEIP712Command({\n      derivationPath: \"44'/60'/0'/0/0\",\n      legacyArgs: Nothing,\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should provide the derivation path\", () => {\n      const apdu = command.getApdu();\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_EIP712_APDU);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should parse the response\", () => {\n      const parsedResponse = command.parseResponse(LNX_RESPONSE_GOOD);\n      expect(parsedResponse).toStrictEqual(\n        CommandResultFactory({\n          data: {\n            v: 0x1c,\n            r: \"0x8a540510e13b0f2b11a451275716d29e08caad07e89a1c84964782fb5e1ad788\",\n            s: \"0x64a0de235b270fbe81e8e40688f4a9f9ad9d283d690552c9331d7773ceafa513\",\n          },\n        }),\n      );\n    });\n\n    it(\"should return an error if the response is not successful\", () => {\n      const response = command.parseResponse(LNX_RESPONSE_LOCKED);\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n\n    it(\"should return an error if the response is too short\", () => {\n      const response = command.parseResponse(LNX_RESPONSE_TOO_SHORT);\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n  });\n});\n\ndescribe(\"SignEIP712Command V0\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should provide the derivation path and hashes\", () => {\n      const command = new SignEIP712Command({\n        derivationPath: \"44'/60'/0'/0/0\",\n        legacyArgs: Just({\n          domainHash:\n            \"0x1111111111111111111111111111111111111111111111111111111111111111\",\n          messageHash:\n            \"0x2222222222222222222222222222222222222222222222222222222222222222\",\n        }),\n      });\n      const apdu = command.getApdu();\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_EIP712_APDU_V0);\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  type Command,\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { type EthErrorCodes } from \"./utils/ethAppErrors\";\nimport {\n  SignEIP712Command,\n  type SignEIP712CommandResponse,\n} from \"./SignEIP712Command\";\n\nconst SIGN_EIP712_APDU = Uint8Array.from([\n  0xe0, 0x0c, 0x00, 0x01, 0x15, 0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00,\n  0x3c, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\nconst SIGN_EIP712_APDU_V0 = Uint8Array.from([\n  0xe0, 0x0c, 0x00, 0x00, 0x55, 0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00,\n  0x3c, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,\n  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,\n  0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\n  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\n  0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,\n]);\n\nconst LNX_RESPONSE_DATA_GOOD = Uint8Array.from([\n  0x1c, 0x8a, 0x54, 0x05, 0x10, 0xe1, 0x3b, 0x0f, 0x2b, 0x11, 0xa4, 0x51, 0x27,\n  0x57, 0x16, 0xd2, 0x9e, 0x08, 0xca, 0xad, 0x07, 0xe8, 0x9a, 0x1c, 0x84, 0x96,\n  0x47, 0x82, 0xfb, 0x5e, 0x1a, 0xd7, 0x88, 0x64, 0xa0, 0xde, 0x23, 0x5b, 0x27,\n  0x0f, 0xbe, 0x81, 0xe8, 0xe4, 0x06, 0x88, 0xf4, 0xa9, 0xf9, 0xad, 0x9d, 0x28,\n  0x3d, 0x69, 0x05, 0x52, 0xc9, 0x33, 0x1d, 0x77, 0x73, 0xce, 0xaf, 0xa5, 0x13,\n]);\n\nconst LNX_RESPONSE_GOOD = {\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA_GOOD,\n};\n\nconst LNX_RESPONSE_LOCKED = {\n  statusCode: Uint8Array.from([0x55, 0x15]),\n  data: new Uint8Array(),\n};\n\nconst LNX_RESPONSE_DATA_TOO_SHORT = Uint8Array.from([0x01, 0x02]);\n\nconst LNX_RESPONSE_TOO_SHORT = {\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA_TOO_SHORT,\n};\n\ndescribe(\"SignEIP712Command\", () => {\n  let command: Command<SignEIP712CommandResponse, void, EthErrorCodes>;\n\n  beforeEach(() => {\n    command = new SignEIP712Command({\n      derivationPath: \"44'/60'/0'/0/0\",\n      legacyArgs: Nothing,\n    });\n  });\n\n  describe(\"name\", () => {\n    it(\"should be 'signEIP712'\", () => {\n      expect(command.name).toBe(\"signEIP712\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should provide the derivation path\", () => {\n      const apdu = command.getApdu();\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_EIP712_APDU);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should parse the response\", () => {\n      const parsedResponse = command.parseResponse(LNX_RESPONSE_GOOD);\n      expect(parsedResponse).toStrictEqual(\n        CommandResultFactory({\n          data: {\n            v: 0x1c,\n            r: \"0x8a540510e13b0f2b11a451275716d29e08caad07e89a1c84964782fb5e1ad788\",\n            s: \"0x64a0de235b270fbe81e8e40688f4a9f9ad9d283d690552c9331d7773ceafa513\",\n          },\n        }),\n      );\n    });\n\n    it(\"should return an error if the response is not successful\", () => {\n      const response = command.parseResponse(LNX_RESPONSE_LOCKED);\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n\n    it(\"should return an error if the response is too short\", () => {\n      const response = command.parseResponse(LNX_RESPONSE_TOO_SHORT);\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n  });\n});\n\ndescribe(\"SignEIP712Command V0\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should provide the derivation path and hashes\", () => {\n      const command = new SignEIP712Command({\n        derivationPath: \"44'/60'/0'/0/0\",\n        legacyArgs: Just({\n          domainHash:\n            \"0x1111111111111111111111111111111111111111111111111111111111111111\",\n          messageHash:\n            \"0x2222222222222222222222222222222222222222222222222222222222222222\",\n        }),\n      });\n      const apdu = command.getApdu();\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_EIP712_APDU_V0);\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["CommandResultFactory", "isSuccessCommandResult", "Just", "Nothing", "SignEIP712Command", "SIGN_EIP712_APDU", "SIGN_EIP712_APDU_V0", "LNX_RESPONSE_DATA_GOOD", "LNX_RESPONSE_GOOD", "LNX_RESPONSE_LOCKED", "LNX_RESPONSE_DATA_TOO_SHORT", "LNX_RESPONSE_TOO_SHORT", "command", "apdu", "parsedResponse", "response"]
 }

package/lib/esm/internal/app-binder/command/SignPersonalMessageCommand.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduBuilder as d,ApduParser as i,CommandResultFactory as o,InvalidStatusWordError as a}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Just as p,Maybe as g,Nothing as l}from"purify-ts";import{ETH_APP_ERRORS as u,EthAppCommandErrorFactory as C}from"./utils/ethAppErrors";const y=32,c=32;class h{args;errorHelper=new m(u,C);constructor(r){this.args=r}getApdu(){const{data:r,isFirstChunk:e}=this.args,s={cla:224,ins:8,p1:e?0:128,p2:0};return new d(s).addBufferToData(r).build()}parseResponse(r){return g.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{const e=new i(r),s=e.extract8BitUInt();if(s===void 0)return o({data:l});const n=e.encodeToHexaString(e.extractFieldByLength(y),!0);if(!n)return o({error:new a("R is missing")});const t=e.encodeToHexaString(e.extractFieldByLength(c),!0);return t?o({data:p({r:n,s:t,v:s})}):o({error:new a("S is missing")})})}}export{h as SignPersonalMessageCommand};
+import{ApduBuilder as d,ApduParser as i,CommandResultFactory as n,InvalidStatusWordError as t}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Just as g,Maybe as p,Nothing as l}from"purify-ts";import{ETH_APP_ERRORS as u,EthAppCommandErrorFactory as y}from"./utils/ethAppErrors";const C=32,c=32;class f{name="signPersonalMessage";args;errorHelper=new m(u,y);constructor(r){this.args=r}getApdu(){const{data:r,isFirstChunk:e}=this.args,s={cla:224,ins:8,p1:e?0:128,p2:0};return new d(s).addBufferToData(r).build()}parseResponse(r){return p.fromNullable(this.errorHelper.getError(r)).orDefaultLazy(()=>{const e=new i(r),s=e.extract8BitUInt();if(s===void 0)return n({data:l});const o=e.encodeToHexaString(e.extractFieldByLength(C),!0);if(!o)return n({error:new t("R is missing")});const a=e.encodeToHexaString(e.extractFieldByLength(c),!0);return a?n({data:g({r:o,s:a,v:s})}):n({error:new t("S is missing")})})}}export{f as SignPersonalMessageCommand};
 //# sourceMappingURL=SignPersonalMessageCommand.js.map

package/lib/esm/internal/app-binder/command/SignPersonalMessageCommand.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignPersonalMessageCommand.ts"],
-  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-personal-message\nimport {\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 { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport { type Signature } from \"@api/model/Signature\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\n\nconst R_LENGTH = 32;\nconst S_LENGTH = 32;\n\nexport type SignPersonalMessageCommandArgs = {\n  /**\n   * The data to sign in max 150 bytes chunks\n   */\n  readonly data: Uint8Array;\n  /**\n   * If this is the first chunk of the message\n   */\n  readonly isFirstChunk: boolean;\n};\n\nexport type SignPersonalMessageCommandResponse = Maybe<Signature>;\n\nexport class SignPersonalMessageCommand\n  implements\n    Command<\n      SignPersonalMessageCommandResponse,\n      SignPersonalMessageCommandArgs,\n      EthErrorCodes\n    >\n{\n  readonly args: SignPersonalMessageCommandArgs;\n  private readonly errorHelper = new CommandErrorHelper<\n    SignPersonalMessageCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  constructor(args: SignPersonalMessageCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const { data, isFirstChunk } = this.args;\n    const signPersonalMessageArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x08,\n      p1: isFirstChunk ? 0x00 : 0x80,\n      p2: 0x00,\n    };\n\n    return new ApduBuilder(signPersonalMessageArgs)\n      .addBufferToData(data)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<SignPersonalMessageCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      // The data is returned only for the last chunk\n      const v = parser.extract8BitUInt();\n      if (v === undefined) {\n        return CommandResultFactory({ data: Nothing });\n      }\n\n      const r = parser.encodeToHexaString(\n        parser.extractFieldByLength(R_LENGTH),\n        true,\n      );\n      if (!r) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        });\n      }\n\n      const s = parser.encodeToHexaString(\n        parser.extractFieldByLength(S_LENGTH),\n        true,\n      );\n      if (!s) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: Just({\n          r,\n          s,\n          v,\n        }),\n      });\n    });\n  }\n}\n"],
-  "mappings": "AACA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,QAAAC,EAAM,SAAAC,EAAO,WAAAC,MAAe,YAIrC,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAEP,MAAMC,EAAW,GACXC,EAAW,GAeV,MAAMC,CAOb,CACW,KACQ,YAAc,IAAIR,EAGjCI,EAAgBC,CAAyB,EAE3C,YAAYI,EAAsC,CAChD,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,KAAM,CAAE,KAAAC,EAAM,aAAAC,CAAa,EAAI,KAAK,KAC9BC,EAA2C,CAC/C,IAAK,IACL,IAAK,EACL,GAAID,EAAe,EAAO,IAC1B,GAAI,CACN,EAEA,OAAO,IAAIf,EAAYgB,CAAuB,EAC3C,gBAAgBF,CAAI,EACpB,MAAM,CACX,CAEA,cACEG,EACkE,CAClE,OAAOX,EAAM,aACX,KAAK,YAAY,SAASW,CAAY,CACxC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIjB,EAAWgB,CAAY,EAGpCE,EAAID,EAAO,gBAAgB,EACjC,GAAIC,IAAM,OACR,OAAOjB,EAAqB,CAAE,KAAMK,CAAQ,CAAC,EAG/C,MAAMa,EAAIF,EAAO,mBACfA,EAAO,qBAAqBR,CAAQ,EACpC,EACF,EACA,GAAI,CAACU,EACH,OAAOlB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMkB,EAAIH,EAAO,mBACfA,EAAO,qBAAqBP,CAAQ,EACpC,EACF,EACA,OAAKU,EAMEnB,EAAqB,CAC1B,KAAMG,EAAK,CACT,EAAAe,EACA,EAAAC,EACA,EAAAF,CACF,CAAC,CACH,CAAC,EAXQjB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,CAUL,CAAC,CACH,CACF",
+  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-personal-message\nimport {\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 { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport { type Signature } from \"@api/model/Signature\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\n\nconst R_LENGTH = 32;\nconst S_LENGTH = 32;\n\nexport type SignPersonalMessageCommandArgs = {\n  /**\n   * The data to sign in max 150 bytes chunks\n   */\n  readonly data: Uint8Array;\n  /**\n   * If this is the first chunk of the message\n   */\n  readonly isFirstChunk: boolean;\n};\n\nexport type SignPersonalMessageCommandResponse = Maybe<Signature>;\n\nexport class SignPersonalMessageCommand\n  implements\n    Command<\n      SignPersonalMessageCommandResponse,\n      SignPersonalMessageCommandArgs,\n      EthErrorCodes\n    >\n{\n  readonly name = \"signPersonalMessage\";\n  readonly args: SignPersonalMessageCommandArgs;\n  private readonly errorHelper = new CommandErrorHelper<\n    SignPersonalMessageCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  constructor(args: SignPersonalMessageCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const { data, isFirstChunk } = this.args;\n    const signPersonalMessageArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x08,\n      p1: isFirstChunk ? 0x00 : 0x80,\n      p2: 0x00,\n    };\n\n    return new ApduBuilder(signPersonalMessageArgs)\n      .addBufferToData(data)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<SignPersonalMessageCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(apduResponse),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(apduResponse);\n\n      // The data is returned only for the last chunk\n      const v = parser.extract8BitUInt();\n      if (v === undefined) {\n        return CommandResultFactory({ data: Nothing });\n      }\n\n      const r = parser.encodeToHexaString(\n        parser.extractFieldByLength(R_LENGTH),\n        true,\n      );\n      if (!r) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        });\n      }\n\n      const s = parser.encodeToHexaString(\n        parser.extractFieldByLength(S_LENGTH),\n        true,\n      );\n      if (!s) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: Just({\n          r,\n          s,\n          v,\n        }),\n      });\n    });\n  }\n}\n"],
+  "mappings": "AACA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,QAAAC,EAAM,SAAAC,EAAO,WAAAC,MAAe,YAIrC,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAEP,MAAMC,EAAW,GACXC,EAAW,GAeV,MAAMC,CAOb,CACW,KAAO,sBACP,KACQ,YAAc,IAAIR,EAGjCI,EAAgBC,CAAyB,EAE3C,YAAYI,EAAsC,CAChD,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,KAAM,CAAE,KAAAC,EAAM,aAAAC,CAAa,EAAI,KAAK,KAC9BC,EAA2C,CAC/C,IAAK,IACL,IAAK,EACL,GAAID,EAAe,EAAO,IAC1B,GAAI,CACN,EAEA,OAAO,IAAIf,EAAYgB,CAAuB,EAC3C,gBAAgBF,CAAI,EACpB,MAAM,CACX,CAEA,cACEG,EACkE,CAClE,OAAOX,EAAM,aACX,KAAK,YAAY,SAASW,CAAY,CACxC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIjB,EAAWgB,CAAY,EAGpCE,EAAID,EAAO,gBAAgB,EACjC,GAAIC,IAAM,OACR,OAAOjB,EAAqB,CAAE,KAAMK,CAAQ,CAAC,EAG/C,MAAMa,EAAIF,EAAO,mBACfA,EAAO,qBAAqBR,CAAQ,EACpC,EACF,EACA,GAAI,CAACU,EACH,OAAOlB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMkB,EAAIH,EAAO,mBACfA,EAAO,qBAAqBP,CAAQ,EACpC,EACF,EACA,OAAKU,EAMEnB,EAAqB,CAC1B,KAAMG,EAAK,CACT,EAAAe,EACA,EAAAC,EACA,EAAAF,CACF,CAAC,CACH,CAAC,EAXQjB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,CAUL,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Just", "Maybe", "Nothing", "ETH_APP_ERRORS", "EthAppCommandErrorFactory", "R_LENGTH", "S_LENGTH", "SignPersonalMessageCommand", "args", "data", "isFirstChunk", "signPersonalMessageArgs", "apduResponse", "parser", "v", "r", "s"]
 }

package/lib/esm/internal/app-binder/command/SignPersonalMessageCommand.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduResponse as a,CommandResultFactory as r,InvalidStatusWordError as o,isSuccessCommandResult as p}from"@ledgerhq/device-management-kit";import{Just as d,Nothing as f}from"purify-ts";import{SignPersonalMessageCommand as t}from"./SignPersonalMessageCommand";const i=new Uint8Array([5,128,0,0,44,128,0,0,60,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),m=new Uint8Array([224,8,0,0,25,...i]),u=new Uint8Array([5,128,0,0,44,128,0,0,60,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,66,84,67,32,116,111,32,116,104,101,32,109,111,111,110]),A=new Uint8Array([224,8,0,0,40,...u]),S=new Uint8Array([100,117,104,122,97,117,105,103,100,122,97,117,105,103,100,117,122,97,103,100,105,117,122,103,97,117,100,103,122,97,117,105,103,100,117,122,105,97,103,100,117,105,122,97,103]),E=new Uint8Array([224,8,128,0,45,...S]),_=new Uint8Array([27,151,164,202,143,105,70,51,89,38,1,245,162,62,11,204,85,60,157,10,144,211,163,66,45,87,85,8,169,40,152,185,110,105,80,208,46,116,233,193,2,193,100,162,37,83,48,130,202,189,216,144,239,196,99,246,127,96,206,254,140,63,135,207,206]),c=new Uint8Array([27,25,16,14,83,56,188,108,119,32,187,71,207,57,35,123,79,39,49,108,178,228,226,255,0,70,24,183,99,200,108,138,6,15,240,26,133,87,24,215,151,92,28,84,171,207,125,50,255,150,48,124,11,218,141,105,93,20,41,13,75,197,77,39,139]);describe("SignPersonalMessageCommand",()=>{const n={data:new Uint8Array([]),isFirstChunk:!0};describe("getApdu",()=>{it("should return correct apdu for an empty message",()=>{const x=new t({data:i,isFirstChunk:!0}).getApdu();expect(x.getRawApdu()).toStrictEqual(m)}),it("should return correct apdu for a short message",()=>{const x=new t({data:u,isFirstChunk:!0}).getApdu();expect(x.getRawApdu()).toStrictEqual(A)}),it("should return correct apdu for a not first chunk of a long message",()=>{const x=new t({data:S,isFirstChunk:!1}).getApdu();expect(x.getRawApdu()).toStrictEqual(E)})}),describe("parseResponse",()=>{it("should return correct response after signing success for a short message",()=>{const e=new t({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:_}),s=e.parseResponse(x);expect(s).toStrictEqual(r({data:d({r:"0x97a4ca8f694633592601f5a23e0bcc553c9d0a90d3a3422d575508a92898b96e",s:"0x6950d02e74e9c102c164a225533082cabdd890efc463f67f60cefe8c3f87cfce",v:27})}))}),it("should return an error if user refused on device",()=>{const e=new t({...n}),x=new a({statusCode:new Uint8Array([85,21]),data:new Uint8Array([])}),s=e.parseResponse(x);expect(p(s)).toBe(!1)}),it("should return nothing if not last index of a long message",()=>{const x=new t({...n}).parseResponse(new a({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}));expect(x).toStrictEqual(r({data:f}))}),it("should return correct response of a long message",()=>{const e=new t({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:c}),s=e.parseResponse(x);expect(s).toStrictEqual(r({data:d({r:"0x19100e5338bc6c7720bb47cf39237b4f27316cb2e4e2ff004618b763c86c8a06",s:"0x0ff01a855718d7975c1c54abcf7d32ff96307c0bda8d695d14290d4bc54d278b",v:27})}))}),it("should return an error if r is missing",()=>{const e=new t({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:c.slice(0,32)}),s=e.parseResponse(x);expect(s).toStrictEqual(r({error:new o("R is missing")}))}),it("should return an error if s is missing",()=>{const e=new t({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:c.slice(0,64)}),s=e.parseResponse(x);expect(s).toStrictEqual(r({error:new o("S is missing")}))})})});
+import{ApduResponse as a,CommandResultFactory as r,InvalidStatusWordError as o,isSuccessCommandResult as S}from"@ledgerhq/device-management-kit";import{Just as d,Nothing as f}from"purify-ts";import{SignPersonalMessageCommand as s}from"./SignPersonalMessageCommand";const i=new Uint8Array([5,128,0,0,44,128,0,0,60,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),m=new Uint8Array([224,8,0,0,25,...i]),u=new Uint8Array([5,128,0,0,44,128,0,0,60,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,66,84,67,32,116,111,32,116,104,101,32,109,111,111,110]),A=new Uint8Array([224,8,0,0,40,...u]),p=new Uint8Array([100,117,104,122,97,117,105,103,100,122,97,117,105,103,100,117,122,97,103,100,105,117,122,103,97,117,100,103,122,97,117,105,103,100,117,122,105,97,103,100,117,105,122,97,103]),E=new Uint8Array([224,8,128,0,45,...p]),w=new Uint8Array([27,151,164,202,143,105,70,51,89,38,1,245,162,62,11,204,85,60,157,10,144,211,163,66,45,87,85,8,169,40,152,185,110,105,80,208,46,116,233,193,2,193,100,162,37,83,48,130,202,189,216,144,239,196,99,246,127,96,206,254,140,63,135,207,206]),c=new Uint8Array([27,25,16,14,83,56,188,108,119,32,187,71,207,57,35,123,79,39,49,108,178,228,226,255,0,70,24,183,99,200,108,138,6,15,240,26,133,87,24,215,151,92,28,84,171,207,125,50,255,150,48,124,11,218,141,105,93,20,41,13,75,197,77,39,139]);describe("SignPersonalMessageCommand",()=>{const n={data:new Uint8Array([]),isFirstChunk:!0};describe("name",()=>{it("should be 'signPersonalMessage'",()=>{const e=new s(n);expect(e.name).toBe("signPersonalMessage")})}),describe("getApdu",()=>{it("should return correct apdu for an empty message",()=>{const x=new s({data:i,isFirstChunk:!0}).getApdu();expect(x.getRawApdu()).toStrictEqual(m)}),it("should return correct apdu for a short message",()=>{const x=new s({data:u,isFirstChunk:!0}).getApdu();expect(x.getRawApdu()).toStrictEqual(A)}),it("should return correct apdu for a not first chunk of a long message",()=>{const x=new s({data:p,isFirstChunk:!1}).getApdu();expect(x.getRawApdu()).toStrictEqual(E)})}),describe("parseResponse",()=>{it("should return correct response after signing success for a short message",()=>{const e=new s({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:w}),t=e.parseResponse(x);expect(t).toStrictEqual(r({data:d({r:"0x97a4ca8f694633592601f5a23e0bcc553c9d0a90d3a3422d575508a92898b96e",s:"0x6950d02e74e9c102c164a225533082cabdd890efc463f67f60cefe8c3f87cfce",v:27})}))}),it("should return an error if user refused on device",()=>{const e=new s({...n}),x=new a({statusCode:new Uint8Array([85,21]),data:new Uint8Array([])}),t=e.parseResponse(x);expect(S(t)).toBe(!1)}),it("should return nothing if not last index of a long message",()=>{const x=new s({...n}).parseResponse(new a({statusCode:new Uint8Array([144,0]),data:new Uint8Array([])}));expect(x).toStrictEqual(r({data:f}))}),it("should return correct response of a long message",()=>{const e=new s({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:c}),t=e.parseResponse(x);expect(t).toStrictEqual(r({data:d({r:"0x19100e5338bc6c7720bb47cf39237b4f27316cb2e4e2ff004618b763c86c8a06",s:"0x0ff01a855718d7975c1c54abcf7d32ff96307c0bda8d695d14290d4bc54d278b",v:27})}))}),it("should return an error if r is missing",()=>{const e=new s({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:c.slice(0,32)}),t=e.parseResponse(x);expect(t).toStrictEqual(r({error:new o("R is missing")}))}),it("should return an error if s is missing",()=>{const e=new s({...n}),x=new a({statusCode:new Uint8Array([144,0]),data:c.slice(0,64)}),t=e.parseResponse(x);expect(t).toStrictEqual(r({error:new o("S is missing")}))})})});
 //# sourceMappingURL=SignPersonalMessageCommand.test.js.map

package/lib/esm/internal/app-binder/command/SignPersonalMessageCommand.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignPersonalMessageCommand.test.ts"],
-  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { SignPersonalMessageCommand } from \"./SignPersonalMessageCommand\";\n\nconst SIGN_PERSONAL_EMPTY_MESSAGE_DATA = new Uint8Array([\n  0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\nconst SIGN_PERSONAL_EMPTY_MESSAGE_APDU = new Uint8Array([\n  0xe0,\n  0x08,\n  0x00,\n  0x00,\n  0x19,\n  ...SIGN_PERSONAL_EMPTY_MESSAGE_DATA,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_SHORT_DATA = new Uint8Array([\n  0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x42,\n  0x54, 0x43, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6f,\n  0x6e,\n]);\nconst SIGN_PERSONAL_MESSAGE_SHORT_APDU = new Uint8Array([\n  0xe0,\n  0x08,\n  0x00,\n  0x00,\n  0x28,\n  ...SIGN_PERSONAL_MESSAGE_SHORT_DATA,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA = new Uint8Array([\n  0x64, 0x75, 0x68, 0x7a, 0x61, 0x75, 0x69, 0x67, 0x64, 0x7a, 0x61, 0x75, 0x69,\n  0x67, 0x64, 0x75, 0x7a, 0x61, 0x67, 0x64, 0x69, 0x75, 0x7a, 0x67, 0x61, 0x75,\n  0x64, 0x67, 0x7a, 0x61, 0x75, 0x69, 0x67, 0x64, 0x75, 0x7a, 0x69, 0x61, 0x67,\n  0x64, 0x75, 0x69, 0x7a, 0x61, 0x67,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_APDU = new Uint8Array([\n  0xe0,\n  0x08,\n  0x80,\n  0x00,\n  0x2d,\n  ...SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_SHORT_SUCCESS_RESPONSE = new Uint8Array([\n  0x1b, 0x97, 0xa4, 0xca, 0x8f, 0x69, 0x46, 0x33, 0x59, 0x26, 0x01, 0xf5, 0xa2,\n  0x3e, 0x0b, 0xcc, 0x55, 0x3c, 0x9d, 0x0a, 0x90, 0xd3, 0xa3, 0x42, 0x2d, 0x57,\n  0x55, 0x08, 0xa9, 0x28, 0x98, 0xb9, 0x6e, 0x69, 0x50, 0xd0, 0x2e, 0x74, 0xe9,\n  0xc1, 0x02, 0xc1, 0x64, 0xa2, 0x25, 0x53, 0x30, 0x82, 0xca, 0xbd, 0xd8, 0x90,\n  0xef, 0xc4, 0x63, 0xf6, 0x7f, 0x60, 0xce, 0xfe, 0x8c, 0x3f, 0x87, 0xcf, 0xce,\n]);\n\nconst SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE = new Uint8Array([\n  0x1b, 0x19, 0x10, 0x0e, 0x53, 0x38, 0xbc, 0x6c, 0x77, 0x20, 0xbb, 0x47, 0xcf,\n  0x39, 0x23, 0x7b, 0x4f, 0x27, 0x31, 0x6c, 0xb2, 0xe4, 0xe2, 0xff, 0x00, 0x46,\n  0x18, 0xb7, 0x63, 0xc8, 0x6c, 0x8a, 0x06, 0x0f, 0xf0, 0x1a, 0x85, 0x57, 0x18,\n  0xd7, 0x97, 0x5c, 0x1c, 0x54, 0xab, 0xcf, 0x7d, 0x32, 0xff, 0x96, 0x30, 0x7c,\n  0x0b, 0xda, 0x8d, 0x69, 0x5d, 0x14, 0x29, 0x0d, 0x4b, 0xc5, 0x4d, 0x27, 0x8b,\n]);\n\ndescribe(\"SignPersonalMessageCommand\", (): void => {\n  const defaultArgs = {\n    data: new Uint8Array([]),\n    isFirstChunk: true,\n  };\n\n  describe(\"getApdu\", () => {\n    it(\"should return correct apdu for an empty message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        data: SIGN_PERSONAL_EMPTY_MESSAGE_DATA,\n        isFirstChunk: true,\n      });\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_PERSONAL_EMPTY_MESSAGE_APDU);\n    });\n\n    it(\"should return correct apdu for a short message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        data: SIGN_PERSONAL_MESSAGE_SHORT_DATA,\n        isFirstChunk: true,\n      });\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_PERSONAL_MESSAGE_SHORT_APDU);\n    });\n\n    it(\"should return correct apdu for a not first chunk of a long message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        data: SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA,\n        isFirstChunk: false,\n      });\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(\n        SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_APDU,\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return correct response after signing success for a short message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_MESSAGE_SHORT_SUCCESS_RESPONSE,\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: Just({\n            r: \"0x97a4ca8f694633592601f5a23e0bcc553c9d0a90d3a3422d575508a92898b96e\",\n            s: \"0x6950d02e74e9c102c164a225533082cabdd890efc463f67f60cefe8c3f87cfce\",\n            v: 27,\n          }),\n        }),\n      );\n    });\n    it(\"should return an error if user refused on device\", () => {\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x55, 0x15]),\n        data: new Uint8Array([]),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n\n    it(\"should return nothing if not last index of a long message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      // when\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: new Uint8Array([0x90, 0x00]),\n          data: new Uint8Array([]),\n        }),\n      );\n      // then\n      expect(response).toStrictEqual(CommandResultFactory({ data: Nothing }));\n    });\n\n    it(\"should return correct response of a long message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE,\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: Just({\n            r: \"0x19100e5338bc6c7720bb47cf39237b4f27316cb2e4e2ff004618b763c86c8a06\",\n            s: \"0x0ff01a855718d7975c1c54abcf7d32ff96307c0bda8d695d14290d4bc54d278b\",\n            v: 27,\n          }),\n        }),\n      );\n    });\n\n    it(\"should return an error if r is missing\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE.slice(0, 32),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        }),\n      );\n    });\n\n    it(\"should return an error if s is missing\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE.slice(0, 64),\n      });\n      // when\n      const result = command.parseResponse(apduResponse);\n      // then\n      expect(result).toStrictEqual(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        }),\n      );\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["ApduResponse", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "Just", "Nothing", "SignPersonalMessageCommand", "SIGN_PERSONAL_EMPTY_MESSAGE_DATA", "SIGN_PERSONAL_EMPTY_MESSAGE_APDU", "SIGN_PERSONAL_MESSAGE_SHORT_DATA", "SIGN_PERSONAL_MESSAGE_SHORT_APDU", "SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA", "SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_APDU", "SIGN_PERSONAL_MESSAGE_SHORT_SUCCESS_RESPONSE", "SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE", "defaultArgs", "apdu", "command", "apduResponse", "response", "result"]
+  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { SignPersonalMessageCommand } from \"./SignPersonalMessageCommand\";\n\nconst SIGN_PERSONAL_EMPTY_MESSAGE_DATA = new Uint8Array([\n  0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\nconst SIGN_PERSONAL_EMPTY_MESSAGE_APDU = new Uint8Array([\n  0xe0,\n  0x08,\n  0x00,\n  0x00,\n  0x19,\n  ...SIGN_PERSONAL_EMPTY_MESSAGE_DATA,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_SHORT_DATA = new Uint8Array([\n  0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x42,\n  0x54, 0x43, 0x20, 0x74, 0x6f, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6d, 0x6f, 0x6f,\n  0x6e,\n]);\nconst SIGN_PERSONAL_MESSAGE_SHORT_APDU = new Uint8Array([\n  0xe0,\n  0x08,\n  0x00,\n  0x00,\n  0x28,\n  ...SIGN_PERSONAL_MESSAGE_SHORT_DATA,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA = new Uint8Array([\n  0x64, 0x75, 0x68, 0x7a, 0x61, 0x75, 0x69, 0x67, 0x64, 0x7a, 0x61, 0x75, 0x69,\n  0x67, 0x64, 0x75, 0x7a, 0x61, 0x67, 0x64, 0x69, 0x75, 0x7a, 0x67, 0x61, 0x75,\n  0x64, 0x67, 0x7a, 0x61, 0x75, 0x69, 0x67, 0x64, 0x75, 0x7a, 0x69, 0x61, 0x67,\n  0x64, 0x75, 0x69, 0x7a, 0x61, 0x67,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_APDU = new Uint8Array([\n  0xe0,\n  0x08,\n  0x80,\n  0x00,\n  0x2d,\n  ...SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA,\n]);\n\nconst SIGN_PERSONAL_MESSAGE_SHORT_SUCCESS_RESPONSE = new Uint8Array([\n  0x1b, 0x97, 0xa4, 0xca, 0x8f, 0x69, 0x46, 0x33, 0x59, 0x26, 0x01, 0xf5, 0xa2,\n  0x3e, 0x0b, 0xcc, 0x55, 0x3c, 0x9d, 0x0a, 0x90, 0xd3, 0xa3, 0x42, 0x2d, 0x57,\n  0x55, 0x08, 0xa9, 0x28, 0x98, 0xb9, 0x6e, 0x69, 0x50, 0xd0, 0x2e, 0x74, 0xe9,\n  0xc1, 0x02, 0xc1, 0x64, 0xa2, 0x25, 0x53, 0x30, 0x82, 0xca, 0xbd, 0xd8, 0x90,\n  0xef, 0xc4, 0x63, 0xf6, 0x7f, 0x60, 0xce, 0xfe, 0x8c, 0x3f, 0x87, 0xcf, 0xce,\n]);\n\nconst SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE = new Uint8Array([\n  0x1b, 0x19, 0x10, 0x0e, 0x53, 0x38, 0xbc, 0x6c, 0x77, 0x20, 0xbb, 0x47, 0xcf,\n  0x39, 0x23, 0x7b, 0x4f, 0x27, 0x31, 0x6c, 0xb2, 0xe4, 0xe2, 0xff, 0x00, 0x46,\n  0x18, 0xb7, 0x63, 0xc8, 0x6c, 0x8a, 0x06, 0x0f, 0xf0, 0x1a, 0x85, 0x57, 0x18,\n  0xd7, 0x97, 0x5c, 0x1c, 0x54, 0xab, 0xcf, 0x7d, 0x32, 0xff, 0x96, 0x30, 0x7c,\n  0x0b, 0xda, 0x8d, 0x69, 0x5d, 0x14, 0x29, 0x0d, 0x4b, 0xc5, 0x4d, 0x27, 0x8b,\n]);\n\ndescribe(\"SignPersonalMessageCommand\", (): void => {\n  const defaultArgs = {\n    data: new Uint8Array([]),\n    isFirstChunk: true,\n  };\n\n  describe(\"name\", () => {\n    it(\"should be 'signPersonalMessage'\", () => {\n      const command = new SignPersonalMessageCommand(defaultArgs);\n      expect(command.name).toBe(\"signPersonalMessage\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return correct apdu for an empty message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        data: SIGN_PERSONAL_EMPTY_MESSAGE_DATA,\n        isFirstChunk: true,\n      });\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_PERSONAL_EMPTY_MESSAGE_APDU);\n    });\n\n    it(\"should return correct apdu for a short message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        data: SIGN_PERSONAL_MESSAGE_SHORT_DATA,\n        isFirstChunk: true,\n      });\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(SIGN_PERSONAL_MESSAGE_SHORT_APDU);\n    });\n\n    it(\"should return correct apdu for a not first chunk of a long message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        data: SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA,\n        isFirstChunk: false,\n      });\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(\n        SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_APDU,\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return correct response after signing success for a short message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_MESSAGE_SHORT_SUCCESS_RESPONSE,\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: Just({\n            r: \"0x97a4ca8f694633592601f5a23e0bcc553c9d0a90d3a3422d575508a92898b96e\",\n            s: \"0x6950d02e74e9c102c164a225533082cabdd890efc463f67f60cefe8c3f87cfce\",\n            v: 27,\n          }),\n        }),\n      );\n    });\n    it(\"should return an error if user refused on device\", () => {\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x55, 0x15]),\n        data: new Uint8Array([]),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n\n    it(\"should return nothing if not last index of a long message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      // when\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: new Uint8Array([0x90, 0x00]),\n          data: new Uint8Array([]),\n        }),\n      );\n      // then\n      expect(response).toStrictEqual(CommandResultFactory({ data: Nothing }));\n    });\n\n    it(\"should return correct response of a long message\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE,\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: Just({\n            r: \"0x19100e5338bc6c7720bb47cf39237b4f27316cb2e4e2ff004618b763c86c8a06\",\n            s: \"0x0ff01a855718d7975c1c54abcf7d32ff96307c0bda8d695d14290d4bc54d278b\",\n            v: 27,\n          }),\n        }),\n      );\n    });\n\n    it(\"should return an error if r is missing\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE.slice(0, 32),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        }),\n      );\n    });\n\n    it(\"should return an error if s is missing\", () => {\n      // given\n      const command = new SignPersonalMessageCommand({\n        ...defaultArgs,\n      });\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE.slice(0, 64),\n      });\n      // when\n      const result = command.parseResponse(apduResponse);\n      // then\n      expect(result).toStrictEqual(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        }),\n      );\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["ApduResponse", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "Just", "Nothing", "SignPersonalMessageCommand", "SIGN_PERSONAL_EMPTY_MESSAGE_DATA", "SIGN_PERSONAL_EMPTY_MESSAGE_APDU", "SIGN_PERSONAL_MESSAGE_SHORT_DATA", "SIGN_PERSONAL_MESSAGE_SHORT_APDU", "SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_DATA", "SIGN_PERSONAL_MESSAGE_NOT_FIRST_CHUNK_APDU", "SIGN_PERSONAL_MESSAGE_SHORT_SUCCESS_RESPONSE", "SIGN_PERSONAL_LONG_MESSAGE_SUCCESS_RESPONSE", "defaultArgs", "command", "apdu", "apduResponse", "response", "result"]
 }

package/lib/esm/internal/app-binder/command/SignTransactionCommand.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduBuilder as i,ApduParser as d,CommandResultFactory as t,InvalidStatusWordError as s}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Just as p,Maybe as u,Nothing as c}from"purify-ts";import{ETH_APP_ERRORS as g,EthAppCommandErrorFactory as l}from"./utils/ethAppErrors";const C=32,y=32;class R{errorHelper=new m(g,l);args;constructor(n){this.args=n}getApdu(){const{serializedTransaction:n,isFirstChunk:r}=this.args,e={cla:224,ins:4,p1:r?0:128,p2:0};return new i(e).addBufferToData(n).build()}parseResponse(n){return u.fromNullable(this.errorHelper.getError(n)).orDefaultLazy(()=>{const r=new d(n),e=r.extract8BitUInt();if(e===void 0)return t({data:c});const o=r.encodeToHexaString(r.extractFieldByLength(C),!0);if(!o)return t({error:new s("R is missing")});const a=r.encodeToHexaString(r.extractFieldByLength(y),!0);return a?t({data:p({v:e,r:o,s:a})}):t({error:new s("S is missing")})})}}export{R as SignTransactionCommand};
+import{ApduBuilder as i,ApduParser as d,CommandResultFactory as t,InvalidStatusWordError as s}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Just as p,Maybe as u,Nothing as c}from"purify-ts";import{ETH_APP_ERRORS as g,EthAppCommandErrorFactory as l}from"./utils/ethAppErrors";const C=32,y=32;class R{name="signTransaction";errorHelper=new m(g,l);args;constructor(n){this.args=n}getApdu(){const{serializedTransaction:n,isFirstChunk:r}=this.args,e={cla:224,ins:4,p1:r?0:128,p2:0};return new i(e).addBufferToData(n).build()}parseResponse(n){return u.fromNullable(this.errorHelper.getError(n)).orDefaultLazy(()=>{const r=new d(n),e=r.extract8BitUInt();if(e===void 0)return t({data:c});const o=r.encodeToHexaString(r.extractFieldByLength(C),!0);if(!o)return t({error:new s("R is missing")});const a=r.encodeToHexaString(r.extractFieldByLength(y),!0);return a?t({data:p({v:e,r:o,s:a})}):t({error:new s("S is missing")})})}}export{R as SignTransactionCommand};
 //# sourceMappingURL=SignTransactionCommand.js.map

package/lib/esm/internal/app-binder/command/SignTransactionCommand.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignTransactionCommand.ts"],
-  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-transaction\nimport {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  type HexaString,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\n\nconst R_LENGTH = 32;\nconst S_LENGTH = 32;\n\nexport type SignTransactionCommandResponse = Maybe<{\n  v: number;\n  r: HexaString;\n  s: HexaString;\n}>;\n\nexport type SignTransactionCommandArgs = {\n  /**\n   * The transaction to sign in max 150 bytes chunks\n   */\n  readonly serializedTransaction: Uint8Array;\n  /**\n   * If this is the first chunk of the message\n   */\n  readonly isFirstChunk: boolean;\n};\n\nexport class SignTransactionCommand\n  implements\n    Command<\n      SignTransactionCommandResponse,\n      SignTransactionCommandArgs,\n      EthErrorCodes\n    >\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    SignTransactionCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  args: SignTransactionCommandArgs;\n\n  constructor(args: SignTransactionCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const { serializedTransaction, isFirstChunk } = this.args;\n\n    const signEthTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x04,\n      p1: isFirstChunk ? 0x00 : 0x80,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(signEthTransactionArgs);\n\n    return builder.addBufferToData(serializedTransaction).build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignTransactionCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(response);\n\n      // The data is returned only for the last chunk\n      const v = parser.extract8BitUInt();\n      if (v === undefined) {\n        return CommandResultFactory({ data: Nothing });\n      }\n\n      const r = parser.encodeToHexaString(\n        parser.extractFieldByLength(R_LENGTH),\n        true,\n      );\n      if (!r) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        });\n      }\n\n      const s = parser.encodeToHexaString(\n        parser.extractFieldByLength(S_LENGTH),\n        true,\n      );\n      if (!s) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: Just({\n          v,\n          r,\n          s,\n        }),\n      });\n    });\n  }\n}\n"],
-  "mappings": "AACA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EAEA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,QAAAC,EAAM,SAAAC,EAAO,WAAAC,MAAe,YAErC,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAEP,MAAMC,EAAW,GACXC,EAAW,GAmBV,MAAMC,CAOb,CACmB,YAAc,IAAIR,EAGjCI,EAAgBC,CAAyB,EAE3C,KAEA,YAAYI,EAAkC,CAC5C,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,KAAM,CAAE,sBAAAC,EAAuB,aAAAC,CAAa,EAAI,KAAK,KAE/CC,EAA0C,CAC9C,IAAK,IACL,IAAK,EACL,GAAID,EAAe,EAAO,IAC1B,GAAI,CACN,EAIA,OAFgB,IAAIf,EAAYgB,CAAsB,EAEvC,gBAAgBF,CAAqB,EAAE,MAAM,CAC9D,CAEA,cACEG,EAC8D,CAC9D,OAAOX,EAAM,aACX,KAAK,YAAY,SAASW,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIjB,EAAWgB,CAAQ,EAGhCE,EAAID,EAAO,gBAAgB,EACjC,GAAIC,IAAM,OACR,OAAOjB,EAAqB,CAAE,KAAMK,CAAQ,CAAC,EAG/C,MAAMa,EAAIF,EAAO,mBACfA,EAAO,qBAAqBR,CAAQ,EACpC,EACF,EACA,GAAI,CAACU,EACH,OAAOlB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMkB,EAAIH,EAAO,mBACfA,EAAO,qBAAqBP,CAAQ,EACpC,EACF,EACA,OAAKU,EAMEnB,EAAqB,CAC1B,KAAMG,EAAK,CACT,EAAAc,EACA,EAAAC,EACA,EAAAC,CACF,CAAC,CACH,CAAC,EAXQnB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,CAUL,CAAC,CACH,CACF",
+  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-transaction\nimport {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  type HexaString,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\n\nconst R_LENGTH = 32;\nconst S_LENGTH = 32;\n\nexport type SignTransactionCommandResponse = Maybe<{\n  v: number;\n  r: HexaString;\n  s: HexaString;\n}>;\n\nexport type SignTransactionCommandArgs = {\n  /**\n   * The transaction to sign in max 150 bytes chunks\n   */\n  readonly serializedTransaction: Uint8Array;\n  /**\n   * If this is the first chunk of the message\n   */\n  readonly isFirstChunk: boolean;\n};\n\nexport class SignTransactionCommand\n  implements\n    Command<\n      SignTransactionCommandResponse,\n      SignTransactionCommandArgs,\n      EthErrorCodes\n    >\n{\n  readonly name = \"signTransaction\";\n  private readonly errorHelper = new CommandErrorHelper<\n    SignTransactionCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  args: SignTransactionCommandArgs;\n\n  constructor(args: SignTransactionCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const { serializedTransaction, isFirstChunk } = this.args;\n\n    const signEthTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x04,\n      p1: isFirstChunk ? 0x00 : 0x80,\n      p2: 0x00,\n    };\n\n    const builder = new ApduBuilder(signEthTransactionArgs);\n\n    return builder.addBufferToData(serializedTransaction).build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignTransactionCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(response);\n\n      // The data is returned only for the last chunk\n      const v = parser.extract8BitUInt();\n      if (v === undefined) {\n        return CommandResultFactory({ data: Nothing });\n      }\n\n      const r = parser.encodeToHexaString(\n        parser.extractFieldByLength(R_LENGTH),\n        true,\n      );\n      if (!r) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        });\n      }\n\n      const s = parser.encodeToHexaString(\n        parser.extractFieldByLength(S_LENGTH),\n        true,\n      );\n      if (!s) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: Just({\n          v,\n          r,\n          s,\n        }),\n      });\n    });\n  }\n}\n"],
+  "mappings": "AACA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EAEA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,QAAAC,EAAM,SAAAC,EAAO,WAAAC,MAAe,YAErC,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAEP,MAAMC,EAAW,GACXC,EAAW,GAmBV,MAAMC,CAOb,CACW,KAAO,kBACC,YAAc,IAAIR,EAGjCI,EAAgBC,CAAyB,EAE3C,KAEA,YAAYI,EAAkC,CAC5C,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,KAAM,CAAE,sBAAAC,EAAuB,aAAAC,CAAa,EAAI,KAAK,KAE/CC,EAA0C,CAC9C,IAAK,IACL,IAAK,EACL,GAAID,EAAe,EAAO,IAC1B,GAAI,CACN,EAIA,OAFgB,IAAIf,EAAYgB,CAAsB,EAEvC,gBAAgBF,CAAqB,EAAE,MAAM,CAC9D,CAEA,cACEG,EAC8D,CAC9D,OAAOX,EAAM,aACX,KAAK,YAAY,SAASW,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIjB,EAAWgB,CAAQ,EAGhCE,EAAID,EAAO,gBAAgB,EACjC,GAAIC,IAAM,OACR,OAAOjB,EAAqB,CAAE,KAAMK,CAAQ,CAAC,EAG/C,MAAMa,EAAIF,EAAO,mBACfA,EAAO,qBAAqBR,CAAQ,EACpC,EACF,EACA,GAAI,CAACU,EACH,OAAOlB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMkB,EAAIH,EAAO,mBACfA,EAAO,qBAAqBP,CAAQ,EACpC,EACF,EACA,OAAKU,EAMEnB,EAAqB,CAC1B,KAAMG,EAAK,CACT,EAAAc,EACA,EAAAC,EACA,EAAAC,CACF,CAAC,CACH,CAAC,EAXQnB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,CAUL,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Just", "Maybe", "Nothing", "ETH_APP_ERRORS", "EthAppCommandErrorFactory", "R_LENGTH", "S_LENGTH", "SignTransactionCommand", "args", "serializedTransaction", "isFirstChunk", "signEthTransactionArgs", "response", "parser", "v", "r", "s"]
 }

package/lib/esm/internal/app-binder/command/SignTransactionCommand.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduResponse as a,CommandResultFactory as x,InvalidStatusWordError as c,isSuccessCommandResult as s,UnknownDeviceExchangeError as d}from"@ledgerhq/device-management-kit";import{Just as i,Nothing as p}from"purify-ts";import{SignTransactionCommand as n}from"./SignTransactionCommand";const m=new a({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),r=new Uint8Array([38,141,39,68,71,17,187,237,68,43,155,252,119,5,192,115,22,183,228,17,80,197,51,18,114,228,210,9,212,34,249,250,57,0,204,63,12,25,56,192,241,255,198,45,240,55,34,90,19,54,251,161,249,254,250,17,245,175,197,188,185,126,177,179,209,144,0]),u=new a({statusCode:Uint8Array.from([144,0]),data:r});describe("SignTransactionCommand",()=>{const t={serializedTransaction:new Uint8Array,isFirstChunk:!0};describe("getApdu",()=>{describe("Legacy",()=>{it("should return the correct APDU when the data is empty",()=>{const e=new n({...t}).getApdu();expect(e.data).toStrictEqual(new Uint8Array),expect(e.cla).toBe(224),expect(e.ins).toBe(4),expect(e.p1).toBe(0),expect(e.p2).toBe(0)}),it("should return the correct APDU when the data is not empty",()=>{const e=new n({...t,serializedTransaction:new Uint8Array([1,2,3])}).getApdu();expect(e.data).toStrictEqual(new Uint8Array([1,2,3])),expect(e.cla).toBe(224),expect(e.ins).toBe(4),expect(e.p1).toBe(0),expect(e.p2).toBe(0)}),it("should return the correct APDU when it is not the first chunk",()=>{const e=new n({...t,isFirstChunk:!1}).getApdu();expect(e.data).toStrictEqual(new Uint8Array),expect(e.cla).toBe(224),expect(e.ins).toBe(4),expect(e.p1).toBe(128),expect(e.p2).toBe(0)})}),describe.todo("Store and start",()=>{}),describe.todo("Start",()=>{})}),describe("parseResponse",()=>{it("should return Nothing when the response data is empty",()=>{const e=new n({...t}).parseResponse(m);expect(e).toStrictEqual(x({data:p}))}),it("should return Just the response data when the response data is not empty",()=>{const e=new n({...t}).parseResponse(u);expect(e).toStrictEqual(x({data:i({r:"0x8d27444711bbed442b9bfc7705c07316b7e41150c5331272e4d209d422f9fa39",s:"0x00cc3f0c1938c0f1ffc62df037225a1336fba1f9fefa11f5afc5bcb97eb1b3d1",v:38})}))}),it("should return a UnknownDeviceExchangeError when the response status code is not 0x9000",()=>{const e=new n({...t}).parseResponse(new a({statusCode:Uint8Array.from([81,85]),data:new Uint8Array}));expect(s(e)).toBe(!1),expect(e.error).toBeInstanceOf(d)}),it("should return an InvalidStatusWord error when the response data r is not valid",()=>{const e=new n({...t}).parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:r.slice(0,1)}));expect(s(e)).toBe(!1),expect(e.error).toBeInstanceOf(c)}),it("should return an error when the response data s is not valid",()=>{const e=new n({...t}).parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:r.slice(0,33)}));expect(s(e)).toBe(!1)})})});
+import{ApduResponse as a,CommandResultFactory as c,InvalidStatusWordError as x,isSuccessCommandResult as s,UnknownDeviceExchangeError as d}from"@ledgerhq/device-management-kit";import{Just as i,Nothing as p}from"purify-ts";import{SignTransactionCommand as o}from"./SignTransactionCommand";const m=new a({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}),r=new Uint8Array([38,141,39,68,71,17,187,237,68,43,155,252,119,5,192,115,22,183,228,17,80,197,51,18,114,228,210,9,212,34,249,250,57,0,204,63,12,25,56,192,241,255,198,45,240,55,34,90,19,54,251,161,249,254,250,17,245,175,197,188,185,126,177,179,209,144,0]),u=new a({statusCode:Uint8Array.from([144,0]),data:r});describe("SignTransactionCommand",()=>{const t={serializedTransaction:new Uint8Array,isFirstChunk:!0};describe("name",()=>{it("should be 'signTransaction'",()=>{const n=new o(t);expect(n.name).toBe("signTransaction")})}),describe("getApdu",()=>{describe("Legacy",()=>{it("should return the correct APDU when the data is empty",()=>{const e=new o({...t}).getApdu();expect(e.data).toStrictEqual(new Uint8Array),expect(e.cla).toBe(224),expect(e.ins).toBe(4),expect(e.p1).toBe(0),expect(e.p2).toBe(0)}),it("should return the correct APDU when the data is not empty",()=>{const e=new o({...t,serializedTransaction:new Uint8Array([1,2,3])}).getApdu();expect(e.data).toStrictEqual(new Uint8Array([1,2,3])),expect(e.cla).toBe(224),expect(e.ins).toBe(4),expect(e.p1).toBe(0),expect(e.p2).toBe(0)}),it("should return the correct APDU when it is not the first chunk",()=>{const e=new o({...t,isFirstChunk:!1}).getApdu();expect(e.data).toStrictEqual(new Uint8Array),expect(e.cla).toBe(224),expect(e.ins).toBe(4),expect(e.p1).toBe(128),expect(e.p2).toBe(0)})}),describe.todo("Store and start",()=>{}),describe.todo("Start",()=>{})}),describe("parseResponse",()=>{it("should return Nothing when the response data is empty",()=>{const e=new o({...t}).parseResponse(m);expect(e).toStrictEqual(c({data:p}))}),it("should return Just the response data when the response data is not empty",()=>{const e=new o({...t}).parseResponse(u);expect(e).toStrictEqual(c({data:i({r:"0x8d27444711bbed442b9bfc7705c07316b7e41150c5331272e4d209d422f9fa39",s:"0x00cc3f0c1938c0f1ffc62df037225a1336fba1f9fefa11f5afc5bcb97eb1b3d1",v:38})}))}),it("should return a UnknownDeviceExchangeError when the response status code is not 0x9000",()=>{const e=new o({...t}).parseResponse(new a({statusCode:Uint8Array.from([81,85]),data:new Uint8Array}));expect(s(e)).toBe(!1),expect(e.error).toBeInstanceOf(d)}),it("should return an InvalidStatusWord error when the response data r is not valid",()=>{const e=new o({...t}).parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:r.slice(0,1)}));expect(s(e)).toBe(!1),expect(e.error).toBeInstanceOf(x)}),it("should return an error when the response data s is not valid",()=>{const e=new o({...t}).parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:r.slice(0,33)}));expect(s(e)).toBe(!1)})})});
 //# sourceMappingURL=SignTransactionCommand.test.js.map

package/lib/esm/internal/app-binder/command/SignTransactionCommand.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignTransactionCommand.test.ts"],
-  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n  UnknownDeviceExchangeError,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport {\n  SignTransactionCommand,\n  type SignTransactionCommandArgs,\n} from \"./SignTransactionCommand\";\n\nconst LNX_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: new Uint8Array([]),\n});\n\nconst LNX_RESPONSE_DATA = new Uint8Array([\n  0x26, 0x8d, 0x27, 0x44, 0x47, 0x11, 0xbb, 0xed, 0x44, 0x2b, 0x9b, 0xfc, 0x77,\n  0x05, 0xc0, 0x73, 0x16, 0xb7, 0xe4, 0x11, 0x50, 0xc5, 0x33, 0x12, 0x72, 0xe4,\n  0xd2, 0x09, 0xd4, 0x22, 0xf9, 0xfa, 0x39, 0x00, 0xcc, 0x3f, 0x0c, 0x19, 0x38,\n  0xc0, 0xf1, 0xff, 0xc6, 0x2d, 0xf0, 0x37, 0x22, 0x5a, 0x13, 0x36, 0xfb, 0xa1,\n  0xf9, 0xfe, 0xfa, 0x11, 0xf5, 0xaf, 0xc5, 0xbc, 0xb9, 0x7e, 0xb1, 0xb3, 0xd1,\n  0x90, 0x00,\n]);\n\nconst LNX_RESPONSE_DATA_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA,\n});\n\ndescribe(\"SignTransactionCommand\", () => {\n  const defaultArgs: SignTransactionCommandArgs = {\n    serializedTransaction: new Uint8Array(),\n    isFirstChunk: true,\n  };\n\n  describe(\"getApdu\", () => {\n    describe(\"Legacy\", () => {\n      it(\"should return the correct APDU when the data is empty\", () => {\n        // GIVEN\n        const command = new SignTransactionCommand({\n          ...defaultArgs,\n        });\n\n        // WHEN\n        const apdu = command.getApdu();\n\n        // THEN\n        expect(apdu.data).toStrictEqual(new Uint8Array());\n        expect(apdu.cla).toBe(0xe0);\n        expect(apdu.ins).toBe(0x04);\n        expect(apdu.p1).toBe(0x00);\n        expect(apdu.p2).toBe(0x00);\n      });\n\n      it(\"should return the correct APDU when the data is not empty\", () => {\n        // GIVEN\n        const command = new SignTransactionCommand({\n          ...defaultArgs,\n          serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n        });\n\n        // WHEN\n        const apdu = command.getApdu();\n\n        // THEN\n        expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n        expect(apdu.cla).toBe(0xe0);\n        expect(apdu.ins).toBe(0x04);\n        expect(apdu.p1).toBe(0x00);\n        expect(apdu.p2).toBe(0x00);\n      });\n\n      it(\"should return the correct APDU when it is not the first chunk\", () => {\n        // GIVEN\n        const command = new SignTransactionCommand({\n          ...defaultArgs,\n          isFirstChunk: false,\n        });\n\n        // WHEN\n        const apdu = command.getApdu();\n\n        // THEN\n        expect(apdu.data).toStrictEqual(new Uint8Array());\n        expect(apdu.cla).toBe(0xe0);\n        expect(apdu.ins).toBe(0x04);\n        expect(apdu.p1).toBe(0x80);\n        expect(apdu.p2).toBe(0x00);\n      });\n    });\n\n    describe.todo(\"Store and start\", () => {});\n\n    describe.todo(\"Start\", () => {});\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return Nothing when the response data is empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(LNX_RESPONSE_GOOD);\n\n      // THEN\n      expect(response).toStrictEqual(CommandResultFactory({ data: Nothing }));\n    });\n\n    it(\"should return Just the response data when the response data is not empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(LNX_RESPONSE_DATA_GOOD);\n\n      // THEN\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: Just({\n            r: \"0x8d27444711bbed442b9bfc7705c07316b7e41150c5331272e4d209d422f9fa39\",\n            s: \"0x00cc3f0c1938c0f1ffc62df037225a1336fba1f9fefa11f5afc5bcb97eb1b3d1\",\n            v: 38,\n          }),\n        }),\n      );\n    });\n\n    it(\"should return a UnknownDeviceExchangeError when the response status code is not 0x9000\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x51, 0x55]),\n          data: new Uint8Array(),\n        }),\n      );\n\n      // THEN\n      expect(isSuccessCommandResult(response)).toBe(false);\n      // @ts-expect-error `error`is not typed because we did not narrow it\n      expect(response.error).toBeInstanceOf(UnknownDeviceExchangeError);\n    });\n\n    it(\"should return an InvalidStatusWord error when the response data r is not valid\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: LNX_RESPONSE_DATA.slice(0, 1),\n        }),\n      );\n\n      // THEN\n      expect(isSuccessCommandResult(response)).toBe(false);\n      // @ts-expect-error `error`is not typed because we did not narrow it\n      expect(response.error).toBeInstanceOf(InvalidStatusWordError);\n    });\n\n    it(\"should return an error when the response data s is not valid\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: LNX_RESPONSE_DATA.slice(0, 33),\n        }),\n      );\n\n      // THEN\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["ApduResponse", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "UnknownDeviceExchangeError", "Just", "Nothing", "SignTransactionCommand", "LNX_RESPONSE_GOOD", "LNX_RESPONSE_DATA", "LNX_RESPONSE_DATA_GOOD", "defaultArgs", "apdu", "response"]
+  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n  UnknownDeviceExchangeError,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport {\n  SignTransactionCommand,\n  type SignTransactionCommandArgs,\n} from \"./SignTransactionCommand\";\n\nconst LNX_RESPONSE_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: new Uint8Array([]),\n});\n\nconst LNX_RESPONSE_DATA = new Uint8Array([\n  0x26, 0x8d, 0x27, 0x44, 0x47, 0x11, 0xbb, 0xed, 0x44, 0x2b, 0x9b, 0xfc, 0x77,\n  0x05, 0xc0, 0x73, 0x16, 0xb7, 0xe4, 0x11, 0x50, 0xc5, 0x33, 0x12, 0x72, 0xe4,\n  0xd2, 0x09, 0xd4, 0x22, 0xf9, 0xfa, 0x39, 0x00, 0xcc, 0x3f, 0x0c, 0x19, 0x38,\n  0xc0, 0xf1, 0xff, 0xc6, 0x2d, 0xf0, 0x37, 0x22, 0x5a, 0x13, 0x36, 0xfb, 0xa1,\n  0xf9, 0xfe, 0xfa, 0x11, 0xf5, 0xaf, 0xc5, 0xbc, 0xb9, 0x7e, 0xb1, 0xb3, 0xd1,\n  0x90, 0x00,\n]);\n\nconst LNX_RESPONSE_DATA_GOOD = new ApduResponse({\n  statusCode: Uint8Array.from([0x90, 0x00]),\n  data: LNX_RESPONSE_DATA,\n});\n\ndescribe(\"SignTransactionCommand\", () => {\n  const defaultArgs: SignTransactionCommandArgs = {\n    serializedTransaction: new Uint8Array(),\n    isFirstChunk: true,\n  };\n\n  describe(\"name\", () => {\n    it(\"should be 'signTransaction'\", () => {\n      const command = new SignTransactionCommand(defaultArgs);\n      expect(command.name).toBe(\"signTransaction\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    describe(\"Legacy\", () => {\n      it(\"should return the correct APDU when the data is empty\", () => {\n        // GIVEN\n        const command = new SignTransactionCommand({\n          ...defaultArgs,\n        });\n\n        // WHEN\n        const apdu = command.getApdu();\n\n        // THEN\n        expect(apdu.data).toStrictEqual(new Uint8Array());\n        expect(apdu.cla).toBe(0xe0);\n        expect(apdu.ins).toBe(0x04);\n        expect(apdu.p1).toBe(0x00);\n        expect(apdu.p2).toBe(0x00);\n      });\n\n      it(\"should return the correct APDU when the data is not empty\", () => {\n        // GIVEN\n        const command = new SignTransactionCommand({\n          ...defaultArgs,\n          serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n        });\n\n        // WHEN\n        const apdu = command.getApdu();\n\n        // THEN\n        expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n        expect(apdu.cla).toBe(0xe0);\n        expect(apdu.ins).toBe(0x04);\n        expect(apdu.p1).toBe(0x00);\n        expect(apdu.p2).toBe(0x00);\n      });\n\n      it(\"should return the correct APDU when it is not the first chunk\", () => {\n        // GIVEN\n        const command = new SignTransactionCommand({\n          ...defaultArgs,\n          isFirstChunk: false,\n        });\n\n        // WHEN\n        const apdu = command.getApdu();\n\n        // THEN\n        expect(apdu.data).toStrictEqual(new Uint8Array());\n        expect(apdu.cla).toBe(0xe0);\n        expect(apdu.ins).toBe(0x04);\n        expect(apdu.p1).toBe(0x80);\n        expect(apdu.p2).toBe(0x00);\n      });\n    });\n\n    describe.todo(\"Store and start\", () => {});\n\n    describe.todo(\"Start\", () => {});\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return Nothing when the response data is empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(LNX_RESPONSE_GOOD);\n\n      // THEN\n      expect(response).toStrictEqual(CommandResultFactory({ data: Nothing }));\n    });\n\n    it(\"should return Just the response data when the response data is not empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(LNX_RESPONSE_DATA_GOOD);\n\n      // THEN\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: Just({\n            r: \"0x8d27444711bbed442b9bfc7705c07316b7e41150c5331272e4d209d422f9fa39\",\n            s: \"0x00cc3f0c1938c0f1ffc62df037225a1336fba1f9fefa11f5afc5bcb97eb1b3d1\",\n            v: 38,\n          }),\n        }),\n      );\n    });\n\n    it(\"should return a UnknownDeviceExchangeError when the response status code is not 0x9000\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x51, 0x55]),\n          data: new Uint8Array(),\n        }),\n      );\n\n      // THEN\n      expect(isSuccessCommandResult(response)).toBe(false);\n      // @ts-expect-error `error`is not typed because we did not narrow it\n      expect(response.error).toBeInstanceOf(UnknownDeviceExchangeError);\n    });\n\n    it(\"should return an InvalidStatusWord error when the response data r is not valid\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: LNX_RESPONSE_DATA.slice(0, 1),\n        }),\n      );\n\n      // THEN\n      expect(isSuccessCommandResult(response)).toBe(false);\n      // @ts-expect-error `error`is not typed because we did not narrow it\n      expect(response.error).toBeInstanceOf(InvalidStatusWordError);\n    });\n\n    it(\"should return an error when the response data s is not valid\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        ...defaultArgs,\n      });\n\n      // WHEN\n      const response = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: LNX_RESPONSE_DATA.slice(0, 33),\n        }),\n      );\n\n      // THEN\n      expect(isSuccessCommandResult(response)).toBe(false);\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["ApduResponse", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "UnknownDeviceExchangeError", "Just", "Nothing", "SignTransactionCommand", "LNX_RESPONSE_GOOD", "LNX_RESPONSE_DATA", "LNX_RESPONSE_DATA_GOOD", "defaultArgs", "command", "apdu", "response"]
 }

package/lib/esm/internal/app-binder/command/StartTransactionCommand.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduBuilder as i,ApduParser as d,CommandResultFactory as n,InvalidStatusWordError as o}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Just as p,Maybe as u}from"purify-ts";import{ETH_APP_ERRORS as c,EthAppCommandErrorFactory as l}from"./utils/ethAppErrors";const E=32,g=32;class S{errorHelper=new m(c,l);getApdu(){const e={cla:224,ins:4,p1:0,p2:2};return new i(e).build()}parseResponse(e){return u.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const r=new d(e),t=r.extract8BitUInt();if(t===void 0)return n({error:new o("V is missing")});const s=r.encodeToHexaString(r.extractFieldByLength(E),!0);if(!s)return n({error:new o("R is missing")});const a=r.encodeToHexaString(r.extractFieldByLength(g),!0);return a?n({data:p({v:t,r:s,s:a})}):n({error:new o("S is missing")})})}}export{S as StartTransactionCommand};
+import{ApduBuilder as i,ApduParser as d,CommandResultFactory as n,InvalidStatusWordError as o}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as m}from"@ledgerhq/signer-utils";import{Just as p,Maybe as u}from"purify-ts";import{ETH_APP_ERRORS as c,EthAppCommandErrorFactory as l}from"./utils/ethAppErrors";const E=32,g=32;class f{name="startTransaction";errorHelper=new m(c,l);getApdu(){const e={cla:224,ins:4,p1:0,p2:2};return new i(e).build()}parseResponse(e){return u.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const r=new d(e),t=r.extract8BitUInt();if(t===void 0)return n({error:new o("V is missing")});const s=r.encodeToHexaString(r.extractFieldByLength(E),!0);if(!s)return n({error:new o("R is missing")});const a=r.encodeToHexaString(r.extractFieldByLength(g),!0);return a?n({data:p({v:t,r:s,s:a})}):n({error:new o("S is missing")})})}}export{f as StartTransactionCommand};
 //# sourceMappingURL=StartTransactionCommand.js.map

package/lib/esm/internal/app-binder/command/StartTransactionCommand.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/StartTransactionCommand.ts"],
-  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-transaction\n// https://github.com/LedgerHQ/generic_parser/blob/master/specs.md#sign (to be removed when the top link has been updated)\nimport {\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 { Just, Maybe } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\nimport { type SignTransactionCommandResponse } from \"./SignTransactionCommand\";\n\nconst R_LENGTH = 32;\nconst S_LENGTH = 32;\n\n/**\n * StartTransactionCommand is a SignTransactionCommand that is used to sign the transaction.\n * It signature differs from the SignTransactionCommand because\n * the command does not need a Transaction to be provided.\n */\nexport class StartTransactionCommand\n  implements Command<SignTransactionCommandResponse, void, EthErrorCodes>\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    SignTransactionCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  getApdu(): Apdu {\n    const signEthTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x04,\n      p1: 0x00,\n      p2: 0x02,\n    };\n    const builder = new ApduBuilder(signEthTransactionArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignTransactionCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(response);\n\n      // The data is returned only for the last chunk\n      const v = parser.extract8BitUInt();\n      if (v === undefined) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"V is missing\"),\n        });\n      }\n\n      const r = parser.encodeToHexaString(\n        parser.extractFieldByLength(R_LENGTH),\n        true,\n      );\n      if (!r) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        });\n      }\n\n      const s = parser.encodeToHexaString(\n        parser.extractFieldByLength(S_LENGTH),\n        true,\n      );\n      if (!s) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: Just({\n          v,\n          r,\n          s,\n        }),\n      });\n    });\n  }\n}\n"],
-  "mappings": "AAEA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,QAAAC,EAAM,SAAAC,MAAa,YAE5B,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAGP,MAAMC,EAAW,GACXC,EAAW,GAOV,MAAMC,CAEb,CACmB,YAAc,IAAIP,EAGjCG,EAAgBC,CAAyB,EAE3C,SAAgB,CACd,MAAMI,EAA0C,CAC9C,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAEA,OADgB,IAAIZ,EAAYY,CAAsB,EACvC,MAAM,CACvB,CAEA,cACEC,EAC8D,CAC9D,OAAOP,EAAM,aACX,KAAK,YAAY,SAASO,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIb,EAAWY,CAAQ,EAGhCE,EAAID,EAAO,gBAAgB,EACjC,GAAIC,IAAM,OACR,OAAOb,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMa,EAAIF,EAAO,mBACfA,EAAO,qBAAqBL,CAAQ,EACpC,EACF,EACA,GAAI,CAACO,EACH,OAAOd,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMc,EAAIH,EAAO,mBACfA,EAAO,qBAAqBJ,CAAQ,EACpC,EACF,EACA,OAAKO,EAMEf,EAAqB,CAC1B,KAAMG,EAAK,CACT,EAAAU,EACA,EAAAC,EACA,EAAAC,CACF,CAAC,CACH,CAAC,EAXQf,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,CAUL,CAAC,CACH,CACF",
+  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-transaction\n// https://github.com/LedgerHQ/generic_parser/blob/master/specs.md#sign (to be removed when the top link has been updated)\nimport {\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 { Just, Maybe } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\nimport { type SignTransactionCommandResponse } from \"./SignTransactionCommand\";\n\nconst R_LENGTH = 32;\nconst S_LENGTH = 32;\n\n/**\n * StartTransactionCommand is a SignTransactionCommand that is used to sign the transaction.\n * It signature differs from the SignTransactionCommand because\n * the command does not need a Transaction to be provided.\n */\nexport class StartTransactionCommand\n  implements Command<SignTransactionCommandResponse, void, EthErrorCodes>\n{\n  readonly name = \"startTransaction\";\n  private readonly errorHelper = new CommandErrorHelper<\n    SignTransactionCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  getApdu(): Apdu {\n    const signEthTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x04,\n      p1: 0x00,\n      p2: 0x02,\n    };\n    const builder = new ApduBuilder(signEthTransactionArgs);\n    return builder.build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignTransactionCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(response);\n\n      // The data is returned only for the last chunk\n      const v = parser.extract8BitUInt();\n      if (v === undefined) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"V is missing\"),\n        });\n      }\n\n      const r = parser.encodeToHexaString(\n        parser.extractFieldByLength(R_LENGTH),\n        true,\n      );\n      if (!r) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"R is missing\"),\n        });\n      }\n\n      const s = parser.encodeToHexaString(\n        parser.extractFieldByLength(S_LENGTH),\n        true,\n      );\n      if (!s) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"S is missing\"),\n        });\n      }\n\n      return CommandResultFactory({\n        data: Just({\n          v,\n          r,\n          s,\n        }),\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAEA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,QAAAC,EAAM,SAAAC,MAAa,YAE5B,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAGP,MAAMC,EAAW,GACXC,EAAW,GAOV,MAAMC,CAEb,CACW,KAAO,mBACC,YAAc,IAAIP,EAGjCG,EAAgBC,CAAyB,EAE3C,SAAgB,CACd,MAAMI,EAA0C,CAC9C,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,EAEA,OADgB,IAAIZ,EAAYY,CAAsB,EACvC,MAAM,CACvB,CAEA,cACEC,EAC8D,CAC9D,OAAOP,EAAM,aACX,KAAK,YAAY,SAASO,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIb,EAAWY,CAAQ,EAGhCE,EAAID,EAAO,gBAAgB,EACjC,GAAIC,IAAM,OACR,OAAOb,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMa,EAAIF,EAAO,mBACfA,EAAO,qBAAqBL,CAAQ,EACpC,EACF,EACA,GAAI,CAACO,EACH,OAAOd,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,EAGH,MAAMc,EAAIH,EAAO,mBACfA,EAAO,qBAAqBJ,CAAQ,EACpC,EACF,EACA,OAAKO,EAMEf,EAAqB,CAC1B,KAAMG,EAAK,CACT,EAAAU,EACA,EAAAC,EACA,EAAAC,CACF,CAAC,CACH,CAAC,EAXQf,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,cAAc,CAClD,CAAC,CAUL,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Just", "Maybe", "ETH_APP_ERRORS", "EthAppCommandErrorFactory", "R_LENGTH", "S_LENGTH", "StartTransactionCommand", "signEthTransactionArgs", "response", "parser", "v", "r", "s"]
 }

package/lib/esm/internal/app-binder/command/StartTransactionCommand.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{InvalidStatusWordError as n,isSuccessCommandResult as o}from"@ledgerhq/device-management-kit";import{EthAppCommandError as a}from"./utils/ethAppErrors";import{StartTransactionCommand as s}from"./StartTransactionCommand";describe("StartTransactionCommand",()=>{describe("getApdu",()=>{it("should return the raw APDU",()=>{const t=new s().getApdu();expect(t.getRawApdu()).toStrictEqual(Uint8Array.from([224,4,0,2,0]))})}),describe("parseResponse",()=>{it("should return an error if the response status code is invalid",()=>{const e={data:Uint8Array.from([]),statusCode:Uint8Array.from([109,0])},r=new s().parseResponse(e);o(r)?assert.fail("Expected an error"):expect(r.error).toBeInstanceOf(a)}),it("should return the correct response",()=>{const e={data:Uint8Array.from([1,...Array(32).fill(2),...Array(32).fill(3)]),statusCode:Uint8Array.from([144,0])},r=new s().parseResponse(e);o(r)?expect(r.data.extract()).toEqual({r:"0x0202020202020202020202020202020202020202020202020202020202020202",s:"0x0303030303030303030303030303030303030303030303030303030303030303",v:1}):assert.fail("Expected a success")}),it("should return an error if v is not valid",()=>{const e={data:Uint8Array.from([]),statusCode:Uint8Array.from([144,0])},r=new s().parseResponse(e);o(r)?assert.fail("Expected an error"):(expect(r.error).toBeInstanceOf(n),expect(r.error.originalError).toEqual(new Error("V is missing")))}),it("should return an error if r is not valid",()=>{const e={data:Uint8Array.from([1,...Array(20).fill(2)]),statusCode:Uint8Array.from([144,0])},r=new s().parseResponse(e);o(r)?assert.fail("Expected an error"):(expect(r.error).toBeInstanceOf(n),expect(r.error.originalError).toEqual(new Error("R is missing")))}),it("should return an error if s is not valid",()=>{const e={data:Uint8Array.from([1,...Array(32).fill(2),...Array(20).fill(2)]),statusCode:Uint8Array.from([144,0])},r=new s().parseResponse(e);o(r)?assert.fail("Expected an error"):(expect(r.error).toBeInstanceOf(n),expect(r.error.originalError).toEqual(new Error("S is missing")))})})});
+import{InvalidStatusWordError as n,isSuccessCommandResult as o}from"@ledgerhq/device-management-kit";import{EthAppCommandError as a}from"./utils/ethAppErrors";import{StartTransactionCommand as t}from"./StartTransactionCommand";describe("StartTransactionCommand",()=>{describe("name",()=>{it("should be 'startTransaction'",()=>{const e=new t;expect(e.name).toBe("startTransaction")})}),describe("getApdu",()=>{it("should return the raw APDU",()=>{const s=new t().getApdu();expect(s.getRawApdu()).toStrictEqual(Uint8Array.from([224,4,0,2,0]))})}),describe("parseResponse",()=>{it("should return an error if the response status code is invalid",()=>{const e={data:Uint8Array.from([]),statusCode:Uint8Array.from([109,0])},r=new t().parseResponse(e);o(r)?assert.fail("Expected an error"):expect(r.error).toBeInstanceOf(a)}),it("should return the correct response",()=>{const e={data:Uint8Array.from([1,...Array(32).fill(2),...Array(32).fill(3)]),statusCode:Uint8Array.from([144,0])},r=new t().parseResponse(e);o(r)?expect(r.data.extract()).toEqual({r:"0x0202020202020202020202020202020202020202020202020202020202020202",s:"0x0303030303030303030303030303030303030303030303030303030303030303",v:1}):assert.fail("Expected a success")}),it("should return an error if v is not valid",()=>{const e={data:Uint8Array.from([]),statusCode:Uint8Array.from([144,0])},r=new t().parseResponse(e);o(r)?assert.fail("Expected an error"):(expect(r.error).toBeInstanceOf(n),expect(r.error.originalError).toEqual(new Error("V is missing")))}),it("should return an error if r is not valid",()=>{const e={data:Uint8Array.from([1,...Array(20).fill(2)]),statusCode:Uint8Array.from([144,0])},r=new t().parseResponse(e);o(r)?assert.fail("Expected an error"):(expect(r.error).toBeInstanceOf(n),expect(r.error.originalError).toEqual(new Error("R is missing")))}),it("should return an error if s is not valid",()=>{const e={data:Uint8Array.from([1,...Array(32).fill(2),...Array(20).fill(2)]),statusCode:Uint8Array.from([144,0])},r=new t().parseResponse(e);o(r)?assert.fail("Expected an error"):(expect(r.error).toBeInstanceOf(n),expect(r.error.originalError).toEqual(new Error("S is missing")))})})});
 //# sourceMappingURL=StartTransactionCommand.test.js.map

package/lib/esm/internal/app-binder/command/StartTransactionCommand.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/StartTransactionCommand.test.ts"],
-  "sourcesContent": ["import {\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { EthAppCommandError } from \"./utils/ethAppErrors\";\nimport { StartTransactionCommand } from \"./StartTransactionCommand\";\n\ndescribe(\"StartTransactionCommand\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should return the raw APDU\", () => {\n      // WHEN\n      const command = new StartTransactionCommand();\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x04, 0x00, 0x02, 0x00]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return an error if the response status code is invalid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([]),\n        statusCode: Uint8Array.from([0x6d, 0x00]), // Invalid status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(EthAppCommandError);\n      }\n    });\n\n    it(\"should return the correct response\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([\n          0x01,\n          ...Array<number>(32).fill(0x02),\n          ...Array<number>(32).fill(0x03),\n        ]), // Some data\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data.extract()).toEqual({\n          r: \"0x0202020202020202020202020202020202020202020202020202020202020202\",\n          s: \"0x0303030303030303030303030303030303030303030303030303030303030303\",\n          v: 1,\n        });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return an error if v is not valid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([]), // No data\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect(result.error.originalError).toEqual(new Error(\"V is missing\"));\n      }\n    });\n\n    it(\"should return an error if r is not valid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([0x01, ...Array<number>(20).fill(0x02)]), // Invalid r\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect(result.error.originalError).toEqual(new Error(\"R is missing\"));\n      }\n    });\n\n    it(\"should return an error if s is not valid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([\n          0x01,\n          ...Array<number>(32).fill(0x02),\n          ...Array<number>(20).fill(0x02),\n        ]), // Invalid s\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect(result.error.originalError).toEqual(new Error(\"S is missing\"));\n      }\n    });\n  });\n});\n"],
-  "mappings": "AAAA,OACE,0BAAAA,EACA,0BAAAC,MACK,kCAEP,OAAS,sBAAAC,MAA0B,uBACnC,OAAS,2BAAAC,MAA+B,4BAExC,SAAS,0BAA2B,IAAM,CACxC,SAAS,UAAW,IAAM,CACxB,GAAG,6BAA8B,IAAM,CAGrC,MAAMC,EADU,IAAID,EAAwB,EACvB,QAAQ,EAG7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,EAAM,EAAM,EAAM,CAAI,CAAC,CAChD,CACF,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,gEAAiE,IAAM,CAExE,MAAMC,EAAW,CACf,KAAM,WAAW,KAAK,CAAC,CAAC,EACxB,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAIMC,EADU,IAAIH,EAAwB,EACrB,cAAcE,CAAQ,EAGzCJ,EAAuBK,CAAM,EAC/B,OAAO,KAAK,mBAAmB,EAE/B,OAAOA,EAAO,KAAK,EAAE,eAAeJ,CAAkB,CAE1D,CAAC,EAED,GAAG,qCAAsC,IAAM,CAE7C,MAAMG,EAAW,CACf,KAAM,WAAW,KAAK,CACpB,EACA,GAAG,MAAc,EAAE,EAAE,KAAK,CAAI,EAC9B,GAAG,MAAc,EAAE,EAAE,KAAK,CAAI,CAChC,CAAC,EACD,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAIMC,EADU,IAAIH,EAAwB,EACrB,cAAcE,CAAQ,EAGzCJ,EAAuBK,CAAM,EAC/B,OAAOA,EAAO,KAAK,QAAQ,CAAC,EAAE,QAAQ,CACpC,EAAG,qEACH,EAAG,qEACH,EAAG,CACL,CAAC,EAED,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMD,EAAW,CACf,KAAM,WAAW,KAAK,CAAC,CAAC,EACxB,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAIMC,EADU,IAAIH,EAAwB,EACrB,cAAcE,CAAQ,EAGzCJ,EAAuBK,CAAM,EAC/B,OAAO,KAAK,mBAAmB,GAE/B,OAAOA,EAAO,KAAK,EAAE,eAAeN,CAAsB,EAC1D,OAAOM,EAAO,MAAM,aAAa,EAAE,QAAQ,IAAI,MAAM,cAAc,CAAC,EAExE,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMD,EAAW,CACf,KAAM,WAAW,KAAK,CAAC,EAAM,GAAG,MAAc,EAAE,EAAE,KAAK,CAAI,CAAC,CAAC,EAC7D,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAIMC,EADU,IAAIH,EAAwB,EACrB,cAAcE,CAAQ,EAGzCJ,EAAuBK,CAAM,EAC/B,OAAO,KAAK,mBAAmB,GAE/B,OAAOA,EAAO,KAAK,EAAE,eAAeN,CAAsB,EAC1D,OAAOM,EAAO,MAAM,aAAa,EAAE,QAAQ,IAAI,MAAM,cAAc,CAAC,EAExE,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMD,EAAW,CACf,KAAM,WAAW,KAAK,CACpB,EACA,GAAG,MAAc,EAAE,EAAE,KAAK,CAAI,EAC9B,GAAG,MAAc,EAAE,EAAE,KAAK,CAAI,CAChC,CAAC,EACD,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAIMC,EADU,IAAIH,EAAwB,EACrB,cAAcE,CAAQ,EAGzCJ,EAAuBK,CAAM,EAC/B,OAAO,KAAK,mBAAmB,GAE/B,OAAOA,EAAO,KAAK,EAAE,eAAeN,CAAsB,EAC1D,OAAOM,EAAO,MAAM,aAAa,EAAE,QAAQ,IAAI,MAAM,cAAc,CAAC,EAExE,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["InvalidStatusWordError", "isSuccessCommandResult", "EthAppCommandError", "StartTransactionCommand", "apdu", "response", "result"]
+  "sourcesContent": ["import {\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { EthAppCommandError } from \"./utils/ethAppErrors\";\nimport { StartTransactionCommand } from \"./StartTransactionCommand\";\n\ndescribe(\"StartTransactionCommand\", () => {\n  describe(\"name\", () => {\n    it(\"should be 'startTransaction'\", () => {\n      const command = new StartTransactionCommand();\n      expect(command.name).toBe(\"startTransaction\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return the raw APDU\", () => {\n      // WHEN\n      const command = new StartTransactionCommand();\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x04, 0x00, 0x02, 0x00]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return an error if the response status code is invalid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([]),\n        statusCode: Uint8Array.from([0x6d, 0x00]), // Invalid status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(EthAppCommandError);\n      }\n    });\n\n    it(\"should return the correct response\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([\n          0x01,\n          ...Array<number>(32).fill(0x02),\n          ...Array<number>(32).fill(0x03),\n        ]), // Some data\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data.extract()).toEqual({\n          r: \"0x0202020202020202020202020202020202020202020202020202020202020202\",\n          s: \"0x0303030303030303030303030303030303030303030303030303030303030303\",\n          v: 1,\n        });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return an error if v is not valid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([]), // No data\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect(result.error.originalError).toEqual(new Error(\"V is missing\"));\n      }\n    });\n\n    it(\"should return an error if r is not valid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([0x01, ...Array<number>(20).fill(0x02)]), // Invalid r\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect(result.error.originalError).toEqual(new Error(\"R is missing\"));\n      }\n    });\n\n    it(\"should return an error if s is not valid\", () => {\n      // GIVEN\n      const response = {\n        data: Uint8Array.from([\n          0x01,\n          ...Array<number>(32).fill(0x02),\n          ...Array<number>(20).fill(0x02),\n        ]), // Invalid s\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StartTransactionCommand();\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toBeInstanceOf(InvalidStatusWordError);\n        expect(result.error.originalError).toEqual(new Error(\"S is missing\"));\n      }\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["InvalidStatusWordError", "isSuccessCommandResult", "EthAppCommandError", "StartTransactionCommand", "command", "apdu", "response", "result"]
 }

package/lib/esm/internal/app-binder/command/StoreTransactionCommand.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduBuilder as t,CommandResultFactory as a}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as n}from"@ledgerhq/signer-utils";import{Maybe as s}from"purify-ts";import{ETH_APP_ERRORS as d,EthAppCommandErrorFactory as i}from"./utils/ethAppErrors";class c{constructor(r){this.args=r}errorHelper=new n(d,i);getApdu(){const{serializedTransaction:r,isFirstChunk:o}=this.args,e={cla:224,ins:4,p1:o?0:128,p2:1};return new t(e).addBufferToData(r).build()}parseResponse(r){return s.fromNullable(this.errorHelper.getError(r)).orDefault(a({data:void 0}))}}export{c as StoreTransactionCommand};
+import{ApduBuilder as t,CommandResultFactory as a}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as n}from"@ledgerhq/signer-utils";import{Maybe as s}from"purify-ts";import{ETH_APP_ERRORS as d,EthAppCommandErrorFactory as i}from"./utils/ethAppErrors";class C{constructor(r){this.args=r}name="storeTransaction";errorHelper=new n(d,i);getApdu(){const{serializedTransaction:r,isFirstChunk:o}=this.args,e={cla:224,ins:4,p1:o?0:128,p2:1};return new t(e).addBufferToData(r).build()}parseResponse(r){return s.fromNullable(this.errorHelper.getError(r)).orDefault(a({data:void 0}))}}export{C as StoreTransactionCommand};
 //# sourceMappingURL=StoreTransactionCommand.js.map

package/lib/esm/internal/app-binder/command/StoreTransactionCommand.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/StoreTransactionCommand.ts"],
-  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-transaction\n// https://github.com/LedgerHQ/generic_parser/blob/master/specs.md#sign (to be removed when the top link has been updated)\nimport {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\n\nexport type StoreTransactionCommandArgs = {\n  /**\n   * The transaction to sign in max 150 bytes chunks\n   */\n  readonly serializedTransaction: Uint8Array;\n  /**\n   * If this is the first chunk of the message\n   */\n  readonly isFirstChunk: boolean;\n};\n\n/**\n * StoreTransactionCommand is a SignTransactionCommand that is used to initiate\n * the sign transaction flow. It signature differs from the SignTransactionCommand\n * because the command does not return any data.\n */\nexport class StoreTransactionCommand\n  implements Command<void, StoreTransactionCommandArgs, EthErrorCodes>\n{\n  private readonly errorHelper = new CommandErrorHelper<void, EthErrorCodes>(\n    ETH_APP_ERRORS,\n    EthAppCommandErrorFactory,\n  );\n\n  constructor(private readonly args: StoreTransactionCommandArgs) {}\n\n  getApdu(): Apdu {\n    const { serializedTransaction, isFirstChunk } = this.args;\n\n    const signEthTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x04,\n      p1: isFirstChunk ? 0x00 : 0x80,\n      p2: 0x01,\n    };\n    const builder = new ApduBuilder(signEthTransactionArgs);\n    return builder.addBufferToData(serializedTransaction).build();\n  }\n\n  parseResponse(response: ApduResponse): CommandResult<void, EthErrorCodes> {\n    return Maybe.fromNullable(this.errorHelper.getError(response)).orDefault(\n      CommandResultFactory({ data: undefined }),\n    );\n  }\n}\n"],
-  "mappings": "AAEA,OAEE,eAAAA,EAKA,wBAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAkBA,MAAMC,CAEb,CAME,YAA6BC,EAAmC,CAAnC,UAAAA,CAAoC,CALhD,YAAc,IAAIL,EACjCE,EACAC,CACF,EAIA,SAAgB,CACd,KAAM,CAAE,sBAAAG,EAAuB,aAAAC,CAAa,EAAI,KAAK,KAE/CC,EAA0C,CAC9C,IAAK,IACL,IAAK,EACL,GAAID,EAAe,EAAO,IAC1B,GAAI,CACN,EAEA,OADgB,IAAIT,EAAYU,CAAsB,EACvC,gBAAgBF,CAAqB,EAAE,MAAM,CAC9D,CAEA,cAAcG,EAA4D,CACxE,OAAOR,EAAM,aAAa,KAAK,YAAY,SAASQ,CAAQ,CAAC,EAAE,UAC7DV,EAAqB,CAAE,KAAM,MAAU,CAAC,CAC1C,CACF,CACF",
+  "sourcesContent": ["// https://github.com/LedgerHQ/app-ethereum/blob/develop/doc/ethapp.adoc#sign-eth-transaction\n// https://github.com/LedgerHQ/generic_parser/blob/master/specs.md#sign (to be removed when the top link has been updated)\nimport {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"./utils/ethAppErrors\";\n\nexport type StoreTransactionCommandArgs = {\n  /**\n   * The transaction to sign in max 150 bytes chunks\n   */\n  readonly serializedTransaction: Uint8Array;\n  /**\n   * If this is the first chunk of the message\n   */\n  readonly isFirstChunk: boolean;\n};\n\n/**\n * StoreTransactionCommand is a SignTransactionCommand that is used to initiate\n * the sign transaction flow. It signature differs from the SignTransactionCommand\n * because the command does not return any data.\n */\nexport class StoreTransactionCommand\n  implements Command<void, StoreTransactionCommandArgs, EthErrorCodes>\n{\n  readonly name = \"storeTransaction\";\n  private readonly errorHelper = new CommandErrorHelper<void, EthErrorCodes>(\n    ETH_APP_ERRORS,\n    EthAppCommandErrorFactory,\n  );\n\n  constructor(private readonly args: StoreTransactionCommandArgs) {}\n\n  getApdu(): Apdu {\n    const { serializedTransaction, isFirstChunk } = this.args;\n\n    const signEthTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x04,\n      p1: isFirstChunk ? 0x00 : 0x80,\n      p2: 0x01,\n    };\n    const builder = new ApduBuilder(signEthTransactionArgs);\n    return builder.addBufferToData(serializedTransaction).build();\n  }\n\n  parseResponse(response: ApduResponse): CommandResult<void, EthErrorCodes> {\n    return Maybe.fromNullable(this.errorHelper.getError(response)).orDefault(\n      CommandResultFactory({ data: undefined }),\n    );\n  }\n}\n"],
+  "mappings": "AAEA,OAEE,eAAAA,EAKA,wBAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,uBAkBA,MAAMC,CAEb,CAOE,YAA6BC,EAAmC,CAAnC,UAAAA,CAAoC,CANxD,KAAO,mBACC,YAAc,IAAIL,EACjCE,EACAC,CACF,EAIA,SAAgB,CACd,KAAM,CAAE,sBAAAG,EAAuB,aAAAC,CAAa,EAAI,KAAK,KAE/CC,EAA0C,CAC9C,IAAK,IACL,IAAK,EACL,GAAID,EAAe,EAAO,IAC1B,GAAI,CACN,EAEA,OADgB,IAAIT,EAAYU,CAAsB,EACvC,gBAAgBF,CAAqB,EAAE,MAAM,CAC9D,CAEA,cAAcG,EAA4D,CACxE,OAAOR,EAAM,aAAa,KAAK,YAAY,SAASQ,CAAQ,CAAC,EAAE,UAC7DV,EAAqB,CAAE,KAAM,MAAU,CAAC,CAC1C,CACF,CACF",
   "names": ["ApduBuilder", "CommandResultFactory", "CommandErrorHelper", "Maybe", "ETH_APP_ERRORS", "EthAppCommandErrorFactory", "StoreTransactionCommand", "args", "serializedTransaction", "isFirstChunk", "signEthTransactionArgs", "response"]
 }

package/lib/esm/internal/app-binder/command/StoreTransactionCommand.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{isSuccessCommandResult as n}from"@ledgerhq/device-management-kit";import{EthAppCommandError as o}from"./utils/ethAppErrors";import{StoreTransactionCommand as t}from"./StoreTransactionCommand";describe("StoreTransactionCommand",()=>{describe("getApdu",()=>{it("should return the raw APDU for the first chunk",()=>{const e={serializedTransaction:Uint8Array.from([1,2,3]),isFirstChunk:!0},r=new t(e).getApdu();expect(r.getRawApdu()).toStrictEqual(Uint8Array.from([224,4,0,1,3,1,2,3]))}),it("should return the raw APDU for the subsequent chunk",()=>{const e={serializedTransaction:Uint8Array.from([4,5,6]),isFirstChunk:!1},r=new t(e).getApdu();expect(r.getRawApdu()).toStrictEqual(Uint8Array.from([224,4,128,1,3,4,5,6]))})}),describe("parseResponse",()=>{it("should return an error if the response status code is invalid",()=>{const e={data:Uint8Array.from([]),statusCode:Uint8Array.from([109,0])},r=new t({serializedTransaction:new Uint8Array(0),isFirstChunk:!0}).parseResponse(e);if(n(r))throw new Error("Expected error");expect(r.error).toBeInstanceOf(o)}),it("should return the correct response",()=>{const e={data:Uint8Array.from([]),statusCode:Uint8Array.from([144,0])},r=new t({serializedTransaction:new Uint8Array(0),isFirstChunk:!0}).parseResponse(e);if(n(r))expect(r.data).toBeUndefined();else throw new Error("Expected success")})})});
+import{isSuccessCommandResult as s}from"@ledgerhq/device-management-kit";import{EthAppCommandError as o}from"./utils/ethAppErrors";import{StoreTransactionCommand as t}from"./StoreTransactionCommand";describe("StoreTransactionCommand",()=>{describe("name",()=>{it("should be 'storeTransaction'",()=>{const r=new t({serializedTransaction:new Uint8Array,isFirstChunk:!0});expect(r.name).toBe("storeTransaction")})}),describe("getApdu",()=>{it("should return the raw APDU for the first chunk",()=>{const r={serializedTransaction:Uint8Array.from([1,2,3]),isFirstChunk:!0},e=new t(r).getApdu();expect(e.getRawApdu()).toStrictEqual(Uint8Array.from([224,4,0,1,3,1,2,3]))}),it("should return the raw APDU for the subsequent chunk",()=>{const r={serializedTransaction:Uint8Array.from([4,5,6]),isFirstChunk:!1},e=new t(r).getApdu();expect(e.getRawApdu()).toStrictEqual(Uint8Array.from([224,4,128,1,3,4,5,6]))})}),describe("parseResponse",()=>{it("should return an error if the response status code is invalid",()=>{const r={data:Uint8Array.from([]),statusCode:Uint8Array.from([109,0])},e=new t({serializedTransaction:new Uint8Array(0),isFirstChunk:!0}).parseResponse(r);if(s(e))throw new Error("Expected error");expect(e.error).toBeInstanceOf(o)}),it("should return the correct response",()=>{const r={data:Uint8Array.from([]),statusCode:Uint8Array.from([144,0])},e=new t({serializedTransaction:new Uint8Array(0),isFirstChunk:!0}).parseResponse(r);if(s(e))expect(e.data).toBeUndefined();else throw new Error("Expected success")})})});
 //# sourceMappingURL=StoreTransactionCommand.test.js.map

package/lib/esm/internal/app-binder/command/StoreTransactionCommand.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/StoreTransactionCommand.test.ts"],
-  "sourcesContent": ["import {\n  type ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { EthAppCommandError } from \"./utils/ethAppErrors\";\nimport {\n  StoreTransactionCommand,\n  type StoreTransactionCommandArgs,\n} from \"./StoreTransactionCommand\";\n\ndescribe(\"StoreTransactionCommand\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should return the raw APDU for the first chunk\", () => {\n      // GIVEN\n      const args: StoreTransactionCommandArgs = {\n        serializedTransaction: Uint8Array.from([0x01, 0x02, 0x03]),\n        isFirstChunk: true,\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand(args);\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x04, 0x00, 0x01, 0x03, 0x01, 0x02, 0x03]),\n      );\n    });\n\n    it(\"should return the raw APDU for the subsequent chunk\", () => {\n      // GIVEN\n      const args: StoreTransactionCommandArgs = {\n        serializedTransaction: Uint8Array.from([0x04, 0x05, 0x06]),\n        isFirstChunk: false,\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand(args);\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x04, 0x80, 0x01, 0x03, 0x04, 0x05, 0x06]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return an error if the response status code is invalid\", () => {\n      // GIVEN\n      const response: ApduResponse = {\n        data: Uint8Array.from([]),\n        statusCode: Uint8Array.from([0x6d, 0x00]), // Invalid status code\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand({\n        serializedTransaction: new Uint8Array(0),\n        isFirstChunk: true,\n      });\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        throw new Error(\"Expected error\");\n      } else {\n        expect(result.error).toBeInstanceOf(EthAppCommandError);\n      }\n    });\n\n    it(\"should return the correct response\", () => {\n      // GIVEN\n      const response: ApduResponse = {\n        data: Uint8Array.from([]),\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand({\n        serializedTransaction: new Uint8Array(0),\n        isFirstChunk: true,\n      });\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toBeUndefined();\n      } else {\n        throw new Error(\"Expected success\");\n      }\n    });\n  });\n});\n"],
-  "mappings": "AAAA,OAEE,0BAAAA,MACK,kCAEP,OAAS,sBAAAC,MAA0B,uBACnC,OACE,2BAAAC,MAEK,4BAEP,SAAS,0BAA2B,IAAM,CACxC,SAAS,UAAW,IAAM,CACxB,GAAG,iDAAkD,IAAM,CAEzD,MAAMC,EAAoC,CACxC,sBAAuB,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,EACzD,aAAc,EAChB,EAIMC,EADU,IAAIF,EAAwBC,CAAI,EAC3B,QAAQ,EAG7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,CAClE,CACF,CAAC,EAED,GAAG,sDAAuD,IAAM,CAE9D,MAAMD,EAAoC,CACxC,sBAAuB,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,EACzD,aAAc,EAChB,EAIMC,EADU,IAAIF,EAAwBC,CAAI,EAC3B,QAAQ,EAG7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,EAAM,IAAM,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,CAClE,CACF,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,gEAAiE,IAAM,CAExE,MAAMC,EAAyB,CAC7B,KAAM,WAAW,KAAK,CAAC,CAAC,EACxB,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAOMC,EAJU,IAAIJ,EAAwB,CAC1C,sBAAuB,IAAI,WAAW,CAAC,EACvC,aAAc,EAChB,CAAC,EACsB,cAAcG,CAAQ,EAG7C,GAAIL,EAAuBM,CAAM,EAC/B,MAAM,IAAI,MAAM,gBAAgB,EAEhC,OAAOA,EAAO,KAAK,EAAE,eAAeL,CAAkB,CAE1D,CAAC,EAED,GAAG,qCAAsC,IAAM,CAE7C,MAAMI,EAAyB,CAC7B,KAAM,WAAW,KAAK,CAAC,CAAC,EACxB,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAOMC,EAJU,IAAIJ,EAAwB,CAC1C,sBAAuB,IAAI,WAAW,CAAC,EACvC,aAAc,EAChB,CAAC,EACsB,cAAcG,CAAQ,EAG7C,GAAIL,EAAuBM,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,MAElC,OAAM,IAAI,MAAM,kBAAkB,CAEtC,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["isSuccessCommandResult", "EthAppCommandError", "StoreTransactionCommand", "args", "apdu", "response", "result"]
+  "sourcesContent": ["import {\n  type ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { EthAppCommandError } from \"./utils/ethAppErrors\";\nimport {\n  StoreTransactionCommand,\n  type StoreTransactionCommandArgs,\n} from \"./StoreTransactionCommand\";\n\ndescribe(\"StoreTransactionCommand\", () => {\n  describe(\"name\", () => {\n    it(\"should be 'storeTransaction'\", () => {\n      const command = new StoreTransactionCommand({\n        serializedTransaction: new Uint8Array(),\n        isFirstChunk: true,\n      });\n      expect(command.name).toBe(\"storeTransaction\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return the raw APDU for the first chunk\", () => {\n      // GIVEN\n      const args: StoreTransactionCommandArgs = {\n        serializedTransaction: Uint8Array.from([0x01, 0x02, 0x03]),\n        isFirstChunk: true,\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand(args);\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x04, 0x00, 0x01, 0x03, 0x01, 0x02, 0x03]),\n      );\n    });\n\n    it(\"should return the raw APDU for the subsequent chunk\", () => {\n      // GIVEN\n      const args: StoreTransactionCommandArgs = {\n        serializedTransaction: Uint8Array.from([0x04, 0x05, 0x06]),\n        isFirstChunk: false,\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand(args);\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x04, 0x80, 0x01, 0x03, 0x04, 0x05, 0x06]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return an error if the response status code is invalid\", () => {\n      // GIVEN\n      const response: ApduResponse = {\n        data: Uint8Array.from([]),\n        statusCode: Uint8Array.from([0x6d, 0x00]), // Invalid status code\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand({\n        serializedTransaction: new Uint8Array(0),\n        isFirstChunk: true,\n      });\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        throw new Error(\"Expected error\");\n      } else {\n        expect(result.error).toBeInstanceOf(EthAppCommandError);\n      }\n    });\n\n    it(\"should return the correct response\", () => {\n      // GIVEN\n      const response: ApduResponse = {\n        data: Uint8Array.from([]),\n        statusCode: Uint8Array.from([0x90, 0x00]), // Success status code\n      };\n\n      // WHEN\n      const command = new StoreTransactionCommand({\n        serializedTransaction: new Uint8Array(0),\n        isFirstChunk: true,\n      });\n      const result = command.parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toBeUndefined();\n      } else {\n        throw new Error(\"Expected success\");\n      }\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAEE,0BAAAA,MACK,kCAEP,OAAS,sBAAAC,MAA0B,uBACnC,OACE,2BAAAC,MAEK,4BAEP,SAAS,0BAA2B,IAAM,CACxC,SAAS,OAAQ,IAAM,CACrB,GAAG,+BAAgC,IAAM,CACvC,MAAMC,EAAU,IAAID,EAAwB,CAC1C,sBAAuB,IAAI,WAC3B,aAAc,EAChB,CAAC,EACD,OAAOC,EAAQ,IAAI,EAAE,KAAK,kBAAkB,CAC9C,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,iDAAkD,IAAM,CAEzD,MAAMC,EAAoC,CACxC,sBAAuB,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,EACzD,aAAc,EAChB,EAIMC,EADU,IAAIH,EAAwBE,CAAI,EAC3B,QAAQ,EAG7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,CAClE,CACF,CAAC,EAED,GAAG,sDAAuD,IAAM,CAE9D,MAAMD,EAAoC,CACxC,sBAAuB,WAAW,KAAK,CAAC,EAAM,EAAM,CAAI,CAAC,EACzD,aAAc,EAChB,EAIMC,EADU,IAAIH,EAAwBE,CAAI,EAC3B,QAAQ,EAG7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,EAAM,IAAM,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,CAClE,CACF,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,gEAAiE,IAAM,CAExE,MAAMC,EAAyB,CAC7B,KAAM,WAAW,KAAK,CAAC,CAAC,EACxB,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAOMC,EAJU,IAAIL,EAAwB,CAC1C,sBAAuB,IAAI,WAAW,CAAC,EACvC,aAAc,EAChB,CAAC,EACsB,cAAcI,CAAQ,EAG7C,GAAIN,EAAuBO,CAAM,EAC/B,MAAM,IAAI,MAAM,gBAAgB,EAEhC,OAAOA,EAAO,KAAK,EAAE,eAAeN,CAAkB,CAE1D,CAAC,EAED,GAAG,qCAAsC,IAAM,CAE7C,MAAMK,EAAyB,CAC7B,KAAM,WAAW,KAAK,CAAC,CAAC,EACxB,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,CAC1C,EAOMC,EAJU,IAAIL,EAAwB,CAC1C,sBAAuB,IAAI,WAAW,CAAC,EACvC,aAAc,EAChB,CAAC,EACsB,cAAcI,CAAQ,EAG7C,GAAIN,EAAuBO,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,MAElC,OAAM,IAAI,MAAM,kBAAkB,CAEtC,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["isSuccessCommandResult", "EthAppCommandError", "StoreTransactionCommand", "command", "args", "apdu", "response", "result"]
 }

package/lib/esm/internal/app-binder/command/Web3CheckOptInCommand.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ApduBuilder as t,ApduParser as n,CommandResultFactory as o}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as p}from"@ledgerhq/signer-utils";import{Maybe as d}from"purify-ts";import{ETH_APP_ERRORS as a,EthAppCommandErrorFactory as m}from"../../app-binder/command/utils/ethAppErrors";class c{errorHelper=new p(a,m);constructor(){}getApdu(){const e={cla:224,ins:50,p1:1,p2:0};return new t(e).build()}parseResponse(e){return d.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const r=new n(e).extract8BitUInt();return r===void 0?o({data:{enabled:!1}}):o({data:{enabled:r!==0}})})}}export{c as Web3CheckOptInCommand};
+import{ApduBuilder as t,ApduParser as n,CommandResultFactory as o}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as p}from"@ledgerhq/signer-utils";import{Maybe as d}from"purify-ts";import{ETH_APP_ERRORS as a,EthAppCommandErrorFactory as m}from"../../app-binder/command/utils/ethAppErrors";class c{name="web3CheckOptIn";errorHelper=new p(a,m);constructor(){}getApdu(){const e={cla:224,ins:50,p1:1,p2:0};return new t(e).build()}parseResponse(e){return d.fromNullable(this.errorHelper.getError(e)).orDefaultLazy(()=>{const r=new n(e).extract8BitUInt();return r===void 0?o({data:{enabled:!1}}):o({data:{enabled:r!==0}})})}}export{c as Web3CheckOptInCommand};
 //# sourceMappingURL=Web3CheckOptInCommand.js.map

package/lib/esm/internal/app-binder/command/Web3CheckOptInCommand.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/Web3CheckOptInCommand.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} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"@internal/app-binder/command/utils/ethAppErrors\";\n\nexport type Web3CheckOptInCommandResponse = {\n  enabled: boolean;\n};\n\n/**\n * The command that trigger web3check opt-in on device.\n */\nexport class Web3CheckOptInCommand\n  implements Command<Web3CheckOptInCommandResponse, void, EthErrorCodes>\n{\n  private readonly errorHelper = new CommandErrorHelper<\n    Web3CheckOptInCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  constructor() {}\n\n  getApdu(): Apdu {\n    const apduBuilderArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x32,\n      p1: 0x01,\n      p2: 0x00,\n    };\n\n    return new ApduBuilder(apduBuilderArgs).build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<Web3CheckOptInCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const enabled = new ApduParser(response).extract8BitUInt();\n      if (enabled === undefined) {\n        return CommandResultFactory({ data: { enabled: false } });\n      }\n      return CommandResultFactory({ data: { enabled: enabled !== 0 } });\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,kDASA,MAAMC,CAEb,CACmB,YAAc,IAAIJ,EAGjCE,EAAgBC,CAAyB,EAE3C,aAAc,CAAC,CAEf,SAAgB,CACd,MAAME,EAAmC,CACvC,IAAK,IACL,IAAK,GACL,GAAI,EACJ,GAAI,CACN,EAEA,OAAO,IAAIR,EAAYQ,CAAe,EAAE,MAAM,CAChD,CAEA,cACEC,EAC6D,CAC7D,OAAOL,EAAM,aACX,KAAK,YAAY,SAASK,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAU,IAAIT,EAAWQ,CAAQ,EAAE,gBAAgB,EACzD,OAAIC,IAAY,OACPR,EAAqB,CAAE,KAAM,CAAE,QAAS,EAAM,CAAE,CAAC,EAEnDA,EAAqB,CAAE,KAAM,CAAE,QAASQ,IAAY,CAAE,CAAE,CAAC,CAClE,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} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  ETH_APP_ERRORS,\n  EthAppCommandErrorFactory,\n  type EthErrorCodes,\n} from \"@internal/app-binder/command/utils/ethAppErrors\";\n\nexport type Web3CheckOptInCommandResponse = {\n  enabled: boolean;\n};\n\n/**\n * The command that trigger web3check opt-in on device.\n */\nexport class Web3CheckOptInCommand\n  implements Command<Web3CheckOptInCommandResponse, void, EthErrorCodes>\n{\n  readonly name = \"web3CheckOptIn\";\n  private readonly errorHelper = new CommandErrorHelper<\n    Web3CheckOptInCommandResponse,\n    EthErrorCodes\n  >(ETH_APP_ERRORS, EthAppCommandErrorFactory);\n\n  constructor() {}\n\n  getApdu(): Apdu {\n    const apduBuilderArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x32,\n      p1: 0x01,\n      p2: 0x00,\n    };\n\n    return new ApduBuilder(apduBuilderArgs).build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<Web3CheckOptInCommandResponse, EthErrorCodes> {\n    return Maybe.fromNullable(\n      this.errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const enabled = new ApduParser(response).extract8BitUInt();\n      if (enabled === undefined) {\n        return CommandResultFactory({ data: { enabled: false } });\n      }\n      return CommandResultFactory({ data: { enabled: enabled !== 0 } });\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,kDASA,MAAMC,CAEb,CACW,KAAO,iBACC,YAAc,IAAIJ,EAGjCE,EAAgBC,CAAyB,EAE3C,aAAc,CAAC,CAEf,SAAgB,CACd,MAAME,EAAmC,CACvC,IAAK,IACL,IAAK,GACL,GAAI,EACJ,GAAI,CACN,EAEA,OAAO,IAAIR,EAAYQ,CAAe,EAAE,MAAM,CAChD,CAEA,cACEC,EAC6D,CAC7D,OAAOL,EAAM,aACX,KAAK,YAAY,SAASK,CAAQ,CACpC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAU,IAAIT,EAAWQ,CAAQ,EAAE,gBAAgB,EACzD,OAAIC,IAAY,OACPR,EAAqB,CAAE,KAAM,CAAE,QAAS,EAAM,CAAE,CAAC,EAEnDA,EAAqB,CAAE,KAAM,CAAE,QAASQ,IAAY,CAAE,CAAE,CAAC,CAClE,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "CommandErrorHelper", "Maybe", "ETH_APP_ERRORS", "EthAppCommandErrorFactory", "Web3CheckOptInCommand", "apduBuilderArgs", "response", "enabled"]
 }

package/lib/esm/internal/app-binder/command/Web3CheckOptInCommand.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{isSuccessCommandResult as r}from"@ledgerhq/device-management-kit";import{Web3CheckOptInCommand as s}from"../../app-binder/command/Web3CheckOptInCommand";describe("Web3CheckOptInCommand",()=>{describe("getApdu",()=>{it("should return the raw APDU",()=>{const e=new s().getApdu();expect(e.getRawApdu()).toStrictEqual(Uint8Array.from([224,50,1,0,0]))})}),describe("parseResponse",()=>{it("should return true",()=>{const t={statusCode:Uint8Array.from([144,0]),data:new Uint8Array([1])},e=new s().parseResponse(t);r(e)?expect(e.data).toStrictEqual({enabled:!0}):assert.fail("Expected a success")}),it("should return false",()=>{const t={statusCode:Uint8Array.from([144,0]),data:new Uint8Array([0])},e=new s().parseResponse(t);r(e)?expect(e.data).toStrictEqual({enabled:!1}):assert.fail("Expected a success")}),it("should return false if missing",()=>{const t={statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])},e=new s().parseResponse(t);r(e)?expect(e.data).toStrictEqual({enabled:!1}):assert.fail("Expected a success")}),it("should return an error if the device is locked",()=>{const t={statusCode:Uint8Array.from([85,21]),data:new Uint8Array},e=new s().parseResponse(t);r(e)?assert.fail("Expected an error"):expect(e.error).toEqual(expect.objectContaining({errorCode:"5515",message:"Device is locked."}))})})});
+import{isSuccessCommandResult as r}from"@ledgerhq/device-management-kit";import{Web3CheckOptInCommand as s}from"../../app-binder/command/Web3CheckOptInCommand";describe("Web3CheckOptInCommand",()=>{describe("name",()=>{it("should be 'web3CheckOptIn'",()=>{const t=new s;expect(t.name).toBe("web3CheckOptIn")})}),describe("getApdu",()=>{it("should return the raw APDU",()=>{const e=new s().getApdu();expect(e.getRawApdu()).toStrictEqual(Uint8Array.from([224,50,1,0,0]))})}),describe("parseResponse",()=>{it("should return true",()=>{const t={statusCode:Uint8Array.from([144,0]),data:new Uint8Array([1])},e=new s().parseResponse(t);r(e)?expect(e.data).toStrictEqual({enabled:!0}):assert.fail("Expected a success")}),it("should return false",()=>{const t={statusCode:Uint8Array.from([144,0]),data:new Uint8Array([0])},e=new s().parseResponse(t);r(e)?expect(e.data).toStrictEqual({enabled:!1}):assert.fail("Expected a success")}),it("should return false if missing",()=>{const t={statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])},e=new s().parseResponse(t);r(e)?expect(e.data).toStrictEqual({enabled:!1}):assert.fail("Expected a success")}),it("should return an error if the device is locked",()=>{const t={statusCode:Uint8Array.from([85,21]),data:new Uint8Array},e=new s().parseResponse(t);r(e)?assert.fail("Expected an error"):expect(e.error).toEqual(expect.objectContaining({errorCode:"5515",message:"Device is locked."}))})})});
 //# sourceMappingURL=Web3CheckOptInCommand.test.js.map

package/lib/esm/internal/app-binder/command/Web3CheckOptInCommand.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/Web3CheckOptInCommand.test.ts"],
-  "sourcesContent": ["import { isSuccessCommandResult } from \"@ledgerhq/device-management-kit\";\n\nimport { Web3CheckOptInCommand } from \"@internal/app-binder/command/Web3CheckOptInCommand\";\n\ndescribe(\"Web3CheckOptInCommand\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should return the raw APDU\", () => {\n      // GIVEN\n      const command = new Web3CheckOptInCommand();\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x32, 0x01, 0x00, 0x00]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return true\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([0x01]),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toStrictEqual({ enabled: true });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return false\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([0x00]),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toStrictEqual({ enabled: false });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return false if missing\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toStrictEqual({ enabled: false });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return an error if the device is locked\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x55, 0x15]),\n        data: new Uint8Array(),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toEqual(\n          expect.objectContaining({\n            errorCode: \"5515\",\n            message: \"Device is locked.\",\n          }),\n        );\n      }\n    });\n  });\n});\n"],
-  "mappings": "AAAA,OAAS,0BAAAA,MAA8B,kCAEvC,OAAS,yBAAAC,MAA6B,qDAEtC,SAAS,wBAAyB,IAAM,CACtC,SAAS,UAAW,IAAM,CACxB,GAAG,6BAA8B,IAAM,CAKrC,MAAMC,EAHU,IAAID,EAAsB,EAGrB,QAAQ,EAG7B,OAAOC,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,GAAM,EAAM,EAAM,CAAI,CAAC,CAChD,CACF,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,qBAAsB,IAAM,CAE7B,MAAMC,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAI,CAAC,CAC7B,EAGMC,EAAS,IAAIH,EAAsB,EAAE,cAAcE,CAAQ,EAG7DH,EAAuBI,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,CAAE,QAAS,EAAK,CAAC,EAEnD,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,sBAAuB,IAAM,CAE9B,MAAMD,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAI,CAAC,CAC7B,EAGMC,EAAS,IAAIH,EAAsB,EAAE,cAAcE,CAAQ,EAG7DH,EAAuBI,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,CAAE,QAAS,EAAM,CAAC,EAEpD,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,iCAAkC,IAAM,CAEzC,MAAMD,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,EAGMC,EAAS,IAAIH,EAAsB,EAAE,cAAcE,CAAQ,EAG7DH,EAAuBI,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,CAAE,QAAS,EAAM,CAAC,EAEpD,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,iDAAkD,IAAM,CAEzD,MAAMD,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,GAAM,EAAI,CAAC,EACxC,KAAM,IAAI,UACZ,EAGMC,EAAS,IAAIH,EAAsB,EAAE,cAAcE,CAAQ,EAG7DH,EAAuBI,CAAM,EAC/B,OAAO,KAAK,mBAAmB,EAE/B,OAAOA,EAAO,KAAK,EAAE,QACnB,OAAO,iBAAiB,CACtB,UAAW,OACX,QAAS,mBACX,CAAC,CACH,CAEJ,CAAC,CACH,CAAC,CACH,CAAC",
-  "names": ["isSuccessCommandResult", "Web3CheckOptInCommand", "apdu", "response", "result"]
+  "sourcesContent": ["import { isSuccessCommandResult } from \"@ledgerhq/device-management-kit\";\n\nimport { Web3CheckOptInCommand } from \"@internal/app-binder/command/Web3CheckOptInCommand\";\n\ndescribe(\"Web3CheckOptInCommand\", () => {\n  describe(\"name\", () => {\n    it(\"should be 'web3CheckOptIn'\", () => {\n      const command = new Web3CheckOptInCommand();\n      expect(command.name).toBe(\"web3CheckOptIn\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return the raw APDU\", () => {\n      // GIVEN\n      const command = new Web3CheckOptInCommand();\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.getRawApdu()).toStrictEqual(\n        Uint8Array.from([0xe0, 0x32, 0x01, 0x00, 0x00]),\n      );\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return true\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([0x01]),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toStrictEqual({ enabled: true });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return false\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([0x00]),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toStrictEqual({ enabled: false });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return false if missing\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: new Uint8Array([]),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toStrictEqual({ enabled: false });\n      } else {\n        assert.fail(\"Expected a success\");\n      }\n    });\n\n    it(\"should return an error if the device is locked\", () => {\n      // GIVEN\n      const response = {\n        statusCode: Uint8Array.from([0x55, 0x15]),\n        data: new Uint8Array(),\n      };\n\n      // WHEN\n      const result = new Web3CheckOptInCommand().parseResponse(response);\n\n      // THEN\n      if (isSuccessCommandResult(result)) {\n        assert.fail(\"Expected an error\");\n      } else {\n        expect(result.error).toEqual(\n          expect.objectContaining({\n            errorCode: \"5515\",\n            message: \"Device is locked.\",\n          }),\n        );\n      }\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,0BAAAA,MAA8B,kCAEvC,OAAS,yBAAAC,MAA6B,qDAEtC,SAAS,wBAAyB,IAAM,CACtC,SAAS,OAAQ,IAAM,CACrB,GAAG,6BAA8B,IAAM,CACrC,MAAMC,EAAU,IAAID,EACpB,OAAOC,EAAQ,IAAI,EAAE,KAAK,gBAAgB,CAC5C,CAAC,CACH,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,6BAA8B,IAAM,CAKrC,MAAMC,EAHU,IAAIF,EAAsB,EAGrB,QAAQ,EAG7B,OAAOE,EAAK,WAAW,CAAC,EAAE,cACxB,WAAW,KAAK,CAAC,IAAM,GAAM,EAAM,EAAM,CAAI,CAAC,CAChD,CACF,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,qBAAsB,IAAM,CAE7B,MAAMC,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAI,CAAC,CAC7B,EAGMC,EAAS,IAAIJ,EAAsB,EAAE,cAAcG,CAAQ,EAG7DJ,EAAuBK,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,CAAE,QAAS,EAAK,CAAC,EAEnD,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,sBAAuB,IAAM,CAE9B,MAAMD,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAI,CAAC,CAC7B,EAGMC,EAAS,IAAIJ,EAAsB,EAAE,cAAcG,CAAQ,EAG7DJ,EAAuBK,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,CAAE,QAAS,EAAM,CAAC,EAEpD,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,iCAAkC,IAAM,CAEzC,MAAMD,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,EAGMC,EAAS,IAAIJ,EAAsB,EAAE,cAAcG,CAAQ,EAG7DJ,EAAuBK,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,cAAc,CAAE,QAAS,EAAM,CAAC,EAEpD,OAAO,KAAK,oBAAoB,CAEpC,CAAC,EAED,GAAG,iDAAkD,IAAM,CAEzD,MAAMD,EAAW,CACf,WAAY,WAAW,KAAK,CAAC,GAAM,EAAI,CAAC,EACxC,KAAM,IAAI,UACZ,EAGMC,EAAS,IAAIJ,EAAsB,EAAE,cAAcG,CAAQ,EAG7DJ,EAAuBK,CAAM,EAC/B,OAAO,KAAK,mBAAmB,EAE/B,OAAOA,EAAO,KAAK,EAAE,QACnB,OAAO,iBAAiB,CACtB,UAAW,OACX,QAAS,mBACX,CAAC,CACH,CAEJ,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["isSuccessCommandResult", "Web3CheckOptInCommand", "command", "apdu", "response", "result"]
 }