npm - @ledgerhq/device-signer-kit-bitcoin - Versions diffs - 1.0.0 → 1.0.2 - Mend

@ledgerhq/device-signer-kit-bitcoin 1.0.0 → 1.0.2

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 (418) hide show

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/RegisterWalletAddressCommand.ts"],
-  "sourcesContent": ["import {\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  BTC_APP_ERRORS,\n  BtcAppCommandErrorFactory,\n  type BtcErrorCodes,\n} from \"@internal/app-binder/command/utils/bitcoinAppErrors\";\nimport { PROTOCOL_VERSION } from \"@internal/app-binder/command/utils/constants\";\nimport { BtcCommandUtils } from \"@internal/utils/BtcCommandUtils\";\n\nexport type RegisterWalletAddressCommandArgs = {\n  walletPolicy: Uint8Array;\n};\n\ntype RegisterWalletAddressCommandResponse = {\n  walletId: Uint8Array;\n  walletHmac: Uint8Array;\n};\n\nconst RESPONSE_BUFFER_LENGTH = 32;\n\nexport class RegisterWalletAddressCommand\n  implements\n    Command<\n      RegisterWalletAddressCommandResponse,\n      RegisterWalletAddressCommandArgs,\n      BtcErrorCodes\n    >\n{\n  constructor(\n    private readonly _args: RegisterWalletAddressCommandArgs,\n    private readonly _errorHelper = new CommandErrorHelper<\n      RegisterWalletAddressCommandResponse,\n      BtcErrorCodes\n    >(\n      BTC_APP_ERRORS,\n      BtcAppCommandErrorFactory,\n      BtcCommandUtils.isSuccessResponse,\n    ),\n  ) {}\n\n  getApdu() {\n    const builder = new ApduBuilder({\n      cla: 0xe1,\n      ins: 0x02,\n      p1: 0x00,\n      p2: PROTOCOL_VERSION,\n    });\n    const { walletPolicy } = this._args;\n\n    return builder.addBufferToData(walletPolicy).build();\n  }\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<RegisterWalletAddressCommandResponse, BtcErrorCodes> {\n    return Maybe.fromNullable(\n      this._errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(response);\n\n      const walletId = parser.extractFieldByLength(RESPONSE_BUFFER_LENGTH);\n      const walletHmac = parser.extractFieldByLength(RESPONSE_BUFFER_LENGTH);\n      if (!walletId || !walletHmac) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"Data mismatch\"),\n        });\n      }\n      return CommandResultFactory({\n        data: {\n          walletId,\n          walletHmac,\n        },\n      });\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OACE,eAAAA,EACA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,sDACP,OAAS,oBAAAC,MAAwB,+CACjC,OAAS,mBAAAC,MAAuB,kCAWhC,MAAMC,EAAyB,GAExB,MAAMC,CAOb,CACE,YACmBC,EACAC,EAAe,IAAIT,EAIlCE,EACAC,EACAE,EAAgB,iBAClB,EACA,CATiB,WAAAG,EACA,kBAAAC,CAQhB,CAEH,SAAU,CACR,MAAMC,EAAU,IAAId,EAAY,CAC9B,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAIQ,CACN,CAAC,EACK,CAAE,aAAAO,CAAa,EAAI,KAAK,MAE9B,OAAOD,EAAQ,gBAAgBC,CAAY,EAAE,MAAM,CACrD,CACA,cACEC,EACoE,CACpE,OAAOX,EAAM,aACX,KAAK,aAAa,SAASW,CAAQ,CACrC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIhB,EAAWe,CAAQ,EAEhCE,EAAWD,EAAO,qBAAqBP,CAAsB,EAC7DS,EAAaF,EAAO,qBAAqBP,CAAsB,EACrE,MAAI,CAACQ,GAAY,CAACC,EACTjB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,eAAe,CACnD,CAAC,EAEID,EAAqB,CAC1B,KAAM,CACJ,SAAAgB,EACA,WAAAC,CACF,CACF,CAAC,CACH,CAAC,CACH,CACF",
+  "sourcesContent": ["import {\n  ApduBuilder,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { CommandErrorHelper } from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport {\n  BTC_APP_ERRORS,\n  BtcAppCommandErrorFactory,\n  type BtcErrorCodes,\n} from \"@internal/app-binder/command/utils/bitcoinAppErrors\";\nimport { PROTOCOL_VERSION } from \"@internal/app-binder/command/utils/constants\";\nimport { BtcCommandUtils } from \"@internal/utils/BtcCommandUtils\";\n\nexport type RegisterWalletAddressCommandArgs = {\n  walletPolicy: Uint8Array;\n};\n\ntype RegisterWalletAddressCommandResponse = {\n  walletId: Uint8Array;\n  walletHmac: Uint8Array;\n};\n\nconst RESPONSE_BUFFER_LENGTH = 32;\n\nexport class RegisterWalletAddressCommand\n  implements\n    Command<\n      RegisterWalletAddressCommandResponse,\n      RegisterWalletAddressCommandArgs,\n      BtcErrorCodes\n    >\n{\n  readonly name = \"registerWalletAddress\";\n  constructor(\n    private readonly _args: RegisterWalletAddressCommandArgs,\n    private readonly _errorHelper = new CommandErrorHelper<\n      RegisterWalletAddressCommandResponse,\n      BtcErrorCodes\n    >(\n      BTC_APP_ERRORS,\n      BtcAppCommandErrorFactory,\n      BtcCommandUtils.isSuccessResponse,\n    ),\n  ) {}\n\n  getApdu() {\n    const builder = new ApduBuilder({\n      cla: 0xe1,\n      ins: 0x02,\n      p1: 0x00,\n      p2: PROTOCOL_VERSION,\n    });\n    const { walletPolicy } = this._args;\n\n    return builder.addBufferToData(walletPolicy).build();\n  }\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<RegisterWalletAddressCommandResponse, BtcErrorCodes> {\n    return Maybe.fromNullable(\n      this._errorHelper.getError(response),\n    ).orDefaultLazy(() => {\n      const parser = new ApduParser(response);\n\n      const walletId = parser.extractFieldByLength(RESPONSE_BUFFER_LENGTH);\n      const walletHmac = parser.extractFieldByLength(RESPONSE_BUFFER_LENGTH);\n      if (!walletId || !walletHmac) {\n        return CommandResultFactory({\n          error: new InvalidStatusWordError(\"Data mismatch\"),\n        });\n      }\n      return CommandResultFactory({\n        data: {\n          walletId,\n          walletHmac,\n        },\n      });\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OACE,eAAAA,EACA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,sDACP,OAAS,oBAAAC,MAAwB,+CACjC,OAAS,mBAAAC,MAAuB,kCAWhC,MAAMC,EAAyB,GAExB,MAAMC,CAOb,CAEE,YACmBC,EACAC,EAAe,IAAIT,EAIlCE,EACAC,EACAE,EAAgB,iBAClB,EACA,CATiB,WAAAG,EACA,kBAAAC,CAQhB,CAXM,KAAO,wBAahB,SAAU,CACR,MAAMC,EAAU,IAAId,EAAY,CAC9B,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAIQ,CACN,CAAC,EACK,CAAE,aAAAO,CAAa,EAAI,KAAK,MAE9B,OAAOD,EAAQ,gBAAgBC,CAAY,EAAE,MAAM,CACrD,CACA,cACEC,EACoE,CACpE,OAAOX,EAAM,aACX,KAAK,aAAa,SAASW,CAAQ,CACrC,EAAE,cAAc,IAAM,CACpB,MAAMC,EAAS,IAAIhB,EAAWe,CAAQ,EAEhCE,EAAWD,EAAO,qBAAqBP,CAAsB,EAC7DS,EAAaF,EAAO,qBAAqBP,CAAsB,EACrE,MAAI,CAACQ,GAAY,CAACC,EACTjB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,eAAe,CACnD,CAAC,EAEID,EAAqB,CAC1B,KAAM,CACJ,SAAAgB,EACA,WAAAC,CACF,CACF,CAAC,CACH,CAAC,CACH,CACF",
   "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "CommandErrorHelper", "Maybe", "BTC_APP_ERRORS", "BtcAppCommandErrorFactory", "PROTOCOL_VERSION", "BtcCommandUtils", "RESPONSE_BUFFER_LENGTH", "RegisterWalletAddressCommand", "_args", "_errorHelper", "builder", "walletPolicy", "response", "parser", "walletId", "walletHmac"]
 }

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

@@ -1,2 +1,2 @@
-import{ApduResponse as a,CommandResultFactory as n,InvalidStatusWordError as d,isSuccessCommandResult as r}from"@ledgerhq/device-management-kit";import{RegisterWalletAddressCommand as o}from"../../app-binder/command/RegisterWalletAddressCommand";const l=Uint8Array.from([124,103,232,79,153,116,70,113,20,147,239,139,116,112,177,15,96,75,2,210,88,79,160,68,111,206,247,217,137,131,227,220]),i=2,f=Uint8Array.from([75,197,70,127,36,147,133,178,158,91,142,201,251,36,204,101,163,113,11,26,38,210,141,233,245,196,243,244,93,214,84,193]),A=Uint8Array.from([2,12,67,111,108,100,32,115,116,111,114,97,103,101,30]),m=2,t=Uint8Array.from([m].concat(...A).concat(...l).concat([i]).concat(...f)),u=Uint8Array.from([225,2,0,1,81].concat(...t)),c=Uint8Array.from([29,21,14,212,37,168,113,165,202,126,44,85,219,27,50,149,193,253,151,20,127,208,167,177,136,212,50,127,75,167,64,42,250,115,227,97,25,50,79,190,76,193,202,148,170,132,44,98,97,82,109,68,17,42,34,22,75,197,124,51,53,16,43,4]);describe("RegisterWalletAddressCommand",()=>{describe("getApdu",()=>{it("should send the correct APDU",()=>{const x=new o({walletPolicy:t});expect(x.getApdu().getRawApdu()).toEqual(u)})}),describe("parseResponse",()=>{it("should parse the response correctly",()=>{const x=new o({walletPolicy:t}),e=new a({statusCode:new Uint8Array([144,0]),data:c});expect(x.parseResponse(e)).toEqual(n({data:{walletId:c.slice(0,32),walletHmac:c.slice(32)}}))}),it("should return an error if the response is not successful",()=>{const x=new o({walletPolicy:t}),e=new a({statusCode:Uint8Array.from([109,0]),data:new Uint8Array(0)}),s=x.parseResponse(e);expect(r(s)).toBe(!1)}),it("should return an error if the response is too short",()=>{const x=new o({walletPolicy:t}),e=new a({data:c.slice(0,2),statusCode:new Uint8Array([144,0])}),s=x.parseResponse(e);r(s)?fail("Expected an error, but the result was successful"):expect(s.error).toEqual(new d("Data mismatch"))})})});
+import{ApduResponse as o,CommandResultFactory as n,InvalidStatusWordError as d,isSuccessCommandResult as c}from"@ledgerhq/device-management-kit";import{RegisterWalletAddressCommand as s}from"../../app-binder/command/RegisterWalletAddressCommand";const l=Uint8Array.from([124,103,232,79,153,116,70,113,20,147,239,139,116,112,177,15,96,75,2,210,88,79,160,68,111,206,247,217,137,131,227,220]),i=2,f=Uint8Array.from([75,197,70,127,36,147,133,178,158,91,142,201,251,36,204,101,163,113,11,26,38,210,141,233,245,196,243,244,93,214,84,193]),m=Uint8Array.from([2,12,67,111,108,100,32,115,116,111,114,97,103,101,30]),A=2,e=Uint8Array.from([A].concat(...m).concat(...l).concat([i]).concat(...f)),u=Uint8Array.from([225,2,0,1,81].concat(...e)),a=Uint8Array.from([29,21,14,212,37,168,113,165,202,126,44,85,219,27,50,149,193,253,151,20,127,208,167,177,136,212,50,127,75,167,64,42,250,115,227,97,25,50,79,190,76,193,202,148,170,132,44,98,97,82,109,68,17,42,34,22,75,197,124,51,53,16,43,4]);describe("RegisterWalletAddressCommand",()=>{describe("name",()=>{it("should be 'registerWalletAddress'",()=>{const x=new s({walletPolicy:e});expect(x.name).toBe("registerWalletAddress")})}),describe("getApdu",()=>{it("should send the correct APDU",()=>{const x=new s({walletPolicy:e});expect(x.getApdu().getRawApdu()).toEqual(u)})}),describe("parseResponse",()=>{it("should parse the response correctly",()=>{const x=new s({walletPolicy:e}),t=new o({statusCode:new Uint8Array([144,0]),data:a});expect(x.parseResponse(t)).toEqual(n({data:{walletId:a.slice(0,32),walletHmac:a.slice(32)}}))}),it("should return an error if the response is not successful",()=>{const x=new s({walletPolicy:e}),t=new o({statusCode:Uint8Array.from([109,0]),data:new Uint8Array(0)}),r=x.parseResponse(t);expect(c(r)).toBe(!1)}),it("should return an error if the response is too short",()=>{const x=new s({walletPolicy:e}),t=new o({data:a.slice(0,2),statusCode:new Uint8Array([144,0])}),r=x.parseResponse(t);c(r)?assert.fail("Expected an error, but the result was successful"):expect(r.error).toEqual(new d("Data mismatch"))})})});
 //# sourceMappingURL=RegisterWalletAddressCommand.test.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/RegisterWalletAddressCommand.test.ts"],
-  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { RegisterWalletAddressCommand } from \"@internal/app-binder/command/RegisterWalletAddressCommand\";\n\nconst POLICY_HASH_DATA = Uint8Array.from([\n  0x7c, 0x67, 0xe8, 0x4f, 0x99, 0x74, 0x46, 0x71, 0x14, 0x93, 0xef, 0x8b, 0x74,\n  0x70, 0xb1, 0x0f, 0x60, 0x4b, 0x02, 0xd2, 0x58, 0x4f, 0xa0, 0x44, 0x6f, 0xce,\n  0xf7, 0xd9, 0x89, 0x83, 0xe3, 0xdc,\n]);\nconst KEYS_LENGTH = 0x02;\nconst KEYS_HASH_DATA = Uint8Array.from([\n  0x4b, 0xc5, 0x46, 0x7f, 0x24, 0x93, 0x85, 0xb2, 0x9e, 0x5b, 0x8e, 0xc9, 0xfb,\n  0x24, 0xcc, 0x65, 0xa3, 0x71, 0x0b, 0x1a, 0x26, 0xd2, 0x8d, 0xe9, 0xf5, 0xc4,\n  0xf3, 0xf4, 0x5d, 0xd6, 0x54, 0xc1,\n]);\nconst POLICY_NAME_DATA = Uint8Array.from([\n  0x02, 0x0c, 0x43, 0x6f, 0x6c, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,\n  0x65, 0x1e,\n]);\nconst POLICY_VERSION = 0x02;\nconst WALLET_POLICY_DATA = Uint8Array.from(\n  [POLICY_VERSION]\n    .concat(...POLICY_NAME_DATA)\n    .concat(...POLICY_HASH_DATA)\n    .concat([KEYS_LENGTH])\n    .concat(...KEYS_HASH_DATA),\n);\nconst EXPECTED_RAW_APDU = Uint8Array.from(\n  [0xe1, 0x02, 0x00, 0x01, 0x51].concat(...WALLET_POLICY_DATA),\n);\nconst APDU_RESPONSE = Uint8Array.from([\n  0x1d, 0x15, 0x0e, 0xd4, 0x25, 0xa8, 0x71, 0xa5, 0xca, 0x7e, 0x2c, 0x55, 0xdb,\n  0x1b, 0x32, 0x95, 0xc1, 0xfd, 0x97, 0x14, 0x7f, 0xd0, 0xa7, 0xb1, 0x88, 0xd4,\n  0x32, 0x7f, 0x4b, 0xa7, 0x40, 0x2a, 0xfa, 0x73, 0xe3, 0x61, 0x19, 0x32, 0x4f,\n  0xbe, 0x4c, 0xc1, 0xca, 0x94, 0xaa, 0x84, 0x2c, 0x62, 0x61, 0x52, 0x6d, 0x44,\n  0x11, 0x2a, 0x22, 0x16, 0x4b, 0xc5, 0x7c, 0x33, 0x35, 0x10, 0x2b, 0x04,\n]);\n\ndescribe(\"RegisterWalletAddressCommand\", () => {\n  describe(\"getApdu\", () => {\n    it(\"should send the correct APDU\", () => {\n      // when\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n\n      // then\n      expect(command.getApdu().getRawApdu()).toEqual(EXPECTED_RAW_APDU);\n    });\n  });\n  describe(\"parseResponse\", () => {\n    it(\"should parse the response correctly\", () => {\n      // given\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      const response = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: APDU_RESPONSE,\n      });\n\n      // then\n      expect(command.parseResponse(response)).toEqual(\n        CommandResultFactory({\n          data: {\n            walletId: APDU_RESPONSE.slice(0, 32),\n            walletHmac: APDU_RESPONSE.slice(32),\n          },\n        }),\n      );\n    });\n\n    it(\"should return an error if the response is not successful\", () => {\n      // given\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6d, 0x00]),\n        data: new Uint8Array(0),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n    });\n    it(\"should return an error if the response is too short\", () => {\n      // given\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      const response = new ApduResponse({\n        data: APDU_RESPONSE.slice(0, 2),\n        statusCode: new Uint8Array([0x90, 0x00]),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      if (!isSuccessCommandResult(result)) {\n        expect(result.error).toEqual(\n          new InvalidStatusWordError(\"Data mismatch\"),\n        );\n      } else {\n        fail(\"Expected an error, but the result was successful\");\n      }\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { RegisterWalletAddressCommand } from \"@internal/app-binder/command/RegisterWalletAddressCommand\";\n\nconst POLICY_HASH_DATA = Uint8Array.from([\n  0x7c, 0x67, 0xe8, 0x4f, 0x99, 0x74, 0x46, 0x71, 0x14, 0x93, 0xef, 0x8b, 0x74,\n  0x70, 0xb1, 0x0f, 0x60, 0x4b, 0x02, 0xd2, 0x58, 0x4f, 0xa0, 0x44, 0x6f, 0xce,\n  0xf7, 0xd9, 0x89, 0x83, 0xe3, 0xdc,\n]);\nconst KEYS_LENGTH = 0x02;\nconst KEYS_HASH_DATA = Uint8Array.from([\n  0x4b, 0xc5, 0x46, 0x7f, 0x24, 0x93, 0x85, 0xb2, 0x9e, 0x5b, 0x8e, 0xc9, 0xfb,\n  0x24, 0xcc, 0x65, 0xa3, 0x71, 0x0b, 0x1a, 0x26, 0xd2, 0x8d, 0xe9, 0xf5, 0xc4,\n  0xf3, 0xf4, 0x5d, 0xd6, 0x54, 0xc1,\n]);\nconst POLICY_NAME_DATA = Uint8Array.from([\n  0x02, 0x0c, 0x43, 0x6f, 0x6c, 0x64, 0x20, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67,\n  0x65, 0x1e,\n]);\nconst POLICY_VERSION = 0x02;\nconst WALLET_POLICY_DATA = Uint8Array.from(\n  [POLICY_VERSION]\n    .concat(...POLICY_NAME_DATA)\n    .concat(...POLICY_HASH_DATA)\n    .concat([KEYS_LENGTH])\n    .concat(...KEYS_HASH_DATA),\n);\nconst EXPECTED_RAW_APDU = Uint8Array.from(\n  [0xe1, 0x02, 0x00, 0x01, 0x51].concat(...WALLET_POLICY_DATA),\n);\nconst APDU_RESPONSE = Uint8Array.from([\n  0x1d, 0x15, 0x0e, 0xd4, 0x25, 0xa8, 0x71, 0xa5, 0xca, 0x7e, 0x2c, 0x55, 0xdb,\n  0x1b, 0x32, 0x95, 0xc1, 0xfd, 0x97, 0x14, 0x7f, 0xd0, 0xa7, 0xb1, 0x88, 0xd4,\n  0x32, 0x7f, 0x4b, 0xa7, 0x40, 0x2a, 0xfa, 0x73, 0xe3, 0x61, 0x19, 0x32, 0x4f,\n  0xbe, 0x4c, 0xc1, 0xca, 0x94, 0xaa, 0x84, 0x2c, 0x62, 0x61, 0x52, 0x6d, 0x44,\n  0x11, 0x2a, 0x22, 0x16, 0x4b, 0xc5, 0x7c, 0x33, 0x35, 0x10, 0x2b, 0x04,\n]);\n\ndescribe(\"RegisterWalletAddressCommand\", () => {\n  describe(\"name\", () => {\n    it(\"should be 'registerWalletAddress'\", () => {\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      expect(command.name).toBe(\"registerWalletAddress\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should send the correct APDU\", () => {\n      // when\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n\n      // then\n      expect(command.getApdu().getRawApdu()).toEqual(EXPECTED_RAW_APDU);\n    });\n  });\n  describe(\"parseResponse\", () => {\n    it(\"should parse the response correctly\", () => {\n      // given\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      const response = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: APDU_RESPONSE,\n      });\n\n      // then\n      expect(command.parseResponse(response)).toEqual(\n        CommandResultFactory({\n          data: {\n            walletId: APDU_RESPONSE.slice(0, 32),\n            walletHmac: APDU_RESPONSE.slice(32),\n          },\n        }),\n      );\n    });\n\n    it(\"should return an error if the response is not successful\", () => {\n      // given\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6d, 0x00]),\n        data: new Uint8Array(0),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n    });\n    it(\"should return an error if the response is too short\", () => {\n      // given\n      const command = new RegisterWalletAddressCommand({\n        walletPolicy: WALLET_POLICY_DATA,\n      });\n      const response = new ApduResponse({\n        data: APDU_RESPONSE.slice(0, 2),\n        statusCode: new Uint8Array([0x90, 0x00]),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      if (!isSuccessCommandResult(result)) {\n        expect(result.error).toEqual(\n          new InvalidStatusWordError(\"Data mismatch\"),\n        );\n      } else {\n        assert.fail(\"Expected an error, but the result was successful\");\n      }\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["ApduResponse", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "RegisterWalletAddressCommand", "POLICY_HASH_DATA", "KEYS_LENGTH", "KEYS_HASH_DATA", "POLICY_NAME_DATA", "POLICY_VERSION", "WALLET_POLICY_DATA", "EXPECTED_RAW_APDU", "APDU_RESPONSE", "command", "response", "result"]
 }

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

@@ -1,2 +1,2 @@
-import{ApduBuilder as n,CommandResultFactory as m}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as d,DerivationPathUtils as p}from"@ledgerhq/signer-utils";import{Maybe as i}from"purify-ts";import{PROTOCOL_VERSION as g}from"../../app-binder/command/utils/constants";import{BtcCommandUtils as l}from"../../utils/BtcCommandUtils";import{encodeVarint as C}from"../../utils/Varint";import{BTC_APP_ERRORS as u,BtcAppCommandErrorFactory as c}from"./utils/bitcoinAppErrors";class E{constructor(e,o=new d(u,c,l.isSuccessResponse)){this._args=e;this._errorHelper=o}getApdu(){const{derivationPath:e,messageLength:o,messageMerkleRoot:t}=this._args,r=new n({cla:225,ins:16,p1:0,p2:g}),s=p.splitPath(e);return r.add8BitUIntToData(s.length),s.forEach(a=>{r.add32BitUIntToData(a)}),r.addBufferToData(C(o).unsafeCoerce()).addBufferToData(t).build()}parseResponse(e){return i.fromNullable(this._errorHelper.getError(e)).orDefault(m({data:e}))}}export{E as SignMessageCommand};
+import{ApduBuilder as n,CommandResultFactory as m}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as d,DerivationPathUtils as p}from"@ledgerhq/signer-utils";import{Maybe as i}from"purify-ts";import{PROTOCOL_VERSION as g}from"../../app-binder/command/utils/constants";import{BtcCommandUtils as l}from"../../utils/BtcCommandUtils";import{encodeVarint as C}from"../../utils/Varint";import{BTC_APP_ERRORS as u,BtcAppCommandErrorFactory as c}from"./utils/bitcoinAppErrors";class E{constructor(e,o=new d(u,c,l.isSuccessResponse)){this._args=e;this._errorHelper=o}name="signMessage";getApdu(){const{derivationPath:e,messageLength:o,messageMerkleRoot:a}=this._args,r=new n({cla:225,ins:16,p1:0,p2:g}),s=p.splitPath(e);return r.add8BitUIntToData(s.length),s.forEach(t=>{r.add32BitUIntToData(t)}),r.addBufferToData(C(o).unsafeCoerce()).addBufferToData(a).build()}parseResponse(e){return i.fromNullable(this._errorHelper.getError(e)).orDefault(m({data:e}))}}export{E as SignMessageCommand};
 //# sourceMappingURL=SignMessageCommand.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignMessageCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n} from \"@ledgerhq/device-management-kit\";\nimport {\n  CommandErrorHelper,\n  DerivationPathUtils,\n} from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport { PROTOCOL_VERSION } from \"@internal/app-binder/command/utils/constants\";\nimport { BtcCommandUtils } from \"@internal/utils/BtcCommandUtils\";\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport {\n  BTC_APP_ERRORS,\n  BtcAppCommandErrorFactory,\n  type BtcErrorCodes,\n} from \"./utils/bitcoinAppErrors\";\n\nexport type SignMessageCommandArgs = {\n  /**\n   * The BIP32 path (e.g., \"m/44'/0'/0'/0/0\")\n   */\n  readonly derivationPath: string;\n  /**\n   * The total length of the message to be signed\n   */\n  readonly messageLength: number;\n  /**\n   * The Merkle root of the message data\n   */\n  readonly messageMerkleRoot: Uint8Array;\n};\n\nexport type SignMessageCommandResponse = ApduResponse;\n\nexport class SignMessageCommand\n  implements\n    Command<SignMessageCommandResponse, SignMessageCommandArgs, BtcErrorCodes>\n{\n  constructor(\n    private readonly _args: SignMessageCommandArgs,\n    private readonly _errorHelper = new CommandErrorHelper<\n      SignMessageCommandResponse,\n      BtcErrorCodes\n    >(\n      BTC_APP_ERRORS,\n      BtcAppCommandErrorFactory,\n      BtcCommandUtils.isSuccessResponse,\n    ),\n  ) {}\n\n  getApdu(): Apdu {\n    const { derivationPath, messageLength, messageMerkleRoot } = this._args;\n\n    const builder = new ApduBuilder({\n      cla: 0xe1,\n      ins: 0x10,\n      p1: 0x00,\n      p2: PROTOCOL_VERSION,\n    });\n\n    const path = DerivationPathUtils.splitPath(derivationPath);\n    builder.add8BitUIntToData(path.length);\n    path.forEach((element) => {\n      builder.add32BitUIntToData(element);\n    });\n\n    return builder\n      .addBufferToData(encodeVarint(messageLength).unsafeCoerce()) // Message length (varint)\n      .addBufferToData(messageMerkleRoot)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<SignMessageCommandResponse, BtcErrorCodes> {\n    return Maybe.fromNullable(\n      this._errorHelper.getError(apduResponse),\n    ).orDefault(CommandResultFactory({ data: apduResponse }));\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EAIA,wBAAAC,MACK,kCACP,OACE,sBAAAC,EACA,uBAAAC,MACK,yBACP,OAAS,SAAAC,MAAa,YAEtB,OAAS,oBAAAC,MAAwB,+CACjC,OAAS,mBAAAC,MAAuB,kCAChC,OAAS,gBAAAC,MAAoB,yBAE7B,OACE,kBAAAC,EACA,6BAAAC,MAEK,2BAmBA,MAAMC,CAGb,CACE,YACmBC,EACAC,EAAe,IAAIV,EAIlCM,EACAC,EACAH,EAAgB,iBAClB,EACA,CATiB,WAAAK,EACA,kBAAAC,CAQhB,CAEH,SAAgB,CACd,KAAM,CAAE,eAAAC,EAAgB,cAAAC,EAAe,kBAAAC,CAAkB,EAAI,KAAK,MAE5DC,EAAU,IAAIhB,EAAY,CAC9B,IAAK,IACL,IAAK,GACL,GAAI,EACJ,GAAIK,CACN,CAAC,EAEKY,EAAOd,EAAoB,UAAUU,CAAc,EACzD,OAAAG,EAAQ,kBAAkBC,EAAK,MAAM,EACrCA,EAAK,QAASC,GAAY,CACxBF,EAAQ,mBAAmBE,CAAO,CACpC,CAAC,EAEMF,EACJ,gBAAgBT,EAAaO,CAAa,EAAE,aAAa,CAAC,EAC1D,gBAAgBC,CAAiB,EACjC,MAAM,CACX,CAEA,cACEI,EAC0D,CAC1D,OAAOf,EAAM,aACX,KAAK,aAAa,SAASe,CAAY,CACzC,EAAE,UAAUlB,EAAqB,CAAE,KAAMkB,CAAa,CAAC,CAAC,CAC1D,CACF",
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n} from \"@ledgerhq/device-management-kit\";\nimport {\n  CommandErrorHelper,\n  DerivationPathUtils,\n} from \"@ledgerhq/signer-utils\";\nimport { Maybe } from \"purify-ts\";\n\nimport { PROTOCOL_VERSION } from \"@internal/app-binder/command/utils/constants\";\nimport { BtcCommandUtils } from \"@internal/utils/BtcCommandUtils\";\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport {\n  BTC_APP_ERRORS,\n  BtcAppCommandErrorFactory,\n  type BtcErrorCodes,\n} from \"./utils/bitcoinAppErrors\";\n\nexport type SignMessageCommandArgs = {\n  /**\n   * The BIP32 path (e.g., \"m/44'/0'/0'/0/0\")\n   */\n  readonly derivationPath: string;\n  /**\n   * The total length of the message to be signed\n   */\n  readonly messageLength: number;\n  /**\n   * The Merkle root of the message data\n   */\n  readonly messageMerkleRoot: Uint8Array;\n};\n\nexport type SignMessageCommandResponse = ApduResponse;\n\nexport class SignMessageCommand\n  implements\n    Command<SignMessageCommandResponse, SignMessageCommandArgs, BtcErrorCodes>\n{\n  readonly name = \"signMessage\";\n  constructor(\n    private readonly _args: SignMessageCommandArgs,\n    private readonly _errorHelper = new CommandErrorHelper<\n      SignMessageCommandResponse,\n      BtcErrorCodes\n    >(\n      BTC_APP_ERRORS,\n      BtcAppCommandErrorFactory,\n      BtcCommandUtils.isSuccessResponse,\n    ),\n  ) {}\n\n  getApdu(): Apdu {\n    const { derivationPath, messageLength, messageMerkleRoot } = this._args;\n\n    const builder = new ApduBuilder({\n      cla: 0xe1,\n      ins: 0x10,\n      p1: 0x00,\n      p2: PROTOCOL_VERSION,\n    });\n\n    const path = DerivationPathUtils.splitPath(derivationPath);\n    builder.add8BitUIntToData(path.length);\n    path.forEach((element) => {\n      builder.add32BitUIntToData(element);\n    });\n\n    return builder\n      .addBufferToData(encodeVarint(messageLength).unsafeCoerce()) // Message length (varint)\n      .addBufferToData(messageMerkleRoot)\n      .build();\n  }\n\n  parseResponse(\n    apduResponse: ApduResponse,\n  ): CommandResult<SignMessageCommandResponse, BtcErrorCodes> {\n    return Maybe.fromNullable(\n      this._errorHelper.getError(apduResponse),\n    ).orDefault(CommandResultFactory({ data: apduResponse }));\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAIA,wBAAAC,MACK,kCACP,OACE,sBAAAC,EACA,uBAAAC,MACK,yBACP,OAAS,SAAAC,MAAa,YAEtB,OAAS,oBAAAC,MAAwB,+CACjC,OAAS,mBAAAC,MAAuB,kCAChC,OAAS,gBAAAC,MAAoB,yBAE7B,OACE,kBAAAC,EACA,6BAAAC,MAEK,2BAmBA,MAAMC,CAGb,CAEE,YACmBC,EACAC,EAAe,IAAIV,EAIlCM,EACAC,EACAH,EAAgB,iBAClB,EACA,CATiB,WAAAK,EACA,kBAAAC,CAQhB,CAXM,KAAO,cAahB,SAAgB,CACd,KAAM,CAAE,eAAAC,EAAgB,cAAAC,EAAe,kBAAAC,CAAkB,EAAI,KAAK,MAE5DC,EAAU,IAAIhB,EAAY,CAC9B,IAAK,IACL,IAAK,GACL,GAAI,EACJ,GAAIK,CACN,CAAC,EAEKY,EAAOd,EAAoB,UAAUU,CAAc,EACzD,OAAAG,EAAQ,kBAAkBC,EAAK,MAAM,EACrCA,EAAK,QAASC,GAAY,CACxBF,EAAQ,mBAAmBE,CAAO,CACpC,CAAC,EAEMF,EACJ,gBAAgBT,EAAaO,CAAa,EAAE,aAAa,CAAC,EAC1D,gBAAgBC,CAAiB,EACjC,MAAM,CACX,CAEA,cACEI,EAC0D,CAC1D,OAAOf,EAAM,aACX,KAAK,aAAa,SAASe,CAAY,CACzC,EAAE,UAAUlB,EAAqB,CAAE,KAAMkB,CAAa,CAAC,CAAC,CAC1D,CACF",
   "names": ["ApduBuilder", "CommandResultFactory", "CommandErrorHelper", "DerivationPathUtils", "Maybe", "PROTOCOL_VERSION", "BtcCommandUtils", "encodeVarint", "BTC_APP_ERRORS", "BtcAppCommandErrorFactory", "SignMessageCommand", "_args", "_errorHelper", "derivationPath", "messageLength", "messageMerkleRoot", "builder", "path", "element", "apduResponse"]
 }

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

@@ -1,2 +1,2 @@
-import{ApduResponse as o,CommandResultFactory as a,isSuccessCommandResult as r}from"@ledgerhq/device-management-kit";import{SW_INTERRUPTED_EXECUTION as i}from"./utils/constants";import{SignMessageCommand as s}from"./SignMessageCommand";const p="44'/0'/0'/0/0",u=new TextEncoder().encode("Hello Bitcoin!"),m=u.length,c=new Uint8Array(32).fill(250),f=({omitR:n=!1,omitS:e=!1}={})=>new Uint8Array([...n?[]:[27],...n?[]:[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],...e?[]:[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]]),l=new Uint8Array([105,133]),E=new Uint8Array([225,16,0,1,54,5,128,0,0,44,128,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,14,...c]);describe("SignMessageCommand",()=>{const n={derivationPath:p,messageLength:m,messageMerkleRoot:c};describe("getApdu",()=>{it("should return correct APDU for given arguments",()=>{const x=new s(n).getApdu();expect(x.getRawApdu()).toStrictEqual(E)})}),describe("parseResponse",()=>{it("should return the APDU response if it's a continue response",()=>{const e=new s(n),x=new Uint8Array([1,2,3,4]),t=new o({statusCode:i,data:x}),d=e.parseResponse(t);expect(d).toStrictEqual(a({data:t}))}),it("should return an error if user denied the operation",()=>{const e=new s(n),x=new o({statusCode:l,data:new Uint8Array([])}),t=e.parseResponse(x);expect(r(t)).toBe(!1),r(t)||expect(t.error).toBeDefined()}),it("should return correct data when the response data is not empty",()=>{const e=new s(n),x=new o({statusCode:new Uint8Array([144,0]),data:f()}),t=e.parseResponse(x);expect(t).toStrictEqual(a({data:x}))})})});
+import{ApduResponse as o,CommandResultFactory as a,isSuccessCommandResult as c}from"@ledgerhq/device-management-kit";import{SW_INTERRUPTED_EXECUTION as i}from"./utils/constants";import{SignMessageCommand as s}from"./SignMessageCommand";const p="44'/0'/0'/0/0",m=new TextEncoder().encode("Hello Bitcoin!"),u=m.length,r=new Uint8Array(32).fill(250),f=({omitR:x=!1,omitS:e=!1}={})=>new Uint8Array([...x?[]:[27],...x?[]:[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],...e?[]:[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]]),l=new Uint8Array([105,133]),E=new Uint8Array([225,16,0,1,54,5,128,0,0,44,128,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,14,...r]);describe("SignMessageCommand",()=>{const x={derivationPath:p,messageLength:u,messageMerkleRoot:r};describe("name",()=>{it("should be 'signMessage'",()=>{const e=new s(x);expect(e.name).toBe("signMessage")})}),describe("getApdu",()=>{it("should return correct APDU for given arguments",()=>{const n=new s(x).getApdu();expect(n.getRawApdu()).toStrictEqual(E)})}),describe("parseResponse",()=>{it("should return the APDU response if it's a continue response",()=>{const e=new s(x),n=new Uint8Array([1,2,3,4]),t=new o({statusCode:i,data:n}),d=e.parseResponse(t);expect(d).toStrictEqual(a({data:t}))}),it("should return an error if user denied the operation",()=>{const e=new s(x),n=new o({statusCode:l,data:new Uint8Array([])}),t=e.parseResponse(n);expect(c(t)).toBe(!1),c(t)||expect(t.error).toBeDefined()}),it("should return correct data when the response data is not empty",()=>{const e=new s(x),n=new o({statusCode:new Uint8Array([144,0]),data:f()}),t=e.parseResponse(n);expect(t).toStrictEqual(a({data:n}))})})});
 //# sourceMappingURL=SignMessageCommand.test.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignMessageCommand.test.ts"],
-  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { SW_INTERRUPTED_EXECUTION } from \"./utils/constants\";\nimport { SignMessageCommand } from \"./SignMessageCommand\";\n\nconst PATH = \"44'/0'/0'/0/0\";\nconst MESSAGE = new TextEncoder().encode(\"Hello Bitcoin!\");\nconst MESSAGE_LENGTH = MESSAGE.length;\nconst MSG_MERKLE_ROOT = new Uint8Array(32).fill(0xfa);\n\nconst getResponse = ({\n  omitR = false,\n  omitS = false,\n}: {\n  omitR?: boolean;\n  omitS?: boolean;\n} = {}) =>\n  new Uint8Array([\n    ...(omitR ? [] : [0x1b]), // v\n    ...(omitR\n      ? []\n      : [\n          0x97, 0xa4, 0xca, 0x8f, 0x69, 0x46, 0x33, 0x59, 0x26, 0x01, 0xf5,\n          0xa2, 0x3e, 0x0b, 0xcc, 0x55, 0x3c, 0x9d, 0x0a, 0x90, 0xd3, 0xa3,\n          0x42, 0x2d, 0x57, 0x55, 0x08, 0xa9, 0x28, 0x98, 0xb9, 0x6e,\n        ]), // r (32 bytes)\n    ...(omitS\n      ? []\n      : [\n          0x69, 0x50, 0xd0, 0x2e, 0x74, 0xe9, 0xc1, 0x02, 0xc1, 0x64, 0xa2,\n          0x25, 0x53, 0x30, 0x82, 0xca, 0xbd, 0xd8, 0x90, 0xef, 0xc4, 0x63,\n          0xf6, 0x7f, 0x60, 0xce, 0xfe, 0x8c, 0x3f, 0x87, 0xcf, 0xce,\n        ]), // s (32 bytes)\n  ]);\n\nconst USER_DENIED_STATUS = new Uint8Array([0x69, 0x85]);\n\nconst EXPECTED_APDU = new Uint8Array([\n  0xe1, // CLA\n  0x10, // INS\n  0x00, // P1\n  0x01, // P2\n  0x36, // Lc\n  // Data:\n  0x05, // Number of derivation steps (5)\n  // BIP32 path:\n  // 44' (0x8000002C)\n  0x80,\n  0x00,\n  0x00,\n  0x2c,\n  // 0' (0x80000000)\n  0x80,\n  0x00,\n  0x00,\n  0x00,\n  // 0' (0x80000000)\n  0x80,\n  0x00,\n  0x00,\n  0x00,\n  // 0 (0x00000000)\n  0x00,\n  0x00,\n  0x00,\n  0x00,\n  // 0 (0x00000000)\n  0x00,\n  0x00,\n  0x00,\n  0x00,\n  // Message length (varint)\n  0x0e, // 14 bytes (\"Hello Bitcoin!\")\n  // messageMerkleRoot\n  ...MSG_MERKLE_ROOT,\n]);\n\ndescribe(\"SignMessageCommand\", (): void => {\n  const defaultArgs = {\n    derivationPath: PATH,\n    messageLength: MESSAGE_LENGTH,\n    messageMerkleRoot: MSG_MERKLE_ROOT,\n  };\n\n  describe(\"getApdu\", () => {\n    it(\"should return correct APDU for given arguments\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(EXPECTED_APDU);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return the APDU response if it's a continue response\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      const continueResponseData = new Uint8Array([0x01, 0x02, 0x03, 0x04]);\n\n      const apduResponse = new ApduResponse({\n        statusCode: SW_INTERRUPTED_EXECUTION,\n        data: continueResponseData,\n      });\n\n      // when\n      const response = command.parseResponse(apduResponse);\n\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: apduResponse,\n        }),\n      );\n    });\n\n    it(\"should return an error if user denied the operation\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      const apduResponse = new ApduResponse({\n        statusCode: USER_DENIED_STATUS,\n        data: new Uint8Array([]),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(isSuccessCommandResult(response)).toBe(false);\n      if (!isSuccessCommandResult(response)) {\n        expect(response.error).toBeDefined();\n      }\n    });\n\n    it(\"should return correct data when the response data is not empty\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: getResponse(),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: apduResponse,\n        }),\n      );\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["ApduResponse", "CommandResultFactory", "isSuccessCommandResult", "SW_INTERRUPTED_EXECUTION", "SignMessageCommand", "PATH", "MESSAGE", "MESSAGE_LENGTH", "MSG_MERKLE_ROOT", "getResponse", "omitR", "omitS", "USER_DENIED_STATUS", "EXPECTED_APDU", "defaultArgs", "apdu", "command", "continueResponseData", "apduResponse", "response"]
+  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { SW_INTERRUPTED_EXECUTION } from \"./utils/constants\";\nimport { SignMessageCommand } from \"./SignMessageCommand\";\n\nconst PATH = \"44'/0'/0'/0/0\";\nconst MESSAGE = new TextEncoder().encode(\"Hello Bitcoin!\");\nconst MESSAGE_LENGTH = MESSAGE.length;\nconst MSG_MERKLE_ROOT = new Uint8Array(32).fill(0xfa);\n\nconst getResponse = ({\n  omitR = false,\n  omitS = false,\n}: {\n  omitR?: boolean;\n  omitS?: boolean;\n} = {}) =>\n  new Uint8Array([\n    ...(omitR ? [] : [0x1b]), // v\n    ...(omitR\n      ? []\n      : [\n          0x97, 0xa4, 0xca, 0x8f, 0x69, 0x46, 0x33, 0x59, 0x26, 0x01, 0xf5,\n          0xa2, 0x3e, 0x0b, 0xcc, 0x55, 0x3c, 0x9d, 0x0a, 0x90, 0xd3, 0xa3,\n          0x42, 0x2d, 0x57, 0x55, 0x08, 0xa9, 0x28, 0x98, 0xb9, 0x6e,\n        ]), // r (32 bytes)\n    ...(omitS\n      ? []\n      : [\n          0x69, 0x50, 0xd0, 0x2e, 0x74, 0xe9, 0xc1, 0x02, 0xc1, 0x64, 0xa2,\n          0x25, 0x53, 0x30, 0x82, 0xca, 0xbd, 0xd8, 0x90, 0xef, 0xc4, 0x63,\n          0xf6, 0x7f, 0x60, 0xce, 0xfe, 0x8c, 0x3f, 0x87, 0xcf, 0xce,\n        ]), // s (32 bytes)\n  ]);\n\nconst USER_DENIED_STATUS = new Uint8Array([0x69, 0x85]);\n\nconst EXPECTED_APDU = new Uint8Array([\n  0xe1, // CLA\n  0x10, // INS\n  0x00, // P1\n  0x01, // P2\n  0x36, // Lc\n  // Data:\n  0x05, // Number of derivation steps (5)\n  // BIP32 path:\n  // 44' (0x8000002C)\n  0x80,\n  0x00,\n  0x00,\n  0x2c,\n  // 0' (0x80000000)\n  0x80,\n  0x00,\n  0x00,\n  0x00,\n  // 0' (0x80000000)\n  0x80,\n  0x00,\n  0x00,\n  0x00,\n  // 0 (0x00000000)\n  0x00,\n  0x00,\n  0x00,\n  0x00,\n  // 0 (0x00000000)\n  0x00,\n  0x00,\n  0x00,\n  0x00,\n  // Message length (varint)\n  0x0e, // 14 bytes (\"Hello Bitcoin!\")\n  // messageMerkleRoot\n  ...MSG_MERKLE_ROOT,\n]);\n\ndescribe(\"SignMessageCommand\", (): void => {\n  const defaultArgs = {\n    derivationPath: PATH,\n    messageLength: MESSAGE_LENGTH,\n    messageMerkleRoot: MSG_MERKLE_ROOT,\n  };\n\n  describe(\"name\", () => {\n    it(\"should be 'signMessage'\", () => {\n      const command = new SignMessageCommand(defaultArgs);\n      expect(command.name).toBe(\"signMessage\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return correct APDU for given arguments\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      // when\n      const apdu = command.getApdu();\n      // then\n      expect(apdu.getRawApdu()).toStrictEqual(EXPECTED_APDU);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return the APDU response if it's a continue response\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      const continueResponseData = new Uint8Array([0x01, 0x02, 0x03, 0x04]);\n\n      const apduResponse = new ApduResponse({\n        statusCode: SW_INTERRUPTED_EXECUTION,\n        data: continueResponseData,\n      });\n\n      // when\n      const response = command.parseResponse(apduResponse);\n\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: apduResponse,\n        }),\n      );\n    });\n\n    it(\"should return an error if user denied the operation\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      const apduResponse = new ApduResponse({\n        statusCode: USER_DENIED_STATUS,\n        data: new Uint8Array([]),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(isSuccessCommandResult(response)).toBe(false);\n      if (!isSuccessCommandResult(response)) {\n        expect(response.error).toBeDefined();\n      }\n    });\n\n    it(\"should return correct data when the response data is not empty\", () => {\n      // given\n      const command = new SignMessageCommand(defaultArgs);\n      const apduResponse = new ApduResponse({\n        statusCode: new Uint8Array([0x90, 0x00]),\n        data: getResponse(),\n      });\n      // when\n      const response = command.parseResponse(apduResponse);\n      // then\n      expect(response).toStrictEqual(\n        CommandResultFactory({\n          data: apduResponse,\n        }),\n      );\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["ApduResponse", "CommandResultFactory", "isSuccessCommandResult", "SW_INTERRUPTED_EXECUTION", "SignMessageCommand", "PATH", "MESSAGE", "MESSAGE_LENGTH", "MSG_MERKLE_ROOT", "getResponse", "omitR", "omitS", "USER_DENIED_STATUS", "EXPECTED_APDU", "defaultArgs", "command", "apdu", "continueResponseData", "apduResponse", "response"]
 }

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

@@ -1,2 +1,2 @@
-import{ApduBuilder as d,CommandResultFactory as p}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as u}from"@ledgerhq/signer-utils";import{Maybe as i}from"purify-ts";import{BTC_APP_ERRORS as l,BtcAppCommandErrorFactory as C}from"../../app-binder/command/utils/bitcoinAppErrors";import{PROTOCOL_VERSION as R}from"../../app-binder/command/utils/constants";import{BtcCommandUtils as c}from"../../utils/BtcCommandUtils";class S{constructor(t,o=new u(l,C,c.isSuccessResponse)){this._args=t;this._errorHelper=o}getApdu(){const t=new d({cla:225,ins:4,p1:0,p2:R}),{globalCommitment:o,inputsCount:r,inputsRoot:e,outputsCount:a,outputsRoot:n,walletHmac:s,walletId:m}=this._args;return t.addBufferToData(o).add8BitUIntToData(r).addBufferToData(e).add8BitUIntToData(a).addBufferToData(n).addBufferToData(m).addBufferToData(s).build()}parseResponse(t){return i.fromNullable(this._errorHelper.getError(t)).orDefault(p({data:t}))}}export{S as SignPsbtCommand};
+import{ApduBuilder as d,CommandResultFactory as p}from"@ledgerhq/device-management-kit";import{CommandErrorHelper as u}from"@ledgerhq/signer-utils";import{Maybe as i}from"purify-ts";import{BTC_APP_ERRORS as l,BtcAppCommandErrorFactory as C}from"../../app-binder/command/utils/bitcoinAppErrors";import{PROTOCOL_VERSION as R}from"../../app-binder/command/utils/constants";import{BtcCommandUtils as c}from"../../utils/BtcCommandUtils";class S{constructor(t,o=new u(l,C,c.isSuccessResponse)){this._args=t;this._errorHelper=o}name="signPsbt";getApdu(){const t=new d({cla:225,ins:4,p1:0,p2:R}),{globalCommitment:o,inputsCount:r,inputsRoot:e,outputsCount:a,outputsRoot:n,walletHmac:s,walletId:m}=this._args;return t.addBufferToData(o).add8BitUIntToData(r).addBufferToData(e).add8BitUIntToData(a).addBufferToData(n).addBufferToData(m).addBufferToData(s).build()}parseResponse(t){return i.fromNullable(this._errorHelper.getError(t)).orDefault(p({data:t}))}}export{S as SignPsbtCommand};
 //# sourceMappingURL=SignPsbtCommand.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignPsbtCommand.ts"],
-  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\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  BTC_APP_ERRORS,\n  BtcAppCommandErrorFactory,\n  type BtcErrorCodes,\n} from \"@internal/app-binder/command/utils/bitcoinAppErrors\";\nimport { PROTOCOL_VERSION } from \"@internal/app-binder/command/utils/constants\";\nimport { BtcCommandUtils } from \"@internal/utils/BtcCommandUtils\";\n\nexport type SignPsbtCommandArgs = {\n  globalCommitment: Uint8Array;\n  inputsCount: number;\n  inputsRoot: Uint8Array;\n  outputsCount: number;\n  outputsRoot: Uint8Array;\n  walletId: Uint8Array;\n  walletHmac: Uint8Array;\n};\n\ntype SignPsbtCommandResponse = ApduResponse;\n\nexport class SignPsbtCommand\n  implements\n    Command<SignPsbtCommandResponse, SignPsbtCommandArgs, BtcErrorCodes>\n{\n  constructor(\n    private readonly _args: SignPsbtCommandArgs,\n    private readonly _errorHelper = new CommandErrorHelper<\n      SignPsbtCommandResponse,\n      BtcErrorCodes\n    >(\n      BTC_APP_ERRORS,\n      BtcAppCommandErrorFactory,\n      BtcCommandUtils.isSuccessResponse,\n    ),\n  ) {}\n\n  getApdu(): Apdu {\n    const builder = new ApduBuilder({\n      cla: 0xe1,\n      ins: 0x04,\n      p1: 0x00,\n      p2: PROTOCOL_VERSION,\n    });\n    const {\n      globalCommitment,\n      inputsCount,\n      inputsRoot,\n      outputsCount,\n      outputsRoot,\n      walletHmac,\n      walletId,\n    } = this._args;\n\n    return builder\n      .addBufferToData(globalCommitment)\n      .add8BitUIntToData(inputsCount)\n      .addBufferToData(inputsRoot)\n      .add8BitUIntToData(outputsCount)\n      .addBufferToData(outputsRoot)\n      .addBufferToData(walletId)\n      .addBufferToData(walletHmac)\n      .build();\n  }\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignPsbtCommandResponse, BtcErrorCodes> {\n    return Maybe.fromNullable(this._errorHelper.getError(response)).orDefault(\n      CommandResultFactory({ data: response }),\n    );\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,eAAAA,EAIA,wBAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,sDACP,OAAS,oBAAAC,MAAwB,+CACjC,OAAS,mBAAAC,MAAuB,kCAczB,MAAMC,CAGb,CACE,YACmBC,EACAC,EAAe,IAAIR,EAIlCE,EACAC,EACAE,EAAgB,iBAClB,EACA,CATiB,WAAAE,EACA,kBAAAC,CAQhB,CAEH,SAAgB,CACd,MAAMC,EAAU,IAAIX,EAAY,CAC9B,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAIM,CACN,CAAC,EACK,CACJ,iBAAAM,EACA,YAAAC,EACA,WAAAC,EACA,aAAAC,EACA,YAAAC,EACA,WAAAC,EACA,SAAAC,CACF,EAAI,KAAK,MAET,OAAOP,EACJ,gBAAgBC,CAAgB,EAChC,kBAAkBC,CAAW,EAC7B,gBAAgBC,CAAU,EAC1B,kBAAkBC,CAAY,EAC9B,gBAAgBC,CAAW,EAC3B,gBAAgBE,CAAQ,EACxB,gBAAgBD,CAAU,EAC1B,MAAM,CACX,CACA,cACEE,EACuD,CACvD,OAAOhB,EAAM,aAAa,KAAK,aAAa,SAASgB,CAAQ,CAAC,EAAE,UAC9DlB,EAAqB,CAAE,KAAMkB,CAAS,CAAC,CACzC,CACF,CACF",
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\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  BTC_APP_ERRORS,\n  BtcAppCommandErrorFactory,\n  type BtcErrorCodes,\n} from \"@internal/app-binder/command/utils/bitcoinAppErrors\";\nimport { PROTOCOL_VERSION } from \"@internal/app-binder/command/utils/constants\";\nimport { BtcCommandUtils } from \"@internal/utils/BtcCommandUtils\";\n\nexport type SignPsbtCommandArgs = {\n  globalCommitment: Uint8Array;\n  inputsCount: number;\n  inputsRoot: Uint8Array;\n  outputsCount: number;\n  outputsRoot: Uint8Array;\n  walletId: Uint8Array;\n  walletHmac: Uint8Array;\n};\n\ntype SignPsbtCommandResponse = ApduResponse;\n\nexport class SignPsbtCommand\n  implements\n    Command<SignPsbtCommandResponse, SignPsbtCommandArgs, BtcErrorCodes>\n{\n  readonly name = \"signPsbt\";\n  constructor(\n    private readonly _args: SignPsbtCommandArgs,\n    private readonly _errorHelper = new CommandErrorHelper<\n      SignPsbtCommandResponse,\n      BtcErrorCodes\n    >(\n      BTC_APP_ERRORS,\n      BtcAppCommandErrorFactory,\n      BtcCommandUtils.isSuccessResponse,\n    ),\n  ) {}\n\n  getApdu(): Apdu {\n    const builder = new ApduBuilder({\n      cla: 0xe1,\n      ins: 0x04,\n      p1: 0x00,\n      p2: PROTOCOL_VERSION,\n    });\n    const {\n      globalCommitment,\n      inputsCount,\n      inputsRoot,\n      outputsCount,\n      outputsRoot,\n      walletHmac,\n      walletId,\n    } = this._args;\n\n    return builder\n      .addBufferToData(globalCommitment)\n      .add8BitUIntToData(inputsCount)\n      .addBufferToData(inputsRoot)\n      .add8BitUIntToData(outputsCount)\n      .addBufferToData(outputsRoot)\n      .addBufferToData(walletId)\n      .addBufferToData(walletHmac)\n      .build();\n  }\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignPsbtCommandResponse, BtcErrorCodes> {\n    return Maybe.fromNullable(this._errorHelper.getError(response)).orDefault(\n      CommandResultFactory({ data: response }),\n    );\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAIA,wBAAAC,MACK,kCACP,OAAS,sBAAAC,MAA0B,yBACnC,OAAS,SAAAC,MAAa,YAEtB,OACE,kBAAAC,EACA,6BAAAC,MAEK,sDACP,OAAS,oBAAAC,MAAwB,+CACjC,OAAS,mBAAAC,MAAuB,kCAczB,MAAMC,CAGb,CAEE,YACmBC,EACAC,EAAe,IAAIR,EAIlCE,EACAC,EACAE,EAAgB,iBAClB,EACA,CATiB,WAAAE,EACA,kBAAAC,CAQhB,CAXM,KAAO,WAahB,SAAgB,CACd,MAAMC,EAAU,IAAIX,EAAY,CAC9B,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAIM,CACN,CAAC,EACK,CACJ,iBAAAM,EACA,YAAAC,EACA,WAAAC,EACA,aAAAC,EACA,YAAAC,EACA,WAAAC,EACA,SAAAC,CACF,EAAI,KAAK,MAET,OAAOP,EACJ,gBAAgBC,CAAgB,EAChC,kBAAkBC,CAAW,EAC7B,gBAAgBC,CAAU,EAC1B,kBAAkBC,CAAY,EAC9B,gBAAgBC,CAAW,EAC3B,gBAAgBE,CAAQ,EACxB,gBAAgBD,CAAU,EAC1B,MAAM,CACX,CACA,cACEE,EACuD,CACvD,OAAOhB,EAAM,aAAa,KAAK,aAAa,SAASgB,CAAQ,CAAC,EAAE,UAC9DlB,EAAqB,CAAE,KAAMkB,CAAS,CAAC,CACzC,CACF,CACF",
   "names": ["ApduBuilder", "CommandResultFactory", "CommandErrorHelper", "Maybe", "BTC_APP_ERRORS", "BtcAppCommandErrorFactory", "PROTOCOL_VERSION", "BtcCommandUtils", "SignPsbtCommand", "_args", "_errorHelper", "builder", "globalCommitment", "inputsCount", "inputsRoot", "outputsCount", "outputsRoot", "walletHmac", "walletId", "response"]
 }

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

@@ -1,2 +1,2 @@
-import{ApduResponse as s,isSuccessCommandResult as n}from"@ledgerhq/device-management-kit";import{SignPsbtCommand as o}from"../../app-binder/command/SignPsbtCommand";const r=Uint8Array.from([5,81,155,56,218,231,68,71,183,33,81,243,84,203,19,140,163,89,26,95,248,172,129,50,137,177,138,0,78,49,50,22,32,58,34,31,75,185,94,30,99,129,67,20,166,147,179,89,53,61,70,96,163,67,81,101,211,223,183,53,206,45,245,245,143]),c=Uint8Array.from([1,42,200,205,188,111,214,67,112,5,86,99,249,80,47,227,102,237,248,73,112,204,125,126,232,246,186,71,89,159,17,5,194]),d=Uint8Array.from([1,217,53,20,212,41,104,141,118,87,201,175,10,8,134,172,116,75,208,136,28,74,25,16,181,55,250,186,40,205,202,46,17]),f=Uint8Array.from([65,172,65,166,22,180,162,250,212,152,38,143,233,200,166,59,136,84,135,56,57,6,93,230,251,47,171,241,251,232,146,86]),m=Uint8Array.from([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),u=Uint8Array.from([225,4,0,1,197,...r,1,...c,1,...d,...f,...m]);describe("SignPsbtCommand",()=>{const t={globalCommitment:r,inputsCount:1,inputsRoot:c,outputsCount:1,outputsRoot:d,walletId:f,walletHmac:m};describe("getApdu",()=>{it("should return a correct apdu",()=>{const x=new o(t);expect(x.getApdu().getRawApdu()).toEqual(u)})}),describe("parseResponse",()=>{it("should return success",()=>{const x=new o(t),e=new s({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])}),a=x.parseResponse(e);expect(n(a)).toBe(!0)}),it("should return failure",()=>{const x=new o(t),e=new s({statusCode:Uint8Array.from([109,0]),data:new Uint8Array(0)}),a=x.parseResponse(e);expect(n(a)).toBe(!1)})})});
+import{ApduResponse as o,isSuccessCommandResult as n}from"@ledgerhq/device-management-kit";import{SignPsbtCommand as t}from"../../app-binder/command/SignPsbtCommand";const r=Uint8Array.from([5,81,155,56,218,231,68,71,183,33,81,243,84,203,19,140,163,89,26,95,248,172,129,50,137,177,138,0,78,49,50,22,32,58,34,31,75,185,94,30,99,129,67,20,166,147,179,89,53,61,70,96,163,67,81,101,211,223,183,53,206,45,245,245,143]),c=Uint8Array.from([1,42,200,205,188,111,214,67,112,5,86,99,249,80,47,227,102,237,248,73,112,204,125,126,232,246,186,71,89,159,17,5,194]),d=Uint8Array.from([1,217,53,20,212,41,104,141,118,87,201,175,10,8,134,172,116,75,208,136,28,74,25,16,181,55,250,186,40,205,202,46,17]),m=Uint8Array.from([65,172,65,166,22,180,162,250,212,152,38,143,233,200,166,59,136,84,135,56,57,6,93,230,251,47,171,241,251,232,146,86]),f=Uint8Array.from([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]),i=Uint8Array.from([225,4,0,1,197,...r,1,...c,1,...d,...m,...f]);describe("SignPsbtCommand",()=>{const e={globalCommitment:r,inputsCount:1,inputsRoot:c,outputsCount:1,outputsRoot:d,walletId:m,walletHmac:f};describe("name",()=>{it("should be 'signPsbt'",()=>{const x=new t(e);expect(x.name).toBe("signPsbt")})}),describe("getApdu",()=>{it("should return a correct apdu",()=>{const x=new t(e);expect(x.getApdu().getRawApdu()).toEqual(i)})}),describe("parseResponse",()=>{it("should return success",()=>{const x=new t(e),s=new o({statusCode:Uint8Array.from([144,0]),data:Uint8Array.from([])}),a=x.parseResponse(s);expect(n(a)).toBe(!0)}),it("should return failure",()=>{const x=new t(e),s=new o({statusCode:Uint8Array.from([109,0]),data:new Uint8Array(0)}),a=x.parseResponse(s);expect(n(a)).toBe(!1)})})});
 //# sourceMappingURL=SignPsbtCommand.test.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/app-binder/command/SignPsbtCommand.test.ts"],
-  "sourcesContent": ["import {\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  SignPsbtCommand,\n  type SignPsbtCommandArgs,\n} from \"@internal/app-binder/command/SignPsbtCommand\";\n\nconst GLOBAL_COMMITMENT = Uint8Array.from([\n  0x05, 0x51, 0x9b, 0x38, 0xda, 0xe7, 0x44, 0x47, 0xb7, 0x21, 0x51, 0xf3, 0x54,\n  0xcb, 0x13, 0x8c, 0xa3, 0x59, 0x1a, 0x5f, 0xf8, 0xac, 0x81, 0x32, 0x89, 0xb1,\n  0x8a, 0x00, 0x4e, 0x31, 0x32, 0x16, 0x20, 0x3a, 0x22, 0x1f, 0x4b, 0xb9, 0x5e,\n  0x1e, 0x63, 0x81, 0x43, 0x14, 0xa6, 0x93, 0xb3, 0x59, 0x35, 0x3d, 0x46, 0x60,\n  0xa3, 0x43, 0x51, 0x65, 0xd3, 0xdf, 0xb7, 0x35, 0xce, 0x2d, 0xf5, 0xf5, 0x8f,\n]);\n\nconst INPUTS_ROOT = Uint8Array.from([\n  0x01, 0x2a, 0xc8, 0xcd, 0xbc, 0x6f, 0xd6, 0x43, 0x70, 0x05, 0x56, 0x63, 0xf9,\n  0x50, 0x2f, 0xe3, 0x66, 0xed, 0xf8, 0x49, 0x70, 0xcc, 0x7d, 0x7e, 0xe8, 0xf6,\n  0xba, 0x47, 0x59, 0x9f, 0x11, 0x05, 0xc2,\n]);\n\nconst OUTPUTS_ROOT = Uint8Array.from([\n  0x01, 0xd9, 0x35, 0x14, 0xd4, 0x29, 0x68, 0x8d, 0x76, 0x57, 0xc9, 0xaf, 0x0a,\n  0x08, 0x86, 0xac, 0x74, 0x4b, 0xd0, 0x88, 0x1c, 0x4a, 0x19, 0x10, 0xb5, 0x37,\n  0xfa, 0xba, 0x28, 0xcd, 0xca, 0x2e, 0x11,\n]);\nconst WALLET_ID = Uint8Array.from([\n  0x41, 0xac, 0x41, 0xa6, 0x16, 0xb4, 0xa2, 0xfa, 0xd4, 0x98, 0x26, 0x8f, 0xe9,\n  0xc8, 0xa6, 0x3b, 0x88, 0x54, 0x87, 0x38, 0x39, 0x06, 0x5d, 0xe6, 0xfb, 0x2f,\n  0xab, 0xf1, 0xfb, 0xe8, 0x92, 0x56,\n]);\nconst WALLET_HMAC = Uint8Array.from([\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\nconst SIGN_PSBT_APDU = Uint8Array.from([\n  0xe1,\n  0x04,\n  0x00,\n  0x01,\n  0xc5,\n  ...GLOBAL_COMMITMENT,\n  0x01,\n  ...INPUTS_ROOT,\n  0x01,\n  ...OUTPUTS_ROOT,\n  ...WALLET_ID,\n  ...WALLET_HMAC,\n]);\n\ndescribe(\"SignPsbtCommand\", () => {\n  const args: SignPsbtCommandArgs = {\n    globalCommitment: GLOBAL_COMMITMENT,\n    inputsCount: 1,\n    inputsRoot: INPUTS_ROOT,\n    outputsCount: 1,\n    outputsRoot: OUTPUTS_ROOT,\n    walletId: WALLET_ID,\n    walletHmac: WALLET_HMAC,\n  };\n  describe(\"getApdu\", () => {\n    it(\"should return a correct apdu\", () => {\n      const command = new SignPsbtCommand(args);\n\n      expect(command.getApdu().getRawApdu()).toEqual(SIGN_PSBT_APDU);\n    });\n  });\n  describe(\"parseResponse\", () => {\n    it(\"should return success\", () => {\n      // given\n      const command = new SignPsbtCommand(args);\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: Uint8Array.from([]),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(true);\n    });\n    it(\"should return failure\", () => {\n      // given\n      const command = new SignPsbtCommand(args);\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6d, 0x00]),\n        data: new Uint8Array(0),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport {\n  SignPsbtCommand,\n  type SignPsbtCommandArgs,\n} from \"@internal/app-binder/command/SignPsbtCommand\";\n\nconst GLOBAL_COMMITMENT = Uint8Array.from([\n  0x05, 0x51, 0x9b, 0x38, 0xda, 0xe7, 0x44, 0x47, 0xb7, 0x21, 0x51, 0xf3, 0x54,\n  0xcb, 0x13, 0x8c, 0xa3, 0x59, 0x1a, 0x5f, 0xf8, 0xac, 0x81, 0x32, 0x89, 0xb1,\n  0x8a, 0x00, 0x4e, 0x31, 0x32, 0x16, 0x20, 0x3a, 0x22, 0x1f, 0x4b, 0xb9, 0x5e,\n  0x1e, 0x63, 0x81, 0x43, 0x14, 0xa6, 0x93, 0xb3, 0x59, 0x35, 0x3d, 0x46, 0x60,\n  0xa3, 0x43, 0x51, 0x65, 0xd3, 0xdf, 0xb7, 0x35, 0xce, 0x2d, 0xf5, 0xf5, 0x8f,\n]);\n\nconst INPUTS_ROOT = Uint8Array.from([\n  0x01, 0x2a, 0xc8, 0xcd, 0xbc, 0x6f, 0xd6, 0x43, 0x70, 0x05, 0x56, 0x63, 0xf9,\n  0x50, 0x2f, 0xe3, 0x66, 0xed, 0xf8, 0x49, 0x70, 0xcc, 0x7d, 0x7e, 0xe8, 0xf6,\n  0xba, 0x47, 0x59, 0x9f, 0x11, 0x05, 0xc2,\n]);\n\nconst OUTPUTS_ROOT = Uint8Array.from([\n  0x01, 0xd9, 0x35, 0x14, 0xd4, 0x29, 0x68, 0x8d, 0x76, 0x57, 0xc9, 0xaf, 0x0a,\n  0x08, 0x86, 0xac, 0x74, 0x4b, 0xd0, 0x88, 0x1c, 0x4a, 0x19, 0x10, 0xb5, 0x37,\n  0xfa, 0xba, 0x28, 0xcd, 0xca, 0x2e, 0x11,\n]);\nconst WALLET_ID = Uint8Array.from([\n  0x41, 0xac, 0x41, 0xa6, 0x16, 0xb4, 0xa2, 0xfa, 0xd4, 0x98, 0x26, 0x8f, 0xe9,\n  0xc8, 0xa6, 0x3b, 0x88, 0x54, 0x87, 0x38, 0x39, 0x06, 0x5d, 0xe6, 0xfb, 0x2f,\n  0xab, 0xf1, 0xfb, 0xe8, 0x92, 0x56,\n]);\nconst WALLET_HMAC = Uint8Array.from([\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\nconst SIGN_PSBT_APDU = Uint8Array.from([\n  0xe1,\n  0x04,\n  0x00,\n  0x01,\n  0xc5,\n  ...GLOBAL_COMMITMENT,\n  0x01,\n  ...INPUTS_ROOT,\n  0x01,\n  ...OUTPUTS_ROOT,\n  ...WALLET_ID,\n  ...WALLET_HMAC,\n]);\n\ndescribe(\"SignPsbtCommand\", () => {\n  const args: SignPsbtCommandArgs = {\n    globalCommitment: GLOBAL_COMMITMENT,\n    inputsCount: 1,\n    inputsRoot: INPUTS_ROOT,\n    outputsCount: 1,\n    outputsRoot: OUTPUTS_ROOT,\n    walletId: WALLET_ID,\n    walletHmac: WALLET_HMAC,\n  };\n\n  describe(\"name\", () => {\n    it(\"should be 'signPsbt'\", () => {\n      const command = new SignPsbtCommand(args);\n      expect(command.name).toBe(\"signPsbt\");\n    });\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return a correct apdu\", () => {\n      const command = new SignPsbtCommand(args);\n\n      expect(command.getApdu().getRawApdu()).toEqual(SIGN_PSBT_APDU);\n    });\n  });\n  describe(\"parseResponse\", () => {\n    it(\"should return success\", () => {\n      // given\n      const command = new SignPsbtCommand(args);\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x90, 0x00]),\n        data: Uint8Array.from([]),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(true);\n    });\n    it(\"should return failure\", () => {\n      // given\n      const command = new SignPsbtCommand(args);\n      const response = new ApduResponse({\n        statusCode: Uint8Array.from([0x6d, 0x00]),\n        data: new Uint8Array(0),\n      });\n\n      // when\n      const result = command.parseResponse(response);\n\n      // then\n      expect(isSuccessCommandResult(result)).toBe(false);\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["ApduResponse", "isSuccessCommandResult", "SignPsbtCommand", "GLOBAL_COMMITMENT", "INPUTS_ROOT", "OUTPUTS_ROOT", "WALLET_ID", "WALLET_HMAC", "SIGN_PSBT_APDU", "args", "command", "response", "result"]
 }

package/lib/esm/internal/app-binder/command/client-command-handlers/GetMerkleLeafIndexCommandHandler.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{Just as x,Nothing as m}from"purify-ts";import{ClientCommandCodes as p,SHA256_SIZE as c}from"../../../app-binder/command/utils/constants";import{encodeVarint as h}from"../../../utils/Varint";import{GetMerkleLeafIndexCommandHandler as i}from"./GetMerkleLeafIndexCommandHandler";const u=p.GET_MERKLE_LEAF_INDEX;describe("GetMerkleLeafIndexCommandHandler",()=>{let l,o;beforeEach(()=>{jest.clearAllMocks(),o={getMerkleLeafIndex:jest.fn()},l={dataStore:o,queue:[],yieldedResults:[]}});const d=(e,t,s)=>new Uint8Array([e,...t,...s]);it("should return the index when the Merkle leaf is found",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t),n=123456,r=h(n).unsafeCoerce();o.getMerkleLeafIndex.mockReturnValue(x(n));const f=i(s,l),a=new Uint8Array(1+r.length);a[0]=1,a.set(r,1),expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(f.isRight()).toBe(!0),expect(f.unsafeCoerce()).toEqual(a),expect(l.queue).toHaveLength(0)}),it("should return a failure response when the Merkle leaf is not found",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t);o.getMerkleLeafIndex.mockReturnValue(m);const n=i(s,l),r=Uint8Array.from([0]);expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(n.isRight()).toBe(!0),expect(n.unsafeCoerce()).toEqual(r),expect(l.queue).toHaveLength(0)}),it("should correctly handle a leaf index of zero",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t),n=0,r=h(n).unsafeCoerce();o.getMerkleLeafIndex.mockReturnValue(x(n));const f=i(s,l),a=new Uint8Array(1+r.length);a[0]=1,a.set(r,1),expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(f.isRight()).toBe(!0),expect(f.unsafeCoerce()).toEqual(a),expect(l.queue).toHaveLength(0)}),it("should correctly handle the maximum SHA256_SIZE-bit unsigned integer as a leaf index",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t),n=4294967295,r=h(n).unsafeCoerce();o.getMerkleLeafIndex.mockReturnValue(x(n));const f=i(s,l),a=new Uint8Array(1+r.length);a[0]=1,a.set(r,1),expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(f.isRight()).toBe(!0),expect(f.unsafeCoerce()).toEqual(a),expect(l.queue).toHaveLength(0)})});
+import{Just as x,Nothing as m}from"purify-ts";import{ClientCommandCodes as p,SHA256_SIZE as c}from"../../../app-binder/command/utils/constants";import{encodeVarint as h}from"../../../utils/Varint";import{GetMerkleLeafIndexCommandHandler as i}from"./GetMerkleLeafIndexCommandHandler";const u=p.GET_MERKLE_LEAF_INDEX;describe("GetMerkleLeafIndexCommandHandler",()=>{let l,o;beforeEach(()=>{vi.clearAllMocks(),o={getMerkleLeafIndex:vi.fn()},l={dataStore:o,queue:[],yieldedResults:[]}});const d=(e,t,s)=>new Uint8Array([e,...t,...s]);it("should return the index when the Merkle leaf is found",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t),n=123456,r=h(n).unsafeCoerce();o.getMerkleLeafIndex.mockReturnValue(x(n));const f=i(s,l),a=new Uint8Array(1+r.length);a[0]=1,a.set(r,1),expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(f.isRight()).toBe(!0),expect(f.unsafeCoerce()).toEqual(a),expect(l.queue).toHaveLength(0)}),it("should return a failure response when the Merkle leaf is not found",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t);o.getMerkleLeafIndex.mockReturnValue(m);const n=i(s,l),r=Uint8Array.from([0]);expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(n.isRight()).toBe(!0),expect(n.unsafeCoerce()).toEqual(r),expect(l.queue).toHaveLength(0)}),it("should correctly handle a leaf index of zero",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t),n=0,r=h(n).unsafeCoerce();o.getMerkleLeafIndex.mockReturnValue(x(n));const f=i(s,l),a=new Uint8Array(1+r.length);a[0]=1,a.set(r,1),expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(f.isRight()).toBe(!0),expect(f.unsafeCoerce()).toEqual(a),expect(l.queue).toHaveLength(0)}),it("should correctly handle the maximum SHA256_SIZE-bit unsigned integer as a leaf index",()=>{const e=new Uint8Array(c).fill(170),t=new Uint8Array(c).fill(255),s=d(u,e,t),n=4294967295,r=h(n).unsafeCoerce();o.getMerkleLeafIndex.mockReturnValue(x(n));const f=i(s,l),a=new Uint8Array(1+r.length);a[0]=1,a.set(r,1),expect(o.getMerkleLeafIndex).toHaveBeenCalledWith(e,t),expect(f.isRight()).toBe(!0),expect(f.unsafeCoerce()).toEqual(a),expect(l.queue).toHaveLength(0)})});
 //# sourceMappingURL=GetMerkleLeafIndexCommandHandler.test.js.map

package/lib/esm/internal/app-binder/command/client-command-handlers/GetMerkleLeafIndexCommandHandler.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/app-binder/command/client-command-handlers/GetMerkleLeafIndexCommandHandler.test.ts"],
-  "sourcesContent": ["import { Just, Nothing } from \"purify-ts\";\n\nimport {\n  ClientCommandCodes,\n  SHA256_SIZE,\n} from \"@internal/app-binder/command/utils/constants\";\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport { type CommandHandlerContext } from \"./ClientCommandHandlersTypes\";\nimport { GetMerkleLeafIndexCommandHandler } from \"./GetMerkleLeafIndexCommandHandler\";\n\nconst COMMAND_CODE = ClientCommandCodes.GET_MERKLE_LEAF_INDEX;\n\ndescribe(\"GetMerkleLeafIndexCommandHandler\", () => {\n  let commandHandlerContext: CommandHandlerContext;\n  let mockDataStore: jest.Mocked<DataStore>;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n\n    mockDataStore = {\n      getMerkleLeafIndex: jest.fn(),\n    } as unknown as jest.Mocked<DataStore>;\n\n    commandHandlerContext = {\n      dataStore: mockDataStore,\n      queue: [],\n      yieldedResults: [],\n    };\n  });\n\n  const createRequest = (\n    commandCode: number,\n    merkleRootHash: Uint8Array,\n    leafNodeHash: Uint8Array,\n  ): Uint8Array =>\n    new Uint8Array([commandCode, ...merkleRootHash, ...leafNodeHash]);\n\n  it(\"should return the index when the Merkle leaf is found\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n    const leafIndex = 123456;\n    const encodedLeafIndexVarint = encodeVarint(leafIndex).unsafeCoerce();\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Just(leafIndex));\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedResponseBuffer = new Uint8Array(\n      1 + encodedLeafIndexVarint.length,\n    );\n    expectedResponseBuffer[0] = 1; // index found\n    expectedResponseBuffer.set(encodedLeafIndexVarint, 1);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponseBuffer);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should return a failure response when the Merkle leaf is not found\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Nothing);\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedFailureResponseBuffer = Uint8Array.from([0]);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(\n      expectedFailureResponseBuffer,\n    );\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should correctly handle a leaf index of zero\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n    const leafIndex = 0;\n    const encodedLeafIndexVarint = encodeVarint(leafIndex).unsafeCoerce();\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Just(leafIndex));\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedResponseBuffer = new Uint8Array(\n      1 + encodedLeafIndexVarint.length,\n    );\n    expectedResponseBuffer[0] = 1; // index found\n    expectedResponseBuffer.set(encodedLeafIndexVarint, 1);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponseBuffer);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should correctly handle the maximum SHA256_SIZE-bit unsigned integer as a leaf index\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n    const maximumLeafIndex = 0xffffffff; // maximum value of a SHA256_SIZE-bit unsigned integer\n    const encodedLeafIndexVarint =\n      encodeVarint(maximumLeafIndex).unsafeCoerce();\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Just(maximumLeafIndex));\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedResponseBuffer = new Uint8Array(\n      1 + encodedLeafIndexVarint.length,\n    );\n    expectedResponseBuffer[0] = 1; // index found\n    expectedResponseBuffer.set(encodedLeafIndexVarint, 1);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponseBuffer);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { Just, Nothing } from \"purify-ts\";\nimport { type Mocked } from \"vitest\";\n\nimport {\n  ClientCommandCodes,\n  SHA256_SIZE,\n} from \"@internal/app-binder/command/utils/constants\";\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport { type CommandHandlerContext } from \"./ClientCommandHandlersTypes\";\nimport { GetMerkleLeafIndexCommandHandler } from \"./GetMerkleLeafIndexCommandHandler\";\n\nconst COMMAND_CODE = ClientCommandCodes.GET_MERKLE_LEAF_INDEX;\n\ndescribe(\"GetMerkleLeafIndexCommandHandler\", () => {\n  let commandHandlerContext: CommandHandlerContext;\n  let mockDataStore: Mocked<DataStore>;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n\n    mockDataStore = {\n      getMerkleLeafIndex: vi.fn(),\n    } as unknown as Mocked<DataStore>;\n\n    commandHandlerContext = {\n      dataStore: mockDataStore,\n      queue: [],\n      yieldedResults: [],\n    };\n  });\n\n  const createRequest = (\n    commandCode: number,\n    merkleRootHash: Uint8Array,\n    leafNodeHash: Uint8Array,\n  ): Uint8Array =>\n    new Uint8Array([commandCode, ...merkleRootHash, ...leafNodeHash]);\n\n  it(\"should return the index when the Merkle leaf is found\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n    const leafIndex = 123456;\n    const encodedLeafIndexVarint = encodeVarint(leafIndex).unsafeCoerce();\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Just(leafIndex));\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedResponseBuffer = new Uint8Array(\n      1 + encodedLeafIndexVarint.length,\n    );\n    expectedResponseBuffer[0] = 1; // index found\n    expectedResponseBuffer.set(encodedLeafIndexVarint, 1);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponseBuffer);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should return a failure response when the Merkle leaf is not found\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Nothing);\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedFailureResponseBuffer = Uint8Array.from([0]);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(\n      expectedFailureResponseBuffer,\n    );\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should correctly handle a leaf index of zero\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n    const leafIndex = 0;\n    const encodedLeafIndexVarint = encodeVarint(leafIndex).unsafeCoerce();\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Just(leafIndex));\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedResponseBuffer = new Uint8Array(\n      1 + encodedLeafIndexVarint.length,\n    );\n    expectedResponseBuffer[0] = 1; // index found\n    expectedResponseBuffer.set(encodedLeafIndexVarint, 1);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponseBuffer);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should correctly handle the maximum SHA256_SIZE-bit unsigned integer as a leaf index\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xff);\n    const handlerRequest = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      leafNodeHash,\n    );\n    const maximumLeafIndex = 0xffffffff; // maximum value of a SHA256_SIZE-bit unsigned integer\n    const encodedLeafIndexVarint =\n      encodeVarint(maximumLeafIndex).unsafeCoerce();\n\n    // when\n    mockDataStore.getMerkleLeafIndex.mockReturnValue(Just(maximumLeafIndex));\n\n    const handlerResponse = GetMerkleLeafIndexCommandHandler(\n      handlerRequest,\n      commandHandlerContext,\n    );\n\n    const expectedResponseBuffer = new Uint8Array(\n      1 + encodedLeafIndexVarint.length,\n    );\n    expectedResponseBuffer[0] = 1; // index found\n    expectedResponseBuffer.set(encodedLeafIndexVarint, 1);\n\n    // then\n    expect(mockDataStore.getMerkleLeafIndex).toHaveBeenCalledWith(\n      merkleRootHash,\n      leafNodeHash,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponseBuffer);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n});\n"],
+  "mappings": "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",
   "names": ["Just", "Nothing", "ClientCommandCodes", "SHA256_SIZE", "encodeVarint", "GetMerkleLeafIndexCommandHandler", "COMMAND_CODE", "commandHandlerContext", "mockDataStore", "createRequest", "commandCode", "merkleRootHash", "leafNodeHash", "handlerRequest", "leafIndex", "encodedLeafIndexVarint", "handlerResponse", "expectedResponseBuffer", "expectedFailureResponseBuffer", "maximumLeafIndex"]
 }

package/lib/esm/internal/app-binder/command/client-command-handlers/GetMerkleLeafProofCommandHandler.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{APDU_MAX_PAYLOAD as k}from"@ledgerhq/device-management-kit";import{Just as y,Nothing as H}from"purify-ts";import{ClientCommandCodes as P,SHA256_SIZE as e}from"../../../app-binder/command/utils/constants";import{encodeVarint as M}from"../../../utils/Varint";import{ClientCommandHandlerError as R}from"./Errors";import{GetMerkleLeafProofCommandHandler as E}from"./GetMerkleLeafProofCommandHandler";const A=P.GET_MERKLE_LEAF_PROOF;describe("GetMerkleLeafProofCommandHandler",()=>{let l,m;beforeEach(()=>{jest.clearAllMocks(),m={getMerkleProof:jest.fn()},l={dataStore:m,queue:[],yieldedResults:[]}});const x=(n,u,r,d)=>new Uint8Array([n,...u,...M(r).unsafeCoerce(),...M(d).unsafeCoerce()]);it("should return the Merkle leaf and proof when found and proof length is less than or equal to the maximum allowed",()=>{const n=new Uint8Array(e).fill(1),u=1,r=2,d=x(A,n,u,r),c=new Uint8Array(e).fill(170),i=[new Uint8Array(e).fill(187),new Uint8Array(e).fill(204)];m.getMerkleProof.mockReturnValue(y({leafHash:c,proof:i}));const s=E(d,l),h=k-e-1-1,g=Math.floor(h/e),p=Math.min(i.length,g),o=new Uint8Array(e+1+1+e*p);let t=0;o.set(c,t),t+=e,o[t++]=i.length,o[t++]=p;for(let a=0;a<p;a++)o.set(i[a],t),t+=e;expect(m.getMerkleProof).toHaveBeenCalledWith(n,r),expect(s.isRight()).toBe(!0),expect(s.unsafeCoerce()).toEqual(o),expect(l.queue).toHaveLength(0)}),it("should handle proof longer than the maximum allowed by queuing the remaining proof elements",()=>{const n=new Uint8Array(e).fill(2),u=1,r=3,d=x(A,n,u,r),c=new Uint8Array(e).fill(221),s=Array.from({length:10},(f,C)=>new Uint8Array(e).fill(238+C));m.getMerkleProof.mockReturnValue(y({leafHash:c,proof:s}));const h=E(d,l),g=k-e-1-1,p=Math.floor(g/e),o=Math.min(s.length,p),t=new Uint8Array(e+1+1+e*o);let a=0;t.set(c,a),a+=e,t[a++]=s.length,t[a++]=o;for(let f=0;f<o;f++)t.set(s[f],a),a+=e;expect(m.getMerkleProof).toHaveBeenCalledWith(n,r),expect(h.isRight()).toBe(!0),expect(h.unsafeCoerce()).toEqual(t),expect(l.queue).toHaveLength(s.length-o);for(let f=0;f<l.queue.length;f++)expect(l.queue[f]).toEqual(s[o+f])}),it("should return an error when the Merkle proof is not found in the data store",()=>{const n=new Uint8Array(e).fill(4),u=1,r=5,d=x(A,n,u,r);m.getMerkleProof.mockReturnValue(H);const c=E(d,l);expect(c.isLeft()).toBe(!0);const i=c.leftOrDefault(void 0);expect(i).toBeDefined(),expect(i instanceof R).toBe(!0),expect(m.getMerkleProof).toHaveBeenCalledWith(n,r),expect(l.queue).toHaveLength(0)})});
+import{APDU_MAX_PAYLOAD as y}from"@ledgerhq/device-management-kit";import{Just as E,Nothing as H}from"purify-ts";import{ClientCommandCodes as P,SHA256_SIZE as e}from"../../../app-binder/command/utils/constants";import{encodeVarint as M}from"../../../utils/Varint";import{ClientCommandHandlerError as R}from"./Errors";import{GetMerkleLeafProofCommandHandler as A}from"./GetMerkleLeafProofCommandHandler";const k=P.GET_MERKLE_LEAF_PROOF;describe("GetMerkleLeafProofCommandHandler",()=>{let l,m;beforeEach(()=>{vi.clearAllMocks(),m={getMerkleProof:vi.fn()},l={dataStore:m,queue:[],yieldedResults:[]}});const x=(n,u,r,d)=>new Uint8Array([n,...u,...M(r).unsafeCoerce(),...M(d).unsafeCoerce()]);it("should return the Merkle leaf and proof when found and proof length is less than or equal to the maximum allowed",()=>{const n=new Uint8Array(e).fill(1),u=1,r=2,d=x(k,n,u,r),i=new Uint8Array(e).fill(170),c=[new Uint8Array(e).fill(187),new Uint8Array(e).fill(204)];m.getMerkleProof.mockReturnValue(E({leafHash:i,proof:c}));const s=A(d,l),h=y-e-1-1,g=Math.floor(h/e),p=Math.min(c.length,g),o=new Uint8Array(e+1+1+e*p);let t=0;o.set(i,t),t+=e,o[t++]=c.length,o[t++]=p;for(let a=0;a<p;a++)o.set(c[a],t),t+=e;expect(m.getMerkleProof).toHaveBeenCalledWith(n,r),expect(s.isRight()).toBe(!0),expect(s.unsafeCoerce()).toEqual(o),expect(l.queue).toHaveLength(0)}),it("should handle proof longer than the maximum allowed by queuing the remaining proof elements",()=>{const n=new Uint8Array(e).fill(2),u=1,r=3,d=x(k,n,u,r),i=new Uint8Array(e).fill(221),s=Array.from({length:10},(f,C)=>new Uint8Array(e).fill(238+C));m.getMerkleProof.mockReturnValue(E({leafHash:i,proof:s}));const h=A(d,l),g=y-e-1-1,p=Math.floor(g/e),o=Math.min(s.length,p),t=new Uint8Array(e+1+1+e*o);let a=0;t.set(i,a),a+=e,t[a++]=s.length,t[a++]=o;for(let f=0;f<o;f++)t.set(s[f],a),a+=e;expect(m.getMerkleProof).toHaveBeenCalledWith(n,r),expect(h.isRight()).toBe(!0),expect(h.unsafeCoerce()).toEqual(t),expect(l.queue).toHaveLength(s.length-o);for(let f=0;f<l.queue.length;f++)expect(l.queue[f]).toEqual(s[o+f])}),it("should return an error when the Merkle proof is not found in the data store",()=>{const n=new Uint8Array(e).fill(4),u=1,r=5,d=x(k,n,u,r);m.getMerkleProof.mockReturnValue(H);const i=A(d,l);expect(i.isLeft()).toBe(!0);const c=i.leftOrDefault(void 0);expect(c).toBeDefined(),expect(c instanceof R).toBe(!0),expect(m.getMerkleProof).toHaveBeenCalledWith(n,r),expect(l.queue).toHaveLength(0)})});
 //# sourceMappingURL=GetMerkleLeafProofCommandHandler.test.js.map

package/lib/esm/internal/app-binder/command/client-command-handlers/GetMerkleLeafProofCommandHandler.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/app-binder/command/client-command-handlers/GetMerkleLeafProofCommandHandler.test.ts"],
-  "sourcesContent": ["import { APDU_MAX_PAYLOAD } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport {\n  ClientCommandCodes,\n  SHA256_SIZE,\n} from \"@internal/app-binder/command/utils/constants\";\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport { type CommandHandlerContext } from \"./ClientCommandHandlersTypes\";\nimport { ClientCommandHandlerError } from \"./Errors\";\nimport { GetMerkleLeafProofCommandHandler } from \"./GetMerkleLeafProofCommandHandler\";\n\nconst COMMAND_CODE = ClientCommandCodes.GET_MERKLE_LEAF_PROOF;\n\ndescribe(\"GetMerkleLeafProofCommandHandler\", () => {\n  let commandHandlerContext: CommandHandlerContext;\n  let mockDataStore: jest.Mocked<DataStore>;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n\n    mockDataStore = {\n      getMerkleProof: jest.fn(),\n    } as unknown as jest.Mocked<DataStore>;\n\n    commandHandlerContext = {\n      dataStore: mockDataStore,\n      queue: [],\n      yieldedResults: [],\n    };\n  });\n\n  const createRequest = (\n    commandCode: number,\n    merkleRootHash: Uint8Array,\n    totalElements: number,\n    proofElementIndex: number,\n  ): Uint8Array =>\n    new Uint8Array([\n      commandCode,\n      ...merkleRootHash,\n      ...encodeVarint(totalElements).unsafeCoerce(),\n      ...encodeVarint(proofElementIndex).unsafeCoerce(),\n    ]);\n\n  it(\"should return the Merkle leaf and proof when found and proof length is less than or equal to the maximum allowed\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0x01);\n    const totalElements = 1;\n    const proofElementIndex = 2;\n    const request = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      totalElements,\n      proofElementIndex,\n    );\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const proofElements = [\n      new Uint8Array(SHA256_SIZE).fill(0xbb),\n      new Uint8Array(SHA256_SIZE).fill(0xcc),\n    ];\n\n    // when\n    mockDataStore.getMerkleProof.mockReturnValue(\n      Just({ leafHash: leafNodeHash, proof: proofElements }),\n    );\n\n    const handlerResponse = GetMerkleLeafProofCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const maximumPayloadSize = APDU_MAX_PAYLOAD - SHA256_SIZE - 1 - 1;\n    const maximumProofElements = Math.floor(maximumPayloadSize / SHA256_SIZE);\n    const proofElementsToInclude = Math.min(\n      proofElements.length,\n      maximumProofElements,\n    );\n\n    const expectedResponse = new Uint8Array(\n      SHA256_SIZE + 1 + 1 + SHA256_SIZE * proofElementsToInclude,\n    );\n    let responseBufferOffset = 0;\n    expectedResponse.set(leafNodeHash, responseBufferOffset); // leafHash\n    responseBufferOffset += SHA256_SIZE;\n    expectedResponse[responseBufferOffset++] = proofElements.length; // total proof length\n    expectedResponse[responseBufferOffset++] = proofElementsToInclude;\n    for (\n      let proofElementIndex = 0;\n      proofElementIndex < proofElementsToInclude;\n      proofElementIndex++\n    ) {\n      expectedResponse.set(\n        proofElements[proofElementIndex] as Uint8Array,\n        responseBufferOffset,\n      );\n      responseBufferOffset += SHA256_SIZE;\n    }\n\n    // then\n    expect(mockDataStore.getMerkleProof).toHaveBeenCalledWith(\n      merkleRootHash,\n      proofElementIndex,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should handle proof longer than the maximum allowed by queuing the remaining proof elements\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0x02);\n    const totalElements = 1;\n    const proofElementIndex = 3;\n    const request = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      totalElements,\n      proofElementIndex,\n    );\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xdd);\n    const totalProofLength = 10;\n    const proofElements = Array.from(\n      { length: totalProofLength },\n      (_, proofIndex) => new Uint8Array(SHA256_SIZE).fill(0xee + proofIndex),\n    );\n\n    // when\n    mockDataStore.getMerkleProof.mockReturnValue(\n      Just({ leafHash: leafNodeHash, proof: proofElements }),\n    );\n\n    const handlerResponse = GetMerkleLeafProofCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const maximumPayloadSize = APDU_MAX_PAYLOAD - SHA256_SIZE - 1 - 1;\n    const maximumProofElements = Math.floor(maximumPayloadSize / SHA256_SIZE);\n    const proofElementsToInclude = Math.min(\n      proofElements.length,\n      maximumProofElements,\n    );\n\n    const expectedResponse = new Uint8Array(\n      SHA256_SIZE + 1 + 1 + SHA256_SIZE * proofElementsToInclude,\n    );\n    let responseBufferOffset = 0;\n    expectedResponse.set(leafNodeHash, responseBufferOffset); // leafHash\n    responseBufferOffset += SHA256_SIZE;\n    expectedResponse[responseBufferOffset++] = proofElements.length; // total proof length\n    expectedResponse[responseBufferOffset++] = proofElementsToInclude;\n    for (\n      let proofElementIndex = 0;\n      proofElementIndex < proofElementsToInclude;\n      proofElementIndex++\n    ) {\n      expectedResponse.set(\n        proofElements[proofElementIndex] as Uint8Array,\n        responseBufferOffset,\n      );\n      responseBufferOffset += SHA256_SIZE;\n    }\n\n    // then\n    expect(mockDataStore.getMerkleProof).toHaveBeenCalledWith(\n      merkleRootHash,\n      proofElementIndex,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(\n      proofElements.length - proofElementsToInclude,\n    );\n    for (\n      let queuedProofIndex = 0;\n      queuedProofIndex < commandHandlerContext.queue.length;\n      queuedProofIndex++\n    ) {\n      expect(commandHandlerContext.queue[queuedProofIndex]).toEqual(\n        proofElements[proofElementsToInclude + queuedProofIndex],\n      );\n    }\n  });\n\n  it(\"should return an error when the Merkle proof is not found in the data store\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0x04);\n    const totalElements = 1;\n    const proofElementIndex = 5;\n    const request = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      totalElements,\n      proofElementIndex,\n    );\n\n    // when\n    mockDataStore.getMerkleProof.mockReturnValue(Nothing);\n\n    const handlerResponse = GetMerkleLeafProofCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(handlerResponse.isLeft()).toBe(true);\n    //@ts-ignore\n    const errorResponse = handlerResponse.leftOrDefault(undefined);\n    expect(errorResponse).toBeDefined();\n    expect(errorResponse instanceof ClientCommandHandlerError).toBe(true);\n    expect(mockDataStore.getMerkleProof).toHaveBeenCalledWith(\n      merkleRootHash,\n      proofElementIndex,\n    );\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n});\n"],
-  "mappings": "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",
-  "names": ["APDU_MAX_PAYLOAD", "Just", "Nothing", "ClientCommandCodes", "SHA256_SIZE", "encodeVarint", "ClientCommandHandlerError", "GetMerkleLeafProofCommandHandler", "COMMAND_CODE", "commandHandlerContext", "mockDataStore", "createRequest", "commandCode", "merkleRootHash", "totalElements", "proofElementIndex", "request", "leafNodeHash", "proofElements", "handlerResponse", "maximumPayloadSize", "maximumProofElements", "proofElementsToInclude", "expectedResponse", "responseBufferOffset", "_", "proofIndex", "queuedProofIndex", "errorResponse"]
+  "sourcesContent": ["import { APDU_MAX_PAYLOAD } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\nimport { type Mocked } from \"vitest\";\n\nimport {\n  ClientCommandCodes,\n  SHA256_SIZE,\n} from \"@internal/app-binder/command/utils/constants\";\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\nimport { encodeVarint } from \"@internal/utils/Varint\";\n\nimport { type CommandHandlerContext } from \"./ClientCommandHandlersTypes\";\nimport { ClientCommandHandlerError } from \"./Errors\";\nimport { GetMerkleLeafProofCommandHandler } from \"./GetMerkleLeafProofCommandHandler\";\n\nconst COMMAND_CODE = ClientCommandCodes.GET_MERKLE_LEAF_PROOF;\n\ndescribe(\"GetMerkleLeafProofCommandHandler\", () => {\n  let commandHandlerContext: CommandHandlerContext;\n  let mockDataStore: Mocked<DataStore>;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n\n    mockDataStore = {\n      getMerkleProof: vi.fn(),\n    } as unknown as Mocked<DataStore>;\n\n    commandHandlerContext = {\n      dataStore: mockDataStore,\n      queue: [],\n      yieldedResults: [],\n    };\n  });\n\n  const createRequest = (\n    commandCode: number,\n    merkleRootHash: Uint8Array,\n    totalElements: number,\n    proofElementIndex: number,\n  ): Uint8Array =>\n    new Uint8Array([\n      commandCode,\n      ...merkleRootHash,\n      ...encodeVarint(totalElements).unsafeCoerce(),\n      ...encodeVarint(proofElementIndex).unsafeCoerce(),\n    ]);\n\n  it(\"should return the Merkle leaf and proof when found and proof length is less than or equal to the maximum allowed\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0x01);\n    const totalElements = 1;\n    const proofElementIndex = 2;\n    const request = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      totalElements,\n      proofElementIndex,\n    );\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xaa);\n    const proofElements = [\n      new Uint8Array(SHA256_SIZE).fill(0xbb),\n      new Uint8Array(SHA256_SIZE).fill(0xcc),\n    ];\n\n    // when\n    mockDataStore.getMerkleProof.mockReturnValue(\n      Just({ leafHash: leafNodeHash, proof: proofElements }),\n    );\n\n    const handlerResponse = GetMerkleLeafProofCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const maximumPayloadSize = APDU_MAX_PAYLOAD - SHA256_SIZE - 1 - 1;\n    const maximumProofElements = Math.floor(maximumPayloadSize / SHA256_SIZE);\n    const proofElementsToInclude = Math.min(\n      proofElements.length,\n      maximumProofElements,\n    );\n\n    const expectedResponse = new Uint8Array(\n      SHA256_SIZE + 1 + 1 + SHA256_SIZE * proofElementsToInclude,\n    );\n    let responseBufferOffset = 0;\n    expectedResponse.set(leafNodeHash, responseBufferOffset); // leafHash\n    responseBufferOffset += SHA256_SIZE;\n    expectedResponse[responseBufferOffset++] = proofElements.length; // total proof length\n    expectedResponse[responseBufferOffset++] = proofElementsToInclude;\n    for (let index = 0; index < proofElementsToInclude; index++) {\n      expectedResponse.set(\n        proofElements[index] as Uint8Array,\n        responseBufferOffset,\n      );\n      responseBufferOffset += SHA256_SIZE;\n    }\n\n    // then\n    expect(mockDataStore.getMerkleProof).toHaveBeenCalledWith(\n      merkleRootHash,\n      proofElementIndex,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should handle proof longer than the maximum allowed by queuing the remaining proof elements\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0x02);\n    const totalElements = 1;\n    const proofElementIndex = 3;\n    const request = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      totalElements,\n      proofElementIndex,\n    );\n    const leafNodeHash = new Uint8Array(SHA256_SIZE).fill(0xdd);\n    const totalProofLength = 10;\n    const proofElements = Array.from(\n      { length: totalProofLength },\n      (_, proofIndex) => new Uint8Array(SHA256_SIZE).fill(0xee + proofIndex),\n    );\n\n    // when\n    mockDataStore.getMerkleProof.mockReturnValue(\n      Just({ leafHash: leafNodeHash, proof: proofElements }),\n    );\n\n    const handlerResponse = GetMerkleLeafProofCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const maximumPayloadSize = APDU_MAX_PAYLOAD - SHA256_SIZE - 1 - 1;\n    const maximumProofElements = Math.floor(maximumPayloadSize / SHA256_SIZE);\n    const proofElementsToInclude = Math.min(\n      proofElements.length,\n      maximumProofElements,\n    );\n\n    const expectedResponse = new Uint8Array(\n      SHA256_SIZE + 1 + 1 + SHA256_SIZE * proofElementsToInclude,\n    );\n    let responseBufferOffset = 0;\n    expectedResponse.set(leafNodeHash, responseBufferOffset); // leafHash\n    responseBufferOffset += SHA256_SIZE;\n    expectedResponse[responseBufferOffset++] = proofElements.length; // total proof length\n    expectedResponse[responseBufferOffset++] = proofElementsToInclude;\n    for (let index = 0; index < proofElementsToInclude; index++) {\n      expectedResponse.set(\n        proofElements[index] as Uint8Array,\n        responseBufferOffset,\n      );\n      responseBufferOffset += SHA256_SIZE;\n    }\n\n    // then\n    expect(mockDataStore.getMerkleProof).toHaveBeenCalledWith(\n      merkleRootHash,\n      proofElementIndex,\n    );\n    expect(handlerResponse.isRight()).toBe(true);\n    expect(handlerResponse.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(\n      proofElements.length - proofElementsToInclude,\n    );\n    for (\n      let queuedProofIndex = 0;\n      queuedProofIndex < commandHandlerContext.queue.length;\n      queuedProofIndex++\n    ) {\n      expect(commandHandlerContext.queue[queuedProofIndex]).toEqual(\n        proofElements[proofElementsToInclude + queuedProofIndex],\n      );\n    }\n  });\n\n  it(\"should return an error when the Merkle proof is not found in the data store\", () => {\n    // given\n    const merkleRootHash = new Uint8Array(SHA256_SIZE).fill(0x04);\n    const totalElements = 1;\n    const proofElementIndex = 5;\n    const request = createRequest(\n      COMMAND_CODE,\n      merkleRootHash,\n      totalElements,\n      proofElementIndex,\n    );\n\n    // when\n    mockDataStore.getMerkleProof.mockReturnValue(Nothing);\n\n    const handlerResponse = GetMerkleLeafProofCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(handlerResponse.isLeft()).toBe(true);\n    //@ts-expect-error purposedly use undefined insteal of a DMKError\n    const errorResponse = handlerResponse.leftOrDefault(undefined);\n    expect(errorResponse).toBeDefined();\n    expect(errorResponse instanceof ClientCommandHandlerError).toBe(true);\n    expect(mockDataStore.getMerkleProof).toHaveBeenCalledWith(\n      merkleRootHash,\n      proofElementIndex,\n    );\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,oBAAAA,MAAwB,kCACjC,OAAS,QAAAC,EAAM,WAAAC,MAAe,YAG9B,OACE,sBAAAC,EACA,eAAAC,MACK,+CAEP,OAAS,gBAAAC,MAAoB,yBAG7B,OAAS,6BAAAC,MAAiC,WAC1C,OAAS,oCAAAC,MAAwC,qCAEjD,MAAMC,EAAeL,EAAmB,sBAExC,SAAS,mCAAoC,IAAM,CACjD,IAAIM,EACAC,EAEJ,WAAW,IAAM,CACf,GAAG,cAAc,EAEjBA,EAAgB,CACd,eAAgB,GAAG,GAAG,CACxB,EAEAD,EAAwB,CACtB,UAAWC,EACX,MAAO,CAAC,EACR,eAAgB,CAAC,CACnB,CACF,CAAC,EAED,MAAMC,EAAgB,CACpBC,EACAC,EACAC,EACAC,IAEA,IAAI,WAAW,CACbH,EACA,GAAGC,EACH,GAAGR,EAAaS,CAAa,EAAE,aAAa,EAC5C,GAAGT,EAAaU,CAAiB,EAAE,aAAa,CAClD,CAAC,EAEH,GAAG,mHAAoH,IAAM,CAE3H,MAAMF,EAAiB,IAAI,WAAWT,CAAW,EAAE,KAAK,CAAI,EACtDU,EAAgB,EAChBC,EAAoB,EACpBC,EAAUL,EACdH,EACAK,EACAC,EACAC,CACF,EACME,EAAe,IAAI,WAAWb,CAAW,EAAE,KAAK,GAAI,EACpDc,EAAgB,CACpB,IAAI,WAAWd,CAAW,EAAE,KAAK,GAAI,EACrC,IAAI,WAAWA,CAAW,EAAE,KAAK,GAAI,CACvC,EAGAM,EAAc,eAAe,gBAC3BT,EAAK,CAAE,SAAUgB,EAAc,MAAOC,CAAc,CAAC,CACvD,EAEA,MAAMC,EAAkBZ,EACtBS,EACAP,CACF,EAEMW,EAAqBpB,EAAmBI,EAAc,EAAI,EAC1DiB,EAAuB,KAAK,MAAMD,EAAqBhB,CAAW,EAClEkB,EAAyB,KAAK,IAClCJ,EAAc,OACdG,CACF,EAEME,EAAmB,IAAI,WAC3BnB,EAAc,EAAI,EAAIA,EAAckB,CACtC,EACA,IAAIE,EAAuB,EAC3BD,EAAiB,IAAIN,EAAcO,CAAoB,EACvDA,GAAwBpB,EACxBmB,EAAiBC,GAAsB,EAAIN,EAAc,OACzDK,EAAiBC,GAAsB,EAAIF,EAC3C,QAASG,EAAQ,EAAGA,EAAQH,EAAwBG,IAClDF,EAAiB,IACfL,EAAcO,CAAK,EACnBD,CACF,EACAA,GAAwBpB,EAI1B,OAAOM,EAAc,cAAc,EAAE,qBACnCG,EACAE,CACF,EACA,OAAOI,EAAgB,QAAQ,CAAC,EAAE,KAAK,EAAI,EAC3C,OAAOA,EAAgB,aAAa,CAAC,EAAE,QAAQI,CAAgB,EAC/D,OAAOd,EAAsB,KAAK,EAAE,aAAa,CAAC,CACpD,CAAC,EAED,GAAG,8FAA+F,IAAM,CAEtG,MAAMI,EAAiB,IAAI,WAAWT,CAAW,EAAE,KAAK,CAAI,EACtDU,EAAgB,EAChBC,EAAoB,EACpBC,EAAUL,EACdH,EACAK,EACAC,EACAC,CACF,EACME,EAAe,IAAI,WAAWb,CAAW,EAAE,KAAK,GAAI,EAEpDc,EAAgB,MAAM,KAC1B,CAAE,OAFqB,EAEI,EAC3B,CAACQ,EAAGC,IAAe,IAAI,WAAWvB,CAAW,EAAE,KAAK,IAAOuB,CAAU,CACvE,EAGAjB,EAAc,eAAe,gBAC3BT,EAAK,CAAE,SAAUgB,EAAc,MAAOC,CAAc,CAAC,CACvD,EAEA,MAAMC,EAAkBZ,EACtBS,EACAP,CACF,EAEMW,EAAqBpB,EAAmBI,EAAc,EAAI,EAC1DiB,EAAuB,KAAK,MAAMD,EAAqBhB,CAAW,EAClEkB,EAAyB,KAAK,IAClCJ,EAAc,OACdG,CACF,EAEME,EAAmB,IAAI,WAC3BnB,EAAc,EAAI,EAAIA,EAAckB,CACtC,EACA,IAAIE,EAAuB,EAC3BD,EAAiB,IAAIN,EAAcO,CAAoB,EACvDA,GAAwBpB,EACxBmB,EAAiBC,GAAsB,EAAIN,EAAc,OACzDK,EAAiBC,GAAsB,EAAIF,EAC3C,QAASG,EAAQ,EAAGA,EAAQH,EAAwBG,IAClDF,EAAiB,IACfL,EAAcO,CAAK,EACnBD,CACF,EACAA,GAAwBpB,EAI1B,OAAOM,EAAc,cAAc,EAAE,qBACnCG,EACAE,CACF,EACA,OAAOI,EAAgB,QAAQ,CAAC,EAAE,KAAK,EAAI,EAC3C,OAAOA,EAAgB,aAAa,CAAC,EAAE,QAAQI,CAAgB,EAC/D,OAAOd,EAAsB,KAAK,EAAE,aAClCS,EAAc,OAASI,CACzB,EACA,QACMM,EAAmB,EACvBA,EAAmBnB,EAAsB,MAAM,OAC/CmB,IAEA,OAAOnB,EAAsB,MAAMmB,CAAgB,CAAC,EAAE,QACpDV,EAAcI,EAAyBM,CAAgB,CACzD,CAEJ,CAAC,EAED,GAAG,8EAA+E,IAAM,CAEtF,MAAMf,EAAiB,IAAI,WAAWT,CAAW,EAAE,KAAK,CAAI,EACtDU,EAAgB,EAChBC,EAAoB,EACpBC,EAAUL,EACdH,EACAK,EACAC,EACAC,CACF,EAGAL,EAAc,eAAe,gBAAgBR,CAAO,EAEpD,MAAMiB,EAAkBZ,EACtBS,EACAP,CACF,EAGA,OAAOU,EAAgB,OAAO,CAAC,EAAE,KAAK,EAAI,EAE1C,MAAMU,EAAgBV,EAAgB,cAAc,MAAS,EAC7D,OAAOU,CAAa,EAAE,YAAY,EAClC,OAAOA,aAAyBvB,CAAyB,EAAE,KAAK,EAAI,EACpE,OAAOI,EAAc,cAAc,EAAE,qBACnCG,EACAE,CACF,EACA,OAAON,EAAsB,KAAK,EAAE,aAAa,CAAC,CACpD,CAAC,CACH,CAAC",
+  "names": ["APDU_MAX_PAYLOAD", "Just", "Nothing", "ClientCommandCodes", "SHA256_SIZE", "encodeVarint", "ClientCommandHandlerError", "GetMerkleLeafProofCommandHandler", "COMMAND_CODE", "commandHandlerContext", "mockDataStore", "createRequest", "commandCode", "merkleRootHash", "totalElements", "proofElementIndex", "request", "leafNodeHash", "proofElements", "handlerResponse", "maximumPayloadSize", "maximumProofElements", "proofElementsToInclude", "expectedResponse", "responseBufferOffset", "index", "_", "proofIndex", "queuedProofIndex", "errorResponse"]
 }

package/lib/esm/internal/app-binder/command/client-command-handlers/GetMoreElementsCommandHandler.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{APDU_MAX_PAYLOAD as d}from"@ledgerhq/device-management-kit";import{ClientCommandCodes as g}from"../../../app-binder/command/utils/constants";import{ClientCommandHandlerError as f}from"./Errors";import{GetMoreElementsCommandHandler as l}from"./GetMoreElementsCommandHandler";const i=g.GET_MORE_ELEMENTS;describe("GetMoreElementsCommandHandler",()=>{let t,q;beforeEach(()=>{jest.clearAllMocks(),q={},t={dataStore:q,queue:[],yieldedResults:[]}});const m=o=>new Uint8Array([o]),p=(o,e)=>new Uint8Array(Array(o).fill(e));it("should retrieve the maximum number of elements within the payload size",()=>{const o=m(i),e=50,n=Math.floor((d-1-1)/e),s=Array.from({length:n},(a,u)=>p(e,16+u));t.queue=[...s];const r=l(o,t),c=new Uint8Array(2+n*e);c[0]=n,c[1]=e;for(let a=0;a<n;a++)c.set(s[a],2+a*e);expect(r.isRight()).toBe(!0),expect(r.unsafeCoerce()).toEqual(c),expect(t.queue).toHaveLength(0)}),it("should retrieve the maximum number of elements allowed and queue the remainder",()=>{const o=m(i),e=30,n=Math.floor((d-1-1)/e),s=n+5,r=Array.from({length:s},(u,h)=>p(e,32+h));t.queue=[...r];const c=l(o,t),a=new Uint8Array(2+n*e);a[0]=n,a[1]=e;for(let u=0;u<n;u++)a.set(r[u],2+u*e);expect(c.isRight()).toBe(!0),expect(c.unsafeCoerce()).toEqual(a),expect(t.queue).toHaveLength(s-n);for(let u=0;u<t.queue.length;u++)expect(t.queue[u]).toEqual(r[n+u])}),it("should return an error when queue is empty",()=>{const o=m(i);t.queue=[];const e=l(o,t);expect(e.isLeft()).toBe(!0),e.caseOf({Left:n=>{expect(n).toBeInstanceOf(f),expect(t.queue).toHaveLength(0)},Right:n=>{throw new Error("Expected Left, got Right")}})}),it("should return an error when the first element is undefined",()=>{const o=m(i);t.queue=[void 0];const e=l(o,t);expect(e.isLeft()).toBe(!0),e.caseOf({Left:n=>{expect(n).toBeInstanceOf(f),expect(t.queue).toHaveLength(1)},Right:n=>{throw new Error("Expected Left, got Right")}})}),it("should return an error when elements in queue have varying lengths",()=>{const o=m(i),e=p(40,48),n=p(50,49);t.queue=[e,n];const s=l(o,t);expect(s.isLeft()).toBe(!0),s.caseOf({Left:r=>{expect(r).toBeInstanceOf(f),expect(t.queue).toHaveLength(2)},Right:r=>{throw new Error("Expected Left, got Right")}})}),it("should handle a single element that matches the maximum payload size",()=>{const o=m(i),e=253,n=[p(e,64)];t.queue=[...n];const s=l(o,t),r=new Uint8Array(2+e);r[0]=1,r[1]=e,r.set(n[0],2),expect(s.isRight()).toBe(!0),expect(s.unsafeCoerce()).toEqual(r),expect(t.queue).toHaveLength(0)}),it("should handle a single element that exceeds the maximum payload size",()=>{const o=m(i),e=254,n=[p(e,80)];t.queue=[...n];const s=l(o,t),r=new Uint8Array([0,e]);expect(s.isRight()).toBe(!0),expect(s.unsafeCoerce()).toEqual(r),expect(t.queue).toHaveLength(1)}),it("should handle multiple executions correctly",()=>{const o=m(i),e=60,n=Math.floor((d-1-1)/e),s=10,r=Array.from({length:s},(c,a)=>p(e,96+a));t.queue=[...r];for(let c=0;c<Math.ceil(s/n);c++){const a=t.queue.length,u=Math.min(n,a),h=new Uint8Array(2+u*e);h[0]=u,h[1]=e;for(let x=0;x<u;x++)h.set(t.queue[x],2+x*e);const E=l(o,t);expect(E.isRight()).toBe(!0),expect(E.unsafeCoerce()).toEqual(h),expect(t.queue).toHaveLength(a-u)}expect(t.queue).toHaveLength(0)})});
+import{APDU_MAX_PAYLOAD as x}from"@ledgerhq/device-management-kit";import{ClientCommandCodes as g}from"../../../app-binder/command/utils/constants";import{ClientCommandHandlerError as f}from"./Errors";import{GetMoreElementsCommandHandler as l}from"./GetMoreElementsCommandHandler";const i=g.GET_MORE_ELEMENTS;describe("GetMoreElementsCommandHandler",()=>{let t,q;beforeEach(()=>{vi.clearAllMocks(),q={},t={dataStore:q,queue:[],yieldedResults:[]}});const m=o=>new Uint8Array([o]),p=(o,e)=>new Uint8Array(Array(o).fill(e));it("should retrieve the maximum number of elements within the payload size",()=>{const o=m(i),e=50,n=Math.floor((x-1-1)/e),s=Array.from({length:n},(a,u)=>p(e,16+u));t.queue=[...s];const r=l(o,t),c=new Uint8Array(2+n*e);c[0]=n,c[1]=e;for(let a=0;a<n;a++)c.set(s[a],2+a*e);expect(r.isRight()).toBe(!0),expect(r.unsafeCoerce()).toEqual(c),expect(t.queue).toHaveLength(0)}),it("should retrieve the maximum number of elements allowed and queue the remainder",()=>{const o=m(i),e=30,n=Math.floor((x-1-1)/e),s=n+5,r=Array.from({length:s},(u,h)=>p(e,32+h));t.queue=[...r];const c=l(o,t),a=new Uint8Array(2+n*e);a[0]=n,a[1]=e;for(let u=0;u<n;u++)a.set(r[u],2+u*e);expect(c.isRight()).toBe(!0),expect(c.unsafeCoerce()).toEqual(a),expect(t.queue).toHaveLength(s-n);for(let u=0;u<t.queue.length;u++)expect(t.queue[u]).toEqual(r[n+u])}),it("should return an error when queue is empty",()=>{const o=m(i);t.queue=[];const e=l(o,t);expect(e.isLeft()).toBe(!0),e.caseOf({Left:n=>{expect(n).toBeInstanceOf(f),expect(t.queue).toHaveLength(0)},Right:n=>{throw new Error("Expected Left, got Right")}})}),it("should return an error when the first element is undefined",()=>{const o=m(i);t.queue=[void 0];const e=l(o,t);expect(e.isLeft()).toBe(!0),e.caseOf({Left:n=>{expect(n).toBeInstanceOf(f),expect(t.queue).toHaveLength(1)},Right:n=>{throw new Error("Expected Left, got Right")}})}),it("should return an error when elements in queue have varying lengths",()=>{const o=m(i),e=p(40,48),n=p(50,49);t.queue=[e,n];const s=l(o,t);expect(s.isLeft()).toBe(!0),s.caseOf({Left:r=>{expect(r).toBeInstanceOf(f),expect(t.queue).toHaveLength(2)},Right:r=>{throw new Error("Expected Left, got Right")}})}),it("should handle a single element that matches the maximum payload size",()=>{const o=m(i),e=253,n=[p(e,64)];t.queue=[...n];const s=l(o,t),r=new Uint8Array(2+e);r[0]=1,r[1]=e,r.set(n[0],2),expect(s.isRight()).toBe(!0),expect(s.unsafeCoerce()).toEqual(r),expect(t.queue).toHaveLength(0)}),it("should handle a single element that exceeds the maximum payload size",()=>{const o=m(i),e=254,n=[p(e,80)];t.queue=[...n];const s=l(o,t),r=new Uint8Array([0,e]);expect(s.isRight()).toBe(!0),expect(s.unsafeCoerce()).toEqual(r),expect(t.queue).toHaveLength(1)}),it("should handle multiple executions correctly",()=>{const o=m(i),e=60,n=Math.floor((x-1-1)/e),s=10,r=Array.from({length:s},(c,a)=>p(e,96+a));t.queue=[...r];for(let c=0;c<Math.ceil(s/n);c++){const a=t.queue.length,u=Math.min(n,a),h=new Uint8Array(2+u*e);h[0]=u,h[1]=e;for(let d=0;d<u;d++)h.set(t.queue[d],2+d*e);const E=l(o,t);expect(E.isRight()).toBe(!0),expect(E.unsafeCoerce()).toEqual(h),expect(t.queue).toHaveLength(a-u)}expect(t.queue).toHaveLength(0)})});
 //# sourceMappingURL=GetMoreElementsCommandHandler.test.js.map

package/lib/esm/internal/app-binder/command/client-command-handlers/GetMoreElementsCommandHandler.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/app-binder/command/client-command-handlers/GetMoreElementsCommandHandler.test.ts"],
-  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  type DmkError,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { ClientCommandCodes } from \"@internal/app-binder/command/utils/constants\";\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\n\nimport { type CommandHandlerContext } from \"./ClientCommandHandlersTypes\";\nimport { ClientCommandHandlerError } from \"./Errors\";\nimport { GetMoreElementsCommandHandler } from \"./GetMoreElementsCommandHandler\";\n\nconst COMMAND_CODE = ClientCommandCodes.GET_MORE_ELEMENTS;\n\ndescribe(\"GetMoreElementsCommandHandler\", () => {\n  let commandHandlerContext: CommandHandlerContext;\n  let mockDataStore: jest.Mocked<DataStore>;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n\n    mockDataStore = {} as unknown as jest.Mocked<DataStore>;\n\n    commandHandlerContext = {\n      dataStore: mockDataStore,\n      queue: [],\n      yieldedResults: [],\n    };\n  });\n\n  const buildRequest = (commandCode: number): Uint8Array =>\n    new Uint8Array([commandCode]);\n\n  const createElement = (elementSize: number, fillValue: number): Uint8Array =>\n    new Uint8Array(Array(elementSize).fill(fillValue));\n\n  it(\"should retrieve the maximum number of elements within the payload size\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 50;\n    const maximumElements = Math.floor(\n      (APDU_MAX_PAYLOAD - 1 - 1) / elementSize,\n    );\n    const elements = Array.from({ length: maximumElements }, (_, index) =>\n      createElement(elementSize, 0x10 + index),\n    );\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array(\n      1 + 1 + maximumElements * elementSize,\n    );\n    expectedResponse[0] = maximumElements;\n    expectedResponse[1] = elementSize;\n    for (let elementIndex = 0; elementIndex < maximumElements; elementIndex++) {\n      expectedResponse.set(\n        elements[elementIndex] as Uint8Array,\n        2 + elementIndex * elementSize,\n      );\n    }\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should retrieve the maximum number of elements allowed and queue the remainder\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 30;\n    const maximumElements = Math.floor(\n      (APDU_MAX_PAYLOAD - 1 - 1) / elementSize,\n    );\n    const totalElements = maximumElements + 5;\n    const elements = Array.from({ length: totalElements }, (_, index) =>\n      createElement(elementSize, 0x20 + index),\n    );\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array(\n      1 + 1 + maximumElements * elementSize,\n    );\n    expectedResponse[0] = maximumElements;\n    expectedResponse[1] = elementSize;\n    for (let elementIndex = 0; elementIndex < maximumElements; elementIndex++) {\n      expectedResponse.set(\n        elements[elementIndex] as Uint8Array,\n        2 + elementIndex * elementSize,\n      );\n    }\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(\n      totalElements - maximumElements,\n    );\n    for (\n      let queuedElementIndex = 0;\n      queuedElementIndex < commandHandlerContext.queue.length;\n      queuedElementIndex++\n    ) {\n      expect(commandHandlerContext.queue[queuedElementIndex]).toEqual(\n        elements[maximumElements + queuedElementIndex],\n      );\n    }\n  });\n\n  it(\"should return an error when queue is empty\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n\n    // when\n    commandHandlerContext.queue = [];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(response.isLeft()).toBe(true);\n    response.caseOf({\n      Left: (error: DmkError) => {\n        expect(error).toBeInstanceOf(ClientCommandHandlerError);\n        expect(commandHandlerContext.queue).toHaveLength(0);\n      },\n      Right: (_) => {\n        throw new Error(\"Expected Left, got Right\");\n      },\n    });\n  });\n\n  it(\"should return an error when the first element is undefined\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n\n    // when\n    commandHandlerContext.queue = [undefined as unknown as Uint8Array];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(response.isLeft()).toBe(true);\n    response.caseOf({\n      Left: (error: DmkError) => {\n        expect(error).toBeInstanceOf(ClientCommandHandlerError);\n        expect(commandHandlerContext.queue).toHaveLength(1);\n      },\n      Right: (_) => {\n        throw new Error(\"Expected Left, got Right\");\n      },\n    });\n  });\n\n  it(\"should return an error when elements in queue have varying lengths\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const firstElement = createElement(40, 0x30);\n    const secondElement = createElement(50, 0x31);\n\n    // when\n    commandHandlerContext.queue = [firstElement, secondElement];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(response.isLeft()).toBe(true);\n    response.caseOf({\n      Left: (error: DmkError) => {\n        expect(error).toBeInstanceOf(ClientCommandHandlerError);\n        expect(commandHandlerContext.queue).toHaveLength(2);\n      },\n      Right: (_) => {\n        throw new Error(\"Expected Left, got Right\");\n      },\n    });\n  });\n\n  it(\"should handle a single element that matches the maximum payload size\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 253;\n    const elements = [createElement(elementSize, 0x40)];\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array(1 + 1 + elementSize);\n    expectedResponse[0] = 1;\n    expectedResponse[1] = elementSize;\n    expectedResponse.set(elements[0] as Uint8Array, 2);\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should handle a single element that exceeds the maximum payload size\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 254;\n    const elements = [createElement(elementSize, 0x50)];\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array([0, elementSize]);\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(1); // still there\n  });\n\n  it(\"should handle multiple executions correctly\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 60;\n    const maximumElements = Math.floor(\n      (APDU_MAX_PAYLOAD - 1 - 1) / elementSize,\n    );\n    const totalElements = 10;\n    const elements = Array.from({ length: totalElements }, (_, index) =>\n      createElement(elementSize, 0x60 + index),\n    );\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    // then\n    for (\n      let executionIndex = 0;\n      executionIndex < Math.ceil(totalElements / maximumElements);\n      executionIndex++\n    ) {\n      const previousQueueLength = commandHandlerContext.queue.length;\n      const expectedNumberOfElements = Math.min(\n        maximumElements,\n        previousQueueLength,\n      );\n      const expectedResponse = new Uint8Array(\n        1 + 1 + expectedNumberOfElements * elementSize,\n      );\n      expectedResponse[0] = expectedNumberOfElements;\n      expectedResponse[1] = elementSize;\n      for (\n        let elementIndex = 0;\n        elementIndex < expectedNumberOfElements;\n        elementIndex++\n      ) {\n        expectedResponse.set(\n          commandHandlerContext.queue[elementIndex] as Uint8Array,\n          2 + elementIndex * elementSize,\n        );\n      }\n\n      const response = GetMoreElementsCommandHandler(\n        request,\n        commandHandlerContext,\n      );\n\n      expect(response.isRight()).toBe(true);\n      expect(response.unsafeCoerce()).toEqual(expectedResponse);\n      expect(commandHandlerContext.queue).toHaveLength(\n        previousQueueLength - expectedNumberOfElements,\n      );\n    }\n\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  type DmkError,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Mocked } from \"vitest\";\n\nimport { ClientCommandCodes } from \"@internal/app-binder/command/utils/constants\";\nimport { type DataStore } from \"@internal/data-store/model/DataStore\";\n\nimport { type CommandHandlerContext } from \"./ClientCommandHandlersTypes\";\nimport { ClientCommandHandlerError } from \"./Errors\";\nimport { GetMoreElementsCommandHandler } from \"./GetMoreElementsCommandHandler\";\n\nconst COMMAND_CODE = ClientCommandCodes.GET_MORE_ELEMENTS;\n\ndescribe(\"GetMoreElementsCommandHandler\", () => {\n  let commandHandlerContext: CommandHandlerContext;\n  let mockDataStore: Mocked<DataStore>;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n\n    mockDataStore = {} as unknown as Mocked<DataStore>;\n\n    commandHandlerContext = {\n      dataStore: mockDataStore,\n      queue: [],\n      yieldedResults: [],\n    };\n  });\n\n  const buildRequest = (commandCode: number): Uint8Array =>\n    new Uint8Array([commandCode]);\n\n  const createElement = (elementSize: number, fillValue: number): Uint8Array =>\n    new Uint8Array(Array(elementSize).fill(fillValue));\n\n  it(\"should retrieve the maximum number of elements within the payload size\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 50;\n    const maximumElements = Math.floor(\n      (APDU_MAX_PAYLOAD - 1 - 1) / elementSize,\n    );\n    const elements = Array.from({ length: maximumElements }, (_, index) =>\n      createElement(elementSize, 0x10 + index),\n    );\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array(\n      1 + 1 + maximumElements * elementSize,\n    );\n    expectedResponse[0] = maximumElements;\n    expectedResponse[1] = elementSize;\n    for (let elementIndex = 0; elementIndex < maximumElements; elementIndex++) {\n      expectedResponse.set(\n        elements[elementIndex] as Uint8Array,\n        2 + elementIndex * elementSize,\n      );\n    }\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should retrieve the maximum number of elements allowed and queue the remainder\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 30;\n    const maximumElements = Math.floor(\n      (APDU_MAX_PAYLOAD - 1 - 1) / elementSize,\n    );\n    const totalElements = maximumElements + 5;\n    const elements = Array.from({ length: totalElements }, (_, index) =>\n      createElement(elementSize, 0x20 + index),\n    );\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array(\n      1 + 1 + maximumElements * elementSize,\n    );\n    expectedResponse[0] = maximumElements;\n    expectedResponse[1] = elementSize;\n    for (let elementIndex = 0; elementIndex < maximumElements; elementIndex++) {\n      expectedResponse.set(\n        elements[elementIndex] as Uint8Array,\n        2 + elementIndex * elementSize,\n      );\n    }\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(\n      totalElements - maximumElements,\n    );\n    for (\n      let queuedElementIndex = 0;\n      queuedElementIndex < commandHandlerContext.queue.length;\n      queuedElementIndex++\n    ) {\n      expect(commandHandlerContext.queue[queuedElementIndex]).toEqual(\n        elements[maximumElements + queuedElementIndex],\n      );\n    }\n  });\n\n  it(\"should return an error when queue is empty\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n\n    // when\n    commandHandlerContext.queue = [];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(response.isLeft()).toBe(true);\n    response.caseOf({\n      Left: (error: DmkError) => {\n        expect(error).toBeInstanceOf(ClientCommandHandlerError);\n        expect(commandHandlerContext.queue).toHaveLength(0);\n      },\n      Right: (_) => {\n        throw new Error(\"Expected Left, got Right\");\n      },\n    });\n  });\n\n  it(\"should return an error when the first element is undefined\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n\n    // when\n    commandHandlerContext.queue = [undefined as unknown as Uint8Array];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(response.isLeft()).toBe(true);\n    response.caseOf({\n      Left: (error: DmkError) => {\n        expect(error).toBeInstanceOf(ClientCommandHandlerError);\n        expect(commandHandlerContext.queue).toHaveLength(1);\n      },\n      Right: (_) => {\n        throw new Error(\"Expected Left, got Right\");\n      },\n    });\n  });\n\n  it(\"should return an error when elements in queue have varying lengths\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const firstElement = createElement(40, 0x30);\n    const secondElement = createElement(50, 0x31);\n\n    // when\n    commandHandlerContext.queue = [firstElement, secondElement];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    // then\n    expect(response.isLeft()).toBe(true);\n    response.caseOf({\n      Left: (error: DmkError) => {\n        expect(error).toBeInstanceOf(ClientCommandHandlerError);\n        expect(commandHandlerContext.queue).toHaveLength(2);\n      },\n      Right: (_) => {\n        throw new Error(\"Expected Left, got Right\");\n      },\n    });\n  });\n\n  it(\"should handle a single element that matches the maximum payload size\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 253;\n    const elements = [createElement(elementSize, 0x40)];\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array(1 + 1 + elementSize);\n    expectedResponse[0] = 1;\n    expectedResponse[1] = elementSize;\n    expectedResponse.set(elements[0] as Uint8Array, 2);\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n\n  it(\"should handle a single element that exceeds the maximum payload size\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 254;\n    const elements = [createElement(elementSize, 0x50)];\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    const response = GetMoreElementsCommandHandler(\n      request,\n      commandHandlerContext,\n    );\n\n    const expectedResponse = new Uint8Array([0, elementSize]);\n\n    // then\n    expect(response.isRight()).toBe(true);\n    expect(response.unsafeCoerce()).toEqual(expectedResponse);\n    expect(commandHandlerContext.queue).toHaveLength(1); // still there\n  });\n\n  it(\"should handle multiple executions correctly\", () => {\n    // given\n    const request = buildRequest(COMMAND_CODE);\n    const elementSize = 60;\n    const maximumElements = Math.floor(\n      (APDU_MAX_PAYLOAD - 1 - 1) / elementSize,\n    );\n    const totalElements = 10;\n    const elements = Array.from({ length: totalElements }, (_, index) =>\n      createElement(elementSize, 0x60 + index),\n    );\n\n    // when\n    commandHandlerContext.queue = [...elements];\n\n    // then\n    for (\n      let executionIndex = 0;\n      executionIndex < Math.ceil(totalElements / maximumElements);\n      executionIndex++\n    ) {\n      const previousQueueLength = commandHandlerContext.queue.length;\n      const expectedNumberOfElements = Math.min(\n        maximumElements,\n        previousQueueLength,\n      );\n      const expectedResponse = new Uint8Array(\n        1 + 1 + expectedNumberOfElements * elementSize,\n      );\n      expectedResponse[0] = expectedNumberOfElements;\n      expectedResponse[1] = elementSize;\n      for (\n        let elementIndex = 0;\n        elementIndex < expectedNumberOfElements;\n        elementIndex++\n      ) {\n        expectedResponse.set(\n          commandHandlerContext.queue[elementIndex] as Uint8Array,\n          2 + elementIndex * elementSize,\n        );\n      }\n\n      const response = GetMoreElementsCommandHandler(\n        request,\n        commandHandlerContext,\n      );\n\n      expect(response.isRight()).toBe(true);\n      expect(response.unsafeCoerce()).toEqual(expectedResponse);\n      expect(commandHandlerContext.queue).toHaveLength(\n        previousQueueLength - expectedNumberOfElements,\n      );\n    }\n\n    expect(commandHandlerContext.queue).toHaveLength(0);\n  });\n});\n"],
+  "mappings": "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",
   "names": ["APDU_MAX_PAYLOAD", "ClientCommandCodes", "ClientCommandHandlerError", "GetMoreElementsCommandHandler", "COMMAND_CODE", "commandHandlerContext", "mockDataStore", "buildRequest", "commandCode", "createElement", "elementSize", "fillValue", "request", "maximumElements", "elements", "_", "index", "response", "expectedResponse", "elementIndex", "totalElements", "queuedElementIndex", "error", "firstElement", "secondElement", "executionIndex", "previousQueueLength", "expectedNumberOfElements"]
 }

package/lib/esm/internal/app-binder/command/client-command-handlers/GetPreimageCommandHandler.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{Either as p,Just as x,Nothing as f}from"purify-ts";import{ClientCommandCodes as y,SHA256_SIZE as h}from"../../../app-binder/command/utils/constants";import{encodeVarint as c}from"../../../utils/Varint";import{ClientCommandHandlerError as w}from"./Errors";import{GetPreimageCommandHandler as u}from"./GetPreimageCommandHandler";const g=y.GET_PREIMAGE;jest.mock("@internal/utils/Varint",()=>({encodeVarint:jest.fn()}));describe("GetPreimageCommandHandler",()=>{let t,o;beforeEach(()=>{jest.clearAllMocks(),o={getPreimage:jest.fn()},t={dataStore:o,queue:[],yieldedResults:[]}}),it("should return the preimage when it is found and its length is within the maximum payload size",()=>{const r=new Uint8Array(h).fill(1),e=new Uint8Array([170,187,204]),l=e.length;c.mockReturnValue({unsafeCoerce:()=>new Uint8Array([3])}),o.getPreimage.mockReturnValue(x(e));const s=new Uint8Array([g,0,...r]),i=u(s,t),a=new Uint8Array([3,3,170,187,204]);expect(o.getPreimage).toHaveBeenCalledWith(r),expect(c).toHaveBeenCalledWith(l),i.caseOf({Left:n=>{throw new Error("Expected Right, got Left")},Right:n=>{expect(n).toEqual(a),expect(t.queue).toHaveLength(0)}})}),it("should handle a preimage longer than the maximum payload size by queuing the remaining bytes",()=>{const r=new Uint8Array(h).fill(2),e=new Uint8Array(300).fill(255),l=e.length;c.mockReturnValue({unsafeCoerce:()=>new Uint8Array([172,2])}),o.getPreimage.mockReturnValue(x(e));const s=new Uint8Array([g,0,...r]),i=u(s,t),a=new Uint8Array([172,2]),n=Math.min(255-a.length-1,e.length),m=new Uint8Array(a.length+1+n);m.set(a,0),m.set([n],a.length),m.set(e.slice(0,n),a.length+1),expect(o.getPreimage).toHaveBeenCalledWith(r),expect(c).toHaveBeenCalledWith(l),i.caseOf({Left:d=>{throw new Error("Expected Right, got Left")},Right:d=>{expect(d).toEqual(m),expect(t.queue).toHaveLength(e.length-n),expect(t.queue[0]).toEqual(new Uint8Array([255])),expect(t.queue[t.queue.length-1]).toEqual(new Uint8Array([255]))}})}),it("should return an error when the preimage is not found",()=>{const r=new Uint8Array(h).fill(3);o.getPreimage.mockReturnValue(f);const e=new Uint8Array([g,0,...r]),l=u(e,t);expect(o.getPreimage).toHaveBeenCalledWith(r),expect(c).not.toHaveBeenCalled(),expect(t.queue).toHaveLength(0),l.caseOf({Left:s=>{expect(s).toBeInstanceOf(w)},Right:s=>{throw new Error("Expected Left, got Right")}})}),it("should handle a preimage length where the maximum payload size exactly matches the preimage length",()=>{const r=new Uint8Array(h).fill(5),e=new Uint8Array(252);e.fill(119),c.mockReturnValue({unsafeCoerce:()=>new Uint8Array([252])}),o.getPreimage.mockReturnValue(x(e));const l=new Uint8Array([g,0,...r]),s=u(l,t),i=new Uint8Array([252]),a=Math.min(255-i.length-1,e.length),n=new Uint8Array(i.length+1+a);n.set(i,0),n.set([a],i.length),n.set(e,i.length+1),expect(s).toStrictEqual(p.of(n)),expect(t.queue).toHaveLength(0)})});
+import{Either as p,Just as x,Nothing as f}from"purify-ts";import{ClientCommandCodes as y,SHA256_SIZE as h}from"../../../app-binder/command/utils/constants";import{encodeVarint as l}from"../../../utils/Varint";import{ClientCommandHandlerError as w}from"./Errors";import{GetPreimageCommandHandler as u}from"./GetPreimageCommandHandler";const g=y.GET_PREIMAGE;vi.mock("@internal/utils/Varint",()=>({encodeVarint:vi.fn()}));describe("GetPreimageCommandHandler",()=>{let t,o;beforeEach(()=>{vi.clearAllMocks(),o={getPreimage:vi.fn()},t={dataStore:o,queue:[],yieldedResults:[]}}),it("should return the preimage when it is found and its length is within the maximum payload size",()=>{const r=new Uint8Array(h).fill(1),e=new Uint8Array([170,187,204]),c=e.length;l.mockReturnValue({unsafeCoerce:()=>new Uint8Array([3])}),o.getPreimage.mockReturnValue(x(e));const s=new Uint8Array([g,0,...r]),i=u(s,t),a=new Uint8Array([3,3,170,187,204]);expect(o.getPreimage).toHaveBeenCalledWith(r),expect(l).toHaveBeenCalledWith(c),i.caseOf({Left:n=>{throw new Error("Expected Right, got Left")},Right:n=>{expect(n).toEqual(a),expect(t.queue).toHaveLength(0)}})}),it("should handle a preimage longer than the maximum payload size by queuing the remaining bytes",()=>{const r=new Uint8Array(h).fill(2),e=new Uint8Array(300).fill(255),c=e.length;l.mockReturnValue({unsafeCoerce:()=>new Uint8Array([172,2])}),o.getPreimage.mockReturnValue(x(e));const s=new Uint8Array([g,0,...r]),i=u(s,t),a=new Uint8Array([172,2]),n=Math.min(255-a.length-1,e.length),m=new Uint8Array(a.length+1+n);m.set(a,0),m.set([n],a.length),m.set(e.slice(0,n),a.length+1),expect(o.getPreimage).toHaveBeenCalledWith(r),expect(l).toHaveBeenCalledWith(c),i.caseOf({Left:d=>{throw new Error("Expected Right, got Left")},Right:d=>{expect(d).toEqual(m),expect(t.queue).toHaveLength(e.length-n),expect(t.queue[0]).toEqual(new Uint8Array([255])),expect(t.queue[t.queue.length-1]).toEqual(new Uint8Array([255]))}})}),it("should return an error when the preimage is not found",()=>{const r=new Uint8Array(h).fill(3);o.getPreimage.mockReturnValue(f);const e=new Uint8Array([g,0,...r]),c=u(e,t);expect(o.getPreimage).toHaveBeenCalledWith(r),expect(l).not.toHaveBeenCalled(),expect(t.queue).toHaveLength(0),c.caseOf({Left:s=>{expect(s).toBeInstanceOf(w)},Right:s=>{throw new Error("Expected Left, got Right")}})}),it("should handle a preimage length where the maximum payload size exactly matches the preimage length",()=>{const r=new Uint8Array(h).fill(5),e=new Uint8Array(252);e.fill(119),l.mockReturnValue({unsafeCoerce:()=>new Uint8Array([252])}),o.getPreimage.mockReturnValue(x(e));const c=new Uint8Array([g,0,...r]),s=u(c,t),i=new Uint8Array([252]),a=Math.min(255-i.length-1,e.length),n=new Uint8Array(i.length+1+a);n.set(i,0),n.set([a],i.length),n.set(e,i.length+1),expect(s).toStrictEqual(p.of(n)),expect(t.queue).toHaveLength(0)})});
 //# sourceMappingURL=GetPreimageCommandHandler.test.js.map