@ledgerhq/device-signer-kit-solana 1.0.0

package/lib/esm/internal/app-binder/command/SignOffChainMessageCommand.test.js

@@ -0,0 +1,2 @@
+import{ApduBuilder as i,ApduResponse as a,isSuccessCommandResult as t}from"@ledgerhq/device-management-kit";import{SignOffChainMessageCommand as c}from"./SignOffChainMessageCommand";describe("SignOffChainMessageCommand",()=>{let s;const n=new Uint8Array(Buffer.from("Solana SignOffChainMessage","utf-8")),o=64;beforeEach(()=>{s=new c({message:n,derivationPath:"44'/501'/0'/0'"}),jest.clearAllMocks(),jest.requireActual("@ledgerhq/device-management-kit")}),describe("getApdu",()=>{it("should return the correct APDU",()=>{const r=s.getApdu(),e=new i({cla:224,ins:7,p1:1,p2:0}).addBufferToData(n).build();expect(r.getRawApdu()).toEqual(e.getRawApdu())})}),describe("parseResponse",()=>{it("should parse the response correctly",()=>{const r=new Uint8Array(o).fill(1),e=s.parseResponse(new a({data:r,statusCode:new Uint8Array([144,0])}));expect(t(e)).toBe(!0),t(e)?expect(e.data).toEqual(r):fail("Expected success result")}),describe("error handling",()=>{it("should return error if response is not success",()=>{const r=s.parseResponse(new a({statusCode:new Uint8Array([106,130]),data:new Uint8Array(0)}));expect(t(r)).toBe(!1),t(r)?fail("Expected error"):expect(r.error).toEqual(expect.objectContaining({_tag:"InvalidStatusWordError",originalError:expect.objectContaining({message:"Signature extraction failed"})}))}),it("should return error if signature is missing or incomplete",()=>{const r=new Uint8Array(o-1).fill(1),e=s.parseResponse(new a({data:r,statusCode:new Uint8Array([144,0])}));expect(t(e)).toBe(!1),t(e)?fail("Expected error"):typeof e.error.originalError=="object"&&e.error.originalError!==null&&"message"in e.error.originalError&&expect(e.error.originalError.message).toBe("Signature extraction failed")})})})});
+//# sourceMappingURL=SignOffChainMessageCommand.test.js.map

package/lib/esm/internal/app-binder/command/SignOffChainMessageCommand.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/command/SignOffChainMessageCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduBuilder,\n  ApduResponse,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { SignOffChainMessageCommand } from \"./SignOffChainMessageCommand\";\n\ndescribe(\"SignOffChainMessageCommand\", () => {\n  let command: SignOffChainMessageCommand;\n  const MESSAGE = new Uint8Array(\n    Buffer.from(\"Solana SignOffChainMessage\", \"utf-8\"),\n  );\n  const SIGNATURE_LENGTH = 64;\n\n  beforeEach(() => {\n    command = new SignOffChainMessageCommand({\n      message: MESSAGE,\n      derivationPath: \"44'/501'/0'/0'\",\n    });\n    jest.clearAllMocks();\n    jest.requireActual(\"@ledgerhq/device-management-kit\");\n  });\n\n  describe(\"getApdu\", () => {\n    it(\"should return the correct APDU\", () => {\n      const apdu = command.getApdu();\n\n      const expectedApdu = new ApduBuilder({\n        cla: 0xe0,\n        ins: 0x07,\n        p1: 0x01,\n        p2: 0x00,\n      })\n        .addBufferToData(MESSAGE)\n        .build();\n\n      expect(apdu.getRawApdu()).toEqual(expectedApdu.getRawApdu());\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should parse the response correctly\", () => {\n      const signature = new Uint8Array(SIGNATURE_LENGTH).fill(0x01);\n      const parsed = command.parseResponse(\n        new ApduResponse({\n          data: signature,\n          statusCode: new Uint8Array([0x90, 0x00]),\n        }),\n      );\n\n      expect(isSuccessCommandResult(parsed)).toBe(true);\n      if (isSuccessCommandResult(parsed)) {\n        expect(parsed.data).toEqual(signature);\n      } else {\n        fail(\"Expected success result\");\n      }\n    });\n\n    describe(\"error handling\", () => {\n      it(\"should return error if response is not success\", () => {\n        const result = command.parseResponse(\n          new ApduResponse({\n            statusCode: new Uint8Array([0x6a, 0x82]),\n            data: new Uint8Array(0),\n          }),\n        );\n\n        expect(isSuccessCommandResult(result)).toBe(false);\n        if (!isSuccessCommandResult(result)) {\n          expect(result.error).toEqual(\n            expect.objectContaining({\n              _tag: \"InvalidStatusWordError\", // Adjust this based on your actual implementation\n              originalError: expect.objectContaining({\n                message: \"Signature extraction failed\",\n              }),\n            }),\n          );\n        } else {\n          fail(\"Expected error\");\n        }\n      });\n\n      it(\"should return error if signature is missing or incomplete\", () => {\n        const incompleteSignature = new Uint8Array(SIGNATURE_LENGTH - 1).fill(\n          0x01,\n        );\n        const result = command.parseResponse(\n          new ApduResponse({\n            data: incompleteSignature,\n            statusCode: new Uint8Array([0x90, 0x00]),\n          }),\n        );\n        expect(isSuccessCommandResult(result)).toBe(false);\n        if (!isSuccessCommandResult(result)) {\n          if (\n            typeof result.error.originalError === \"object\" &&\n            result.error.originalError !== null &&\n            \"message\" in result.error.originalError\n          ) {\n            expect(result.error.originalError.message).toBe(\n              \"Signature extraction failed\",\n            );\n          }\n        } else {\n          fail(\"Expected error\");\n        }\n      });\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OACE,eAAAA,EACA,gBAAAC,EACA,0BAAAC,MACK,kCAEP,OAAS,8BAAAC,MAAkC,+BAE3C,SAAS,6BAA8B,IAAM,CAC3C,IAAIC,EACJ,MAAMC,EAAU,IAAI,WAClB,OAAO,KAAK,6BAA8B,OAAO,CACnD,EACMC,EAAmB,GAEzB,WAAW,IAAM,CACfF,EAAU,IAAID,EAA2B,CACvC,QAASE,EACT,eAAgB,gBAClB,CAAC,EACD,KAAK,cAAc,EACnB,KAAK,cAAc,iCAAiC,CACtD,CAAC,EAED,SAAS,UAAW,IAAM,CACxB,GAAG,iCAAkC,IAAM,CACzC,MAAME,EAAOH,EAAQ,QAAQ,EAEvBI,EAAe,IAAIR,EAAY,CACnC,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAI,CACN,CAAC,EACE,gBAAgBK,CAAO,EACvB,MAAM,EAET,OAAOE,EAAK,WAAW,CAAC,EAAE,QAAQC,EAAa,WAAW,CAAC,CAC7D,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,sCAAuC,IAAM,CAC9C,MAAMC,EAAY,IAAI,WAAWH,CAAgB,EAAE,KAAK,CAAI,EACtDI,EAASN,EAAQ,cACrB,IAAIH,EAAa,CACf,KAAMQ,EACN,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,CACzC,CAAC,CACH,EAEA,OAAOP,EAAuBQ,CAAM,CAAC,EAAE,KAAK,EAAI,EAC5CR,EAAuBQ,CAAM,EAC/B,OAAOA,EAAO,IAAI,EAAE,QAAQD,CAAS,EAErC,KAAK,yBAAyB,CAElC,CAAC,EAED,SAAS,iBAAkB,IAAM,CAC/B,GAAG,iDAAkD,IAAM,CACzD,MAAME,EAASP,EAAQ,cACrB,IAAIH,EAAa,CACf,WAAY,IAAI,WAAW,CAAC,IAAM,GAAI,CAAC,EACvC,KAAM,IAAI,WAAW,CAAC,CACxB,CAAC,CACH,EAEA,OAAOC,EAAuBS,CAAM,CAAC,EAAE,KAAK,EAAK,EAC5CT,EAAuBS,CAAM,EAUhC,KAAK,gBAAgB,EATrB,OAAOA,EAAO,KAAK,EAAE,QACnB,OAAO,iBAAiB,CACtB,KAAM,yBACN,cAAe,OAAO,iBAAiB,CACrC,QAAS,6BACX,CAAC,CACH,CAAC,CACH,CAIJ,CAAC,EAED,GAAG,4DAA6D,IAAM,CACpE,MAAMC,EAAsB,IAAI,WAAWN,EAAmB,CAAC,EAAE,KAC/D,CACF,EACMK,EAASP,EAAQ,cACrB,IAAIH,EAAa,CACf,KAAMW,EACN,WAAY,IAAI,WAAW,CAAC,IAAM,CAAI,CAAC,CACzC,CAAC,CACH,EACA,OAAOV,EAAuBS,CAAM,CAAC,EAAE,KAAK,EAAK,EAC5CT,EAAuBS,CAAM,EAWhC,KAAK,gBAAgB,EATnB,OAAOA,EAAO,MAAM,eAAkB,UACtCA,EAAO,MAAM,gBAAkB,MAC/B,YAAaA,EAAO,MAAM,eAE1B,OAAOA,EAAO,MAAM,cAAc,OAAO,EAAE,KACzC,6BACF,CAKN,CAAC,CACH,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["ApduBuilder", "ApduResponse", "isSuccessCommandResult", "SignOffChainMessageCommand", "command", "MESSAGE", "SIGNATURE_LENGTH", "apdu", "expectedApdu", "signature", "parsed", "result", "incompleteSignature"]
+}

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

@@ -0,0 +1,2 @@
+import{ApduBuilder as i,ApduParser as d,CommandResultFactory as a,InvalidStatusWordError as m,isCommandErrorCode as p}from"@ledgerhq/device-management-kit";import{Just as g,Nothing as u}from"purify-ts";import{SolanaAppCommandError as c,solanaAppErrors as t}from"./utils/solanaAppErrors";const l=64;class T{args;constructor(n){this.args=n}getApdu(){const{more:n,extend:o,serializedTransaction:r}=this.args;let e=0;n&&(e|=2),o&&(e|=1);const s={cla:224,ins:6,p1:1,p2:e};return new i(s).addBufferToData(r).build()}parseResponse(n){const o=new d(n),r=o.encodeToHexaString(n.statusCode);if(console.log("Status Code:",n.statusCode),console.log("Error Code:",r),p(r,t))return a({error:new c({...t[r],errorCode:r})});if(o.getUnparsedRemainingLength()===0)return a({data:u});const e=o.extractFieldByLength(l);return e?a({data:g(e)}):a({error:new m("Signature is missing")})}}export{T as SignTransactionCommand};
+//# sourceMappingURL=SignTransactionCommand.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/command/SignTransactionCommand.ts"],
+  "sourcesContent": ["import {\n  type Apdu,\n  ApduBuilder,\n  type ApduBuilderArgs,\n  ApduParser,\n  type ApduResponse,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isCommandErrorCode,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, type Maybe, Nothing } from \"purify-ts\";\n\nimport { type Signature } from \"@api/model/Signature\";\n\nimport {\n  SolanaAppCommandError,\n  solanaAppErrors,\n} from \"./utils/solanaAppErrors\";\n\nconst SIGNATURE_LENGTH = 64;\n\nexport type SignTransactionCommandResponse = Maybe<Signature>;\nexport type SignTransactionCommandArgs = {\n  /**\n   * Chunked serialized transaction\n   */\n  readonly serializedTransaction: Uint8Array;\n  readonly more: boolean;\n  readonly extend: boolean;\n};\n\nexport class SignTransactionCommand\n  implements\n    Command<SignTransactionCommandResponse, SignTransactionCommandArgs>\n{\n  args: SignTransactionCommandArgs;\n\n  constructor(args: SignTransactionCommandArgs) {\n    this.args = args;\n  }\n\n  getApdu(): Apdu {\n    const { more, extend, serializedTransaction } = this.args;\n    let p2 = 0x00;\n    if (more) p2 |= 0x02;\n    if (extend) p2 |= 0x01;\n\n    const signTransactionArgs: ApduBuilderArgs = {\n      cla: 0xe0,\n      ins: 0x06,\n      p1: 0x01,\n      p2,\n    };\n\n    return new ApduBuilder(signTransactionArgs)\n      .addBufferToData(serializedTransaction)\n      .build();\n  }\n\n  parseResponse(\n    response: ApduResponse,\n  ): CommandResult<SignTransactionCommandResponse> {\n    const parser = new ApduParser(response);\n    const errorCode = parser.encodeToHexaString(response.statusCode);\n    console.log(\"Status Code:\", response.statusCode); // Debugging\n    console.log(\"Error Code:\", errorCode); // Debugging\n    if (isCommandErrorCode(errorCode, solanaAppErrors)) {\n      return CommandResultFactory({\n        error: new SolanaAppCommandError({\n          ...solanaAppErrors[errorCode],\n          errorCode,\n        }),\n      });\n    }\n\n    if (parser.getUnparsedRemainingLength() === 0) {\n      return CommandResultFactory({\n        data: Nothing,\n      });\n    }\n\n    const signature = parser.extractFieldByLength(SIGNATURE_LENGTH);\n    if (!signature) {\n      return CommandResultFactory({\n        error: new InvalidStatusWordError(\"Signature is missing\"),\n      });\n    }\n\n    return CommandResultFactory({\n      data: Just(signature),\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,eAAAA,EAEA,cAAAC,EAIA,wBAAAC,EACA,0BAAAC,EACA,sBAAAC,MACK,kCACP,OAAS,QAAAC,EAAkB,WAAAC,MAAe,YAI1C,OACE,yBAAAC,EACA,mBAAAC,MACK,0BAEP,MAAMC,EAAmB,GAYlB,MAAMC,CAGb,CACE,KAEA,YAAYC,EAAkC,CAC5C,KAAK,KAAOA,CACd,CAEA,SAAgB,CACd,KAAM,CAAE,KAAAC,EAAM,OAAAC,EAAQ,sBAAAC,CAAsB,EAAI,KAAK,KACrD,IAAIC,EAAK,EACLH,IAAMG,GAAM,GACZF,IAAQE,GAAM,GAElB,MAAMC,EAAuC,CAC3C,IAAK,IACL,IAAK,EACL,GAAI,EACJ,GAAAD,CACF,EAEA,OAAO,IAAIf,EAAYgB,CAAmB,EACvC,gBAAgBF,CAAqB,EACrC,MAAM,CACX,CAEA,cACEG,EAC+C,CAC/C,MAAMC,EAAS,IAAIjB,EAAWgB,CAAQ,EAChCE,EAAYD,EAAO,mBAAmBD,EAAS,UAAU,EAG/D,GAFA,QAAQ,IAAI,eAAgBA,EAAS,UAAU,EAC/C,QAAQ,IAAI,cAAeE,CAAS,EAChCf,EAAmBe,EAAWX,CAAe,EAC/C,OAAON,EAAqB,CAC1B,MAAO,IAAIK,EAAsB,CAC/B,GAAGC,EAAgBW,CAAS,EAC5B,UAAAA,CACF,CAAC,CACH,CAAC,EAGH,GAAID,EAAO,2BAA2B,IAAM,EAC1C,OAAOhB,EAAqB,CAC1B,KAAMI,CACR,CAAC,EAGH,MAAMc,EAAYF,EAAO,qBAAqBT,CAAgB,EAC9D,OAAKW,EAMElB,EAAqB,CAC1B,KAAMG,EAAKe,CAAS,CACtB,CAAC,EAPQlB,EAAqB,CAC1B,MAAO,IAAIC,EAAuB,sBAAsB,CAC1D,CAAC,CAML,CACF",
+  "names": ["ApduBuilder", "ApduParser", "CommandResultFactory", "InvalidStatusWordError", "isCommandErrorCode", "Just", "Nothing", "SolanaAppCommandError", "solanaAppErrors", "SIGNATURE_LENGTH", "SignTransactionCommand", "args", "more", "extend", "serializedTransaction", "p2", "signTransactionArgs", "response", "parser", "errorCode", "signature"]
+}

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

@@ -0,0 +1,2 @@
+import{ApduResponse as a,CommandResultFactory as o,InvalidStatusWordError as x,isSuccessCommandResult as i}from"@ledgerhq/device-management-kit";import{Just as d,Nothing as p}from"purify-ts";import{SignTransactionCommand as n}from"./SignTransactionCommand";describe("SignTransactionCommand",()=>{const r={serializedTransaction:new Uint8Array,more:!1,extend:!1};describe("getApdu",()=>{it("should return the correct APDU when the data is empty",()=>{const e=new n(r).getApdu();expect(e.data).toStrictEqual(new Uint8Array),expect(e.cla).toBe(224),expect(e.ins).toBe(6),expect(e.p1).toBe(1),expect(e.p2).toBe(0)}),it("should return the correct APDU when the data is not empty",()=>{const e=new n({serializedTransaction:new Uint8Array([1,2,3]),more:!1,extend:!1}).getApdu();expect(e.data).toStrictEqual(new Uint8Array([1,2,3])),expect(e.cla).toBe(224),expect(e.ins).toBe(6),expect(e.p1).toBe(1),expect(e.p2).toBe(0)}),it("should return the correct APDU when the more flag is set",()=>{const e=new n({serializedTransaction:new Uint8Array([1,2,3]),more:!0,extend:!1}).getApdu();expect(e.data).toStrictEqual(new Uint8Array([1,2,3])),expect(e.cla).toBe(224),expect(e.ins).toBe(6),expect(e.p1).toBe(1),expect(e.p2).toBe(2)}),it("should return the correct APDU when the extend flag is set",()=>{const e=new n({serializedTransaction:new Uint8Array([1,2,3]),more:!1,extend:!0}).getApdu();expect(e.data).toStrictEqual(new Uint8Array([1,2,3])),expect(e.cla).toBe(224),expect(e.ins).toBe(6),expect(e.p1).toBe(1),expect(e.p2).toBe(1)}),it("should return the correct APDU when the more and extend flags are set",()=>{const e=new n({serializedTransaction:new Uint8Array([1,2,3]),more:!0,extend:!0}).getApdu();expect(e.data).toStrictEqual(new Uint8Array([1,2,3])),expect(e.cla).toBe(224),expect(e.ins).toBe(6),expect(e.p1).toBe(1),expect(e.p2).toBe(3)})}),describe("parseResponse",()=>{it("should return Noting when the response is empty",()=>{const e=new n(r).parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([])}));expect(e).toStrictEqual(o({data:p}))}),it("should return the signature when the response is not empty",()=>{const t=new n(r),e=new Uint8Array(Array.from({length:64},(m,c)=>c+1)),s=t.parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:e}));expect(s).toStrictEqual(o({data:d(e)}))}),it("should return an error when the response data is not valid",()=>{const e=new n(r).parseResponse(new a({statusCode:Uint8Array.from([144,0]),data:new Uint8Array([1])}));i(e)?fail("The result should be an error."):expect(e.error).toEqual(new x("Signature is missing"))})})});
+//# sourceMappingURL=SignTransactionCommand.test.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/command/SignTransactionCommand.test.ts"],
+  "sourcesContent": ["import {\n  ApduResponse,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport {\n  SignTransactionCommand,\n  type SignTransactionCommandArgs,\n} from \"./SignTransactionCommand\";\n\ndescribe(\"SignTransactionCommand\", () => {\n  const defaultArgs: SignTransactionCommandArgs = {\n    serializedTransaction: new Uint8Array(),\n    more: false,\n    extend: false,\n  };\n\n  describe(\"getApdu\", () => {\n    it(\"should return the correct APDU when the data is empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand(defaultArgs);\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.data).toStrictEqual(new Uint8Array());\n      expect(apdu.cla).toBe(0xe0);\n      expect(apdu.ins).toBe(0x06);\n      expect(apdu.p1).toBe(0x01);\n      expect(apdu.p2).toBe(0x00);\n    });\n\n    it(\"should return the correct APDU when the data is not empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n        more: false,\n        extend: false,\n      });\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n      expect(apdu.cla).toBe(0xe0);\n      expect(apdu.ins).toBe(0x06);\n      expect(apdu.p1).toBe(0x01);\n      expect(apdu.p2).toBe(0x00);\n    });\n\n    it(\"should return the correct APDU when the more flag is set\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n        more: true,\n        extend: false,\n      });\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n      expect(apdu.cla).toBe(0xe0);\n      expect(apdu.ins).toBe(0x06);\n      expect(apdu.p1).toBe(0x01);\n      expect(apdu.p2).toBe(0x02);\n    });\n\n    it(\"should return the correct APDU when the extend flag is set\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n        more: false,\n        extend: true,\n      });\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n      expect(apdu.cla).toBe(0xe0);\n      expect(apdu.ins).toBe(0x06);\n      expect(apdu.p1).toBe(0x01);\n      expect(apdu.p2).toBe(0x01);\n    });\n\n    it(\"should return the correct APDU when the more and extend flags are set\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand({\n        serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n        more: true,\n        extend: true,\n      });\n\n      // WHEN\n      const apdu = command.getApdu();\n\n      // THEN\n      expect(apdu.data).toStrictEqual(new Uint8Array([0x01, 0x02, 0x03]));\n      expect(apdu.cla).toBe(0xe0);\n      expect(apdu.ins).toBe(0x06);\n      expect(apdu.p1).toBe(0x01);\n      expect(apdu.p2).toBe(0x03);\n    });\n  });\n\n  describe(\"parseResponse\", () => {\n    it(\"should return Noting when the response is empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand(defaultArgs);\n\n      // WHEN\n      const result = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: new Uint8Array([]),\n        }),\n      );\n\n      // THEN\n      expect(result).toStrictEqual(CommandResultFactory({ data: Nothing }));\n    });\n\n    it(\"should return the signature when the response is not empty\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand(defaultArgs);\n      const data = new Uint8Array(Array.from({ length: 64 }, (_, i) => i + 1));\n\n      // WHEN\n      const result = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data,\n        }),\n      );\n\n      // THEN\n      expect(result).toStrictEqual(\n        CommandResultFactory({\n          data: Just(data),\n        }),\n      );\n    });\n\n    it(\"should return an error when the response data is not valid\", () => {\n      // GIVEN\n      const command = new SignTransactionCommand(defaultArgs);\n\n      // WHEN\n      const result = command.parseResponse(\n        new ApduResponse({\n          statusCode: Uint8Array.from([0x90, 0x00]),\n          data: new Uint8Array([0x01]),\n        }),\n      );\n\n      // THEN\n      if (isSuccessCommandResult(result))\n        fail(\"The result should be an error.\");\n      else {\n        expect(result.error).toEqual(\n          new InvalidStatusWordError(\"Signature is missing\"),\n        );\n      }\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OACE,gBAAAA,EACA,wBAAAC,EACA,0BAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,QAAAC,EAAM,WAAAC,MAAe,YAE9B,OACE,0BAAAC,MAEK,2BAEP,SAAS,yBAA0B,IAAM,CACvC,MAAMC,EAA0C,CAC9C,sBAAuB,IAAI,WAC3B,KAAM,GACN,OAAQ,EACV,EAEA,SAAS,UAAW,IAAM,CACxB,GAAG,wDAAyD,IAAM,CAKhE,MAAMC,EAHU,IAAIF,EAAuBC,CAAW,EAGjC,QAAQ,EAG7B,OAAOC,EAAK,IAAI,EAAE,cAAc,IAAI,UAAY,EAChD,OAAOA,EAAK,GAAG,EAAE,KAAK,GAAI,EAC1B,OAAOA,EAAK,GAAG,EAAE,KAAK,CAAI,EAC1B,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,EACzB,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,CAC3B,CAAC,EAED,GAAG,4DAA6D,IAAM,CASpE,MAAMA,EAPU,IAAIF,EAAuB,CACzC,sBAAuB,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,EACxD,KAAM,GACN,OAAQ,EACV,CAAC,EAGoB,QAAQ,EAG7B,OAAOE,EAAK,IAAI,EAAE,cAAc,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,CAAC,EAClE,OAAOA,EAAK,GAAG,EAAE,KAAK,GAAI,EAC1B,OAAOA,EAAK,GAAG,EAAE,KAAK,CAAI,EAC1B,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,EACzB,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,CAC3B,CAAC,EAED,GAAG,2DAA4D,IAAM,CASnE,MAAMA,EAPU,IAAIF,EAAuB,CACzC,sBAAuB,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,EACxD,KAAM,GACN,OAAQ,EACV,CAAC,EAGoB,QAAQ,EAG7B,OAAOE,EAAK,IAAI,EAAE,cAAc,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,CAAC,EAClE,OAAOA,EAAK,GAAG,EAAE,KAAK,GAAI,EAC1B,OAAOA,EAAK,GAAG,EAAE,KAAK,CAAI,EAC1B,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,EACzB,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,CAC3B,CAAC,EAED,GAAG,6DAA8D,IAAM,CASrE,MAAMA,EAPU,IAAIF,EAAuB,CACzC,sBAAuB,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,EACxD,KAAM,GACN,OAAQ,EACV,CAAC,EAGoB,QAAQ,EAG7B,OAAOE,EAAK,IAAI,EAAE,cAAc,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,CAAC,EAClE,OAAOA,EAAK,GAAG,EAAE,KAAK,GAAI,EAC1B,OAAOA,EAAK,GAAG,EAAE,KAAK,CAAI,EAC1B,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,EACzB,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,CAC3B,CAAC,EAED,GAAG,wEAAyE,IAAM,CAShF,MAAMA,EAPU,IAAIF,EAAuB,CACzC,sBAAuB,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,EACxD,KAAM,GACN,OAAQ,EACV,CAAC,EAGoB,QAAQ,EAG7B,OAAOE,EAAK,IAAI,EAAE,cAAc,IAAI,WAAW,CAAC,EAAM,EAAM,CAAI,CAAC,CAAC,EAClE,OAAOA,EAAK,GAAG,EAAE,KAAK,GAAI,EAC1B,OAAOA,EAAK,GAAG,EAAE,KAAK,CAAI,EAC1B,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,EACzB,OAAOA,EAAK,EAAE,EAAE,KAAK,CAAI,CAC3B,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,kDAAmD,IAAM,CAK1D,MAAMC,EAHU,IAAIH,EAAuBC,CAAW,EAG/B,cACrB,IAAIP,EAAa,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAC,CACzB,CAAC,CACH,EAGA,OAAOS,CAAM,EAAE,cAAcR,EAAqB,CAAE,KAAMI,CAAQ,CAAC,CAAC,CACtE,CAAC,EAED,GAAG,6DAA8D,IAAM,CAErE,MAAMK,EAAU,IAAIJ,EAAuBC,CAAW,EAChDI,EAAO,IAAI,WAAW,MAAM,KAAK,CAAE,OAAQ,EAAG,EAAG,CAACC,EAAGC,IAAMA,EAAI,CAAC,CAAC,EAGjEJ,EAASC,EAAQ,cACrB,IAAIV,EAAa,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAAW,CACF,CAAC,CACH,EAGA,OAAOF,CAAM,EAAE,cACbR,EAAqB,CACnB,KAAMG,EAAKO,CAAI,CACjB,CAAC,CACH,CACF,CAAC,EAED,GAAG,6DAA8D,IAAM,CAKrE,MAAMF,EAHU,IAAIH,EAAuBC,CAAW,EAG/B,cACrB,IAAIP,EAAa,CACf,WAAY,WAAW,KAAK,CAAC,IAAM,CAAI,CAAC,EACxC,KAAM,IAAI,WAAW,CAAC,CAAI,CAAC,CAC7B,CAAC,CACH,EAGIG,EAAuBM,CAAM,EAC/B,KAAK,gCAAgC,EAErC,OAAOA,EAAO,KAAK,EAAE,QACnB,IAAIP,EAAuB,sBAAsB,CACnD,CAEJ,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["ApduResponse", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "Just", "Nothing", "SignTransactionCommand", "defaultArgs", "apdu", "result", "command", "data", "_", "i"]
+}

package/lib/esm/internal/app-binder/command/utils/solanaAppError.test.js

@@ -0,0 +1,2 @@
+import{DeviceExchangeError as c}from"@ledgerhq/device-management-kit";import{SolanaAppCommandError as t}from"./solanaAppErrors";describe("SolanaAppCommandError",()=>{it("should correctly instantiate with a message and error code",()=>{const e="Invalid data",r="6A80",o=new t({message:e,errorCode:r});expect(o).toBeInstanceOf(t),expect(o.message).toBe(e),expect(o.customErrorCode).toBe(r),expect(o._tag).toBe("SolanaAppCommandError")}),it("should correctly instantiate without an error code",()=>{const e="Some generic error",r=new t({message:e,errorCode:void 0});expect(r).toBeInstanceOf(t),expect(r.message).toBe(e),expect(r.customErrorCode).toBeUndefined(),expect(r._tag).toBe("SolanaAppCommandError")}),it("should handle default message if none is provided",()=>{const e=new t({message:"An error occurred during device exchange.",errorCode:"6A80"});expect(e).toBeInstanceOf(t),expect(e.message).toBe("An error occurred during device exchange."),expect(e.customErrorCode).toBe("6A80"),expect(e._tag).toBe("SolanaAppCommandError")}),it("should extend DeviceExchangeError",()=>{const e="Security status not satisfied",r="6982",o=new t({message:e,errorCode:r});expect(o).toBeInstanceOf(c),expect(o).toBeInstanceOf(t),expect(o._tag).toBe("SolanaAppCommandError"),expect(o.message).toBe(e),expect(o.customErrorCode).toBe(r)}),it("should allow custom properties to be checked",()=>{const e="Invalid parameter",r="6B00",o=new t({message:e,errorCode:r});expect(o.customErrorCode).toBe("6B00"),expect(o.customErrorCode).not.toBe("6A80")})});
+//# sourceMappingURL=solanaAppError.test.js.map

package/lib/esm/internal/app-binder/command/utils/solanaAppError.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/command/utils/solanaAppError.test.ts"],
+  "sourcesContent": ["import { DeviceExchangeError } from \"@ledgerhq/device-management-kit\";\n\nimport { SolanaAppCommandError } from \"./solanaAppErrors\";\n\ndescribe(\"SolanaAppCommandError\", () => {\n  it(\"should correctly instantiate with a message and error code\", () => {\n    const message = \"Invalid data\";\n    const errorCode = \"6A80\";\n\n    const error = new SolanaAppCommandError({\n      message,\n      errorCode,\n    });\n\n    expect(error).toBeInstanceOf(SolanaAppCommandError);\n    expect(error.message).toBe(message);\n    expect(error.customErrorCode).toBe(errorCode);\n    expect(error._tag).toBe(\"SolanaAppCommandError\");\n  });\n\n  it(\"should correctly instantiate without an error code\", () => {\n    const message = \"Some generic error\";\n\n    const error = new SolanaAppCommandError({\n      message,\n      errorCode: undefined,\n    });\n\n    expect(error).toBeInstanceOf(SolanaAppCommandError);\n    expect(error.message).toBe(message);\n    expect(error.customErrorCode).toBeUndefined();\n    expect(error._tag).toBe(\"SolanaAppCommandError\");\n  });\n\n  it(\"should handle default message if none is provided\", () => {\n    const error = new SolanaAppCommandError({\n      message: \"An error occurred during device exchange.\",\n      errorCode: \"6A80\",\n    });\n\n    expect(error).toBeInstanceOf(SolanaAppCommandError);\n    expect(error.message).toBe(\"An error occurred during device exchange.\");\n    expect(error.customErrorCode).toBe(\"6A80\");\n    expect(error._tag).toBe(\"SolanaAppCommandError\");\n  });\n\n  it(\"should extend DeviceExchangeError\", () => {\n    const message = \"Security status not satisfied\";\n    const errorCode = \"6982\";\n\n    const error = new SolanaAppCommandError({\n      message,\n      errorCode,\n    });\n\n    expect(error).toBeInstanceOf(DeviceExchangeError);\n    expect(error).toBeInstanceOf(SolanaAppCommandError);\n    expect(error._tag).toBe(\"SolanaAppCommandError\");\n    expect(error.message).toBe(message);\n    expect(error.customErrorCode).toBe(errorCode);\n  });\n\n  it(\"should allow custom properties to be checked\", () => {\n    const message = \"Invalid parameter\";\n    const errorCode = \"6B00\";\n\n    const error = new SolanaAppCommandError({\n      message,\n      errorCode,\n    });\n\n    expect(error.customErrorCode).toBe(\"6B00\");\n    expect(error.customErrorCode).not.toBe(\"6A80\");\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,uBAAAA,MAA2B,kCAEpC,OAAS,yBAAAC,MAA6B,oBAEtC,SAAS,wBAAyB,IAAM,CACtC,GAAG,6DAA8D,IAAM,CACrE,MAAMC,EAAU,eACVC,EAAY,OAEZC,EAAQ,IAAIH,EAAsB,CACtC,QAAAC,EACA,UAAAC,CACF,CAAC,EAED,OAAOC,CAAK,EAAE,eAAeH,CAAqB,EAClD,OAAOG,EAAM,OAAO,EAAE,KAAKF,CAAO,EAClC,OAAOE,EAAM,eAAe,EAAE,KAAKD,CAAS,EAC5C,OAAOC,EAAM,IAAI,EAAE,KAAK,uBAAuB,CACjD,CAAC,EAED,GAAG,qDAAsD,IAAM,CAC7D,MAAMF,EAAU,qBAEVE,EAAQ,IAAIH,EAAsB,CACtC,QAAAC,EACA,UAAW,MACb,CAAC,EAED,OAAOE,CAAK,EAAE,eAAeH,CAAqB,EAClD,OAAOG,EAAM,OAAO,EAAE,KAAKF,CAAO,EAClC,OAAOE,EAAM,eAAe,EAAE,cAAc,EAC5C,OAAOA,EAAM,IAAI,EAAE,KAAK,uBAAuB,CACjD,CAAC,EAED,GAAG,oDAAqD,IAAM,CAC5D,MAAMA,EAAQ,IAAIH,EAAsB,CACtC,QAAS,4CACT,UAAW,MACb,CAAC,EAED,OAAOG,CAAK,EAAE,eAAeH,CAAqB,EAClD,OAAOG,EAAM,OAAO,EAAE,KAAK,2CAA2C,EACtE,OAAOA,EAAM,eAAe,EAAE,KAAK,MAAM,EACzC,OAAOA,EAAM,IAAI,EAAE,KAAK,uBAAuB,CACjD,CAAC,EAED,GAAG,oCAAqC,IAAM,CAC5C,MAAMF,EAAU,gCACVC,EAAY,OAEZC,EAAQ,IAAIH,EAAsB,CACtC,QAAAC,EACA,UAAAC,CACF,CAAC,EAED,OAAOC,CAAK,EAAE,eAAeJ,CAAmB,EAChD,OAAOI,CAAK,EAAE,eAAeH,CAAqB,EAClD,OAAOG,EAAM,IAAI,EAAE,KAAK,uBAAuB,EAC/C,OAAOA,EAAM,OAAO,EAAE,KAAKF,CAAO,EAClC,OAAOE,EAAM,eAAe,EAAE,KAAKD,CAAS,CAC9C,CAAC,EAED,GAAG,+CAAgD,IAAM,CACvD,MAAMD,EAAU,oBACVC,EAAY,OAEZC,EAAQ,IAAIH,EAAsB,CACtC,QAAAC,EACA,UAAAC,CACF,CAAC,EAED,OAAOC,EAAM,eAAe,EAAE,KAAK,MAAM,EACzC,OAAOA,EAAM,eAAe,EAAE,IAAI,KAAK,MAAM,CAC/C,CAAC,CACH,CAAC",
+  "names": ["DeviceExchangeError", "SolanaAppCommandError", "message", "errorCode", "error"]
+}

package/lib/esm/internal/app-binder/command/utils/solanaAppErrors.js

@@ -0,0 +1,2 @@
+import{DeviceExchangeError as o}from"@ledgerhq/device-management-kit";const n={6700:{message:"Incorrect length"},6982:{message:"Security status not satisfied (Canceled by user)"},"6A80":{message:"Invalid data"},"6A81":{message:"Invalid off-chain message header"},"6A82":{message:"Invalid off-chain message format"},"6B00":{message:"Incorrect parameter P1 or P2"}};class m extends o{constructor({message:r,errorCode:e}){super({tag:"SolanaAppCommandError",message:r||"An error occurred during device exchange.",errorCode:void 0}),this.customErrorCode=e||void 0}customErrorCode}export{m as SolanaAppCommandError,n as solanaAppErrors};
+//# sourceMappingURL=solanaAppErrors.js.map

package/lib/esm/internal/app-binder/command/utils/solanaAppErrors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/command/utils/solanaAppErrors.ts"],
+  "sourcesContent": ["import {\n  type CommandErrorArgs,\n  type CommandErrors,\n  DeviceExchangeError,\n  type DmkError,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type SolanaAppErrorCodes =\n  | \"6700\"\n  | \"6982\"\n  | \"6A80\"\n  | \"6A81\"\n  | \"6A82\"\n  | \"6B00\";\n\nexport const solanaAppErrors: CommandErrors<SolanaAppErrorCodes> = {\n  \"6700\": { message: \"Incorrect length\" },\n  \"6982\": { message: \"Security status not satisfied (Canceled by user)\" },\n  \"6A80\": { message: \"Invalid data\" },\n  \"6A81\": { message: \"Invalid off-chain message header\" },\n  \"6A82\": { message: \"Invalid off-chain message format\" },\n  \"6B00\": { message: \"Incorrect parameter P1 or P2\" },\n};\n\nexport class SolanaAppCommandError\n  extends DeviceExchangeError<void>\n  implements DmkError\n{\n  constructor({\n    message,\n    errorCode,\n  }: CommandErrorArgs<SolanaAppErrorCodes | void>) {\n    super({\n      tag: \"SolanaAppCommandError\",\n      message: message || \"An error occurred during device exchange.\",\n      errorCode: undefined,\n    });\n    this.customErrorCode = errorCode || undefined;\n  }\n  customErrorCode?: SolanaAppErrorCodes;\n}\n"],
+  "mappings": "AAAA,OAGE,uBAAAA,MAEK,kCAUA,MAAMC,EAAsD,CACjE,KAAQ,CAAE,QAAS,kBAAmB,EACtC,KAAQ,CAAE,QAAS,kDAAmD,EACtE,OAAQ,CAAE,QAAS,cAAe,EAClC,OAAQ,CAAE,QAAS,kCAAmC,EACtD,OAAQ,CAAE,QAAS,kCAAmC,EACtD,OAAQ,CAAE,QAAS,8BAA+B,CACpD,EAEO,MAAMC,UACHF,CAEV,CACE,YAAY,CACV,QAAAG,EACA,UAAAC,CACF,EAAiD,CAC/C,MAAM,CACJ,IAAK,wBACL,QAASD,GAAW,4CACpB,UAAW,MACb,CAAC,EACD,KAAK,gBAAkBC,GAAa,MACtC,CACA,eACF",
+  "names": ["DeviceExchangeError", "solanaAppErrors", "SolanaAppCommandError", "message", "errorCode"]
+}

package/lib/esm/internal/app-binder/device-action/SignMessage/SignMessageDeviceAction.js

@@ -0,0 +1,2 @@
+import{isSuccessCommandResult as g,OpenAppDeviceAction as o,UnknownDAError as p,UserInteractionRequired as r,XStateDeviceAction as u}from"@ledgerhq/device-management-kit";import{Left as S,Right as c}from"purify-ts";import{assign as n,fromPromise as l,setup as M}from"xstate";import{SendSignMessageTask as d}from"../../../app-binder/task/SendSignMessageTask";class E extends u{makeStateMachine(a){const{signMessage:s}=this.extractDependencies(a);return M({types:{input:{},context:{},output:{}},actors:{openAppStateMachine:new o({input:{appName:"Solana"}}).makeStateMachine(a),signMessage:l(s)},guards:{noInternalError:({context:e})=>e._internalState.error===null,messageSizeWithinLimit:({context:e})=>5+new TextEncoder().encode(e.input.message).length<=255},actions:{assignErrorFromEvent:n({_internalState:({context:e,event:t})=>({...e._internalState,error:t.data})}),assignErrorMessageTooBig:n({_internalState:({context:e})=>({...e._internalState,error:{_tag:"InvalidMessageSizeError",errorCode:"MessageTooLarge",message:"The APDU command exceeds the maximum allowable size (255 bytes)"}})})}}).createMachine({id:"SignMessageDeviceAction",initial:"OpenAppDeviceAction",context:({input:e})=>({input:e,intermediateValue:{requiredUserInteraction:r.None},_internalState:{error:null,signature:null}}),states:{OpenAppDeviceAction:{exit:n({intermediateValue:{requiredUserInteraction:r.None}}),invoke:{id:"openAppStateMachine",input:{appName:"Solana"},src:"openAppStateMachine",onSnapshot:{actions:n({intermediateValue:({event:e})=>e.snapshot.context.intermediateValue})},onDone:{actions:n({_internalState:({event:e,context:t})=>e.output.caseOf({Right:()=>t._internalState,Left:i=>({...t._internalState,error:i})})}),target:"CheckOpenAppDeviceActionResult"},onError:{target:"Error",actions:"assignErrorFromEvent"}}},CheckOpenAppDeviceActionResult:{always:[{target:"CheckMessageSize",guard:"noInternalError"},"Error"]},CheckMessageSize:{always:[{target:"SignMessage",guard:"messageSizeWithinLimit"},{target:"Error",actions:"assignErrorMessageTooBig"}]},SignMessage:{entry:n({intermediateValue:{requiredUserInteraction:r.SignPersonalMessage}}),exit:n({intermediateValue:{requiredUserInteraction:r.None}}),invoke:{id:"signMessage",src:"signMessage",input:({context:e})=>({derivationPath:e.input.derivationPath,sendingData:new TextEncoder().encode(e.input.message)}),onDone:{target:"SignMessageResultCheck",actions:[n({_internalState:({event:e,context:t})=>g(e.output)?{...t._internalState,signature:e.output.data}:{...t._internalState,error:e.output.error}})]},onError:{target:"Error",actions:"assignErrorFromEvent"}}},SignMessageResultCheck:{always:[{guard:"noInternalError",target:"Success"},{target:"Error"}]},Success:{type:"final"},Error:{type:"final"}},output:({context:e})=>e._internalState.signature?c(e._internalState.signature):S(e._internalState.error||new p("No error in final state"))})}extractDependencies(a){return{signMessage:async e=>await new d(a,e.input).run()}}}export{E as SignMessageDeviceAction};
+//# sourceMappingURL=SignMessageDeviceAction.js.map

package/lib/esm/internal/app-binder/device-action/SignMessage/SignMessageDeviceAction.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/device-action/SignMessage/SignMessageDeviceAction.ts"],
+  "sourcesContent": ["import {\n  type CommandResult,\n  //CommandResultStatus,\n  type DeviceActionStateMachine,\n  type InternalApi,\n  isSuccessCommandResult,\n  OpenAppDeviceAction,\n  type StateMachineTypes,\n  UnknownDAError,\n  UserInteractionRequired,\n  XStateDeviceAction,\n} from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\nimport { assign, fromPromise, setup } from \"xstate\";\n\nimport {\n  type SignMessageDAError,\n  type SignMessageDAInput,\n  type SignMessageDAIntermediateValue,\n  type SignMessageDAInternalState,\n  type SignMessageDAOutput,\n} from \"@api/app-binder/SignMessageDeviceActionTypes\";\nimport { type Signature } from \"@api/model/Signature\";\nimport {\n  SendSignMessageTask,\n  type SendSignMessageTaskArgs,\n} from \"@internal/app-binder/task/SendSignMessageTask\";\n\nexport type MachineDependencies = {\n  readonly signMessage: (arg0: {\n    input: SendSignMessageTaskArgs;\n  }) => Promise<CommandResult<Signature>>;\n};\n\nexport type ExtractMachineDependencies = (\n  internalApi: InternalApi,\n) => MachineDependencies;\n\nexport class SignMessageDeviceAction extends XStateDeviceAction<\n  SignMessageDAOutput,\n  SignMessageDAInput,\n  SignMessageDAError,\n  SignMessageDAIntermediateValue,\n  SignMessageDAInternalState\n> {\n  makeStateMachine(\n    internalApi: InternalApi,\n  ): DeviceActionStateMachine<\n    SignMessageDAOutput,\n    SignMessageDAInput,\n    SignMessageDAError,\n    SignMessageDAIntermediateValue,\n    SignMessageDAInternalState\n  > {\n    type types = StateMachineTypes<\n      SignMessageDAOutput,\n      SignMessageDAInput,\n      SignMessageDAError,\n      SignMessageDAIntermediateValue,\n      SignMessageDAInternalState\n    >;\n\n    const { signMessage } = this.extractDependencies(internalApi);\n\n    return setup({\n      types: {\n        input: {} as types[\"input\"],\n        context: {} as types[\"context\"],\n        output: {} as types[\"output\"],\n      },\n      actors: {\n        openAppStateMachine: new OpenAppDeviceAction({\n          input: { appName: \"Solana\" },\n        }).makeStateMachine(internalApi),\n        signMessage: fromPromise(signMessage),\n      },\n      guards: {\n        noInternalError: ({ context }) => context._internalState.error === null,\n        messageSizeWithinLimit: ({ context }) => {\n          const messageSize = new TextEncoder().encode(\n            context.input.message,\n          ).length;\n          const apduHeaderSize = 5;\n\n          return apduHeaderSize + messageSize <= 255;\n        },\n      },\n      actions: {\n        assignErrorFromEvent: assign({\n          _internalState: ({ context, event }) => ({\n            ...context._internalState,\n            error: event[\"data\"] as SignMessageDAError,\n          }),\n        }),\n        assignErrorMessageTooBig: assign({\n          _internalState: ({ context }) => ({\n            ...context._internalState,\n            error: {\n              _tag: \"InvalidMessageSizeError\",\n              errorCode: \"MessageTooLarge\",\n              message:\n                \"The APDU command exceeds the maximum allowable size (255 bytes)\",\n            } as SignMessageDAError,\n          }),\n        }),\n      },\n    }).createMachine({\n      id: \"SignMessageDeviceAction\",\n      initial: \"OpenAppDeviceAction\",\n      context: ({ input }) => {\n        return {\n          input,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          _internalState: {\n            error: null,\n            signature: null,\n          },\n        };\n      },\n      states: {\n        OpenAppDeviceAction: {\n          exit: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          invoke: {\n            id: \"openAppStateMachine\",\n            input: { appName: \"Solana\" },\n            src: \"openAppStateMachine\",\n            onSnapshot: {\n              actions: assign({\n                intermediateValue: ({ event }) =>\n                  event.snapshot.context.intermediateValue,\n              }),\n            },\n            onDone: {\n              actions: assign({\n                _internalState: ({ event, context }) => {\n                  return event.output.caseOf<SignMessageDAInternalState>({\n                    Right: () => context._internalState,\n                    Left: (error) => ({\n                      ...context._internalState,\n                      error,\n                    }),\n                  });\n                },\n              }),\n              target: \"CheckOpenAppDeviceActionResult\",\n            },\n            onError: {\n              target: \"Error\",\n              actions: \"assignErrorFromEvent\",\n            },\n          },\n        },\n        CheckOpenAppDeviceActionResult: {\n          always: [\n            {\n              target: \"CheckMessageSize\",\n              guard: \"noInternalError\",\n            },\n            \"Error\",\n          ],\n        },\n        CheckMessageSize: {\n          always: [\n            {\n              target: \"SignMessage\",\n              guard: \"messageSizeWithinLimit\",\n            },\n            {\n              target: \"Error\",\n              actions: \"assignErrorMessageTooBig\",\n            },\n          ],\n        },\n        SignMessage: {\n          entry: assign({\n            intermediateValue: {\n              requiredUserInteraction:\n                UserInteractionRequired.SignPersonalMessage,\n            },\n          }),\n          exit: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          invoke: {\n            id: \"signMessage\",\n            src: \"signMessage\",\n            input: ({ context }) => ({\n              derivationPath: context.input.derivationPath,\n              sendingData: new TextEncoder().encode(context.input.message),\n            }),\n            onDone: {\n              target: \"SignMessageResultCheck\",\n              actions: [\n                assign({\n                  _internalState: ({ event, context }) => {\n                    if (isSuccessCommandResult(event.output)) {\n                      return {\n                        ...context._internalState,\n                        signature: event.output.data,\n                      };\n                    }\n                    return {\n                      ...context._internalState,\n                      error: event.output.error,\n                    };\n                  },\n                }),\n              ],\n            },\n            onError: {\n              target: \"Error\",\n              actions: \"assignErrorFromEvent\",\n            },\n          },\n        },\n        SignMessageResultCheck: {\n          always: [\n            { guard: \"noInternalError\", target: \"Success\" },\n            { target: \"Error\" },\n          ],\n        },\n        Success: {\n          type: \"final\",\n        },\n        Error: {\n          type: \"final\",\n        },\n      },\n      output: ({ context }) =>\n        context._internalState.signature\n          ? Right(context._internalState.signature)\n          : Left(\n              context._internalState.error ||\n                new UnknownDAError(\"No error in final state\"),\n            ),\n    });\n  }\n\n  extractDependencies(internalApi: InternalApi): MachineDependencies {\n    const signMessage = async (arg0: { input: SendSignMessageTaskArgs }) => {\n      const result = await new SendSignMessageTask(\n        internalApi,\n        arg0.input,\n      ).run();\n      return result;\n    };\n\n    return {\n      signMessage,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["isSuccessCommandResult", "OpenAppDeviceAction", "UnknownDAError", "UserInteractionRequired", "XStateDeviceAction", "Left", "Right", "assign", "fromPromise", "setup", "SendSignMessageTask", "SignMessageDeviceAction", "internalApi", "signMessage", "context", "event", "input", "error", "arg0"]
+}

package/lib/esm/internal/app-binder/device-action/SignMessage/SignMessageDeviceAction.test.js

@@ -0,0 +1,2 @@
+import{CommandResultFactory as A,DeviceActionStatus as t,UnknownDeviceExchangeError as d,UserInteractionRequired as n}from"@ledgerhq/device-management-kit";import{UnknownDAError as v}from"@ledgerhq/device-management-kit";import{makeDeviceActionInternalApiMock as l}from"../../../app-binder/device-action/__test-utils__/makeInternalApi";import{setupOpenAppDAMock as p}from"../../../app-binder/device-action/__test-utils__/setupOpenAppDAMock";import{testDeviceActionStates as u}from"../../../app-binder/device-action/__test-utils__/testDeviceActionStates";import{SignMessageDeviceAction as m}from"../../../app-binder/device-action/SignMessage/SignMessageDeviceAction";jest.mock("@ledgerhq/device-management-kit",()=>({...jest.requireActual("@ledgerhq/device-management-kit"),OpenAppDeviceAction:jest.fn(()=>({makeStateMachine:jest.fn()}))}));describe("SignMessageDeviceAction",()=>{const s=jest.fn();function c(){return{signMessage:s}}beforeEach(()=>{jest.resetAllMocks()}),describe("Success case",()=>{it("should call external dependencies with the correct parameters",e=>{p();const i=new m({input:{derivationPath:"44'/501'/0'/0'",message:"Hello world"}});jest.spyOn(i,"extractDependencies").mockImplementation(()=>c());const a=new Uint8Array([]);s.mockResolvedValueOnce(A({data:a}));const o=[{intermediateValue:{requiredUserInteraction:n.None},status:t.Pending},{intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp},status:t.Pending},{intermediateValue:{requiredUserInteraction:n.SignPersonalMessage},status:t.Pending},{output:a,status:t.Completed}],{observable:r}=u(i,o,l());r.subscribe({complete:()=>{try{expect(s).toHaveBeenCalledWith(expect.objectContaining({input:expect.objectContaining({derivationPath:"44'/501'/0'/0'",sendingData:new TextEncoder().encode("Hello world")})})),e()}catch(g){e(g)}},error:g=>{e(g)}})})}),describe("error cases",()=>{it("Error if the open app fails",e=>{p(new d("Mocked error"));const i=[{status:t.Pending,intermediateValue:{requiredUserInteraction:n.None}},{status:t.Pending,intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp}},{status:t.Error,error:new d("Mocked error")}],a=new m({input:{derivationPath:"44'/60'/0'/0/0",message:"Hello world"}});jest.spyOn(a,"extractDependencies").mockImplementation(()=>c());const{observable:o}=u(a,i,l());o.subscribe({complete:()=>{try{expect(s).not.toHaveBeenCalled(),e()}catch(r){e(r)}},error:r=>{e(r)}})}),it("Error if the signMessage fails",e=>{p();const i=new m({input:{derivationPath:"44'/60'/0'/0/0",message:"Hello world"}});jest.spyOn(i,"extractDependencies").mockImplementation(()=>c()),s.mockResolvedValueOnce(A({error:new d("Mocked error")}));const a=[{status:t.Pending,intermediateValue:{requiredUserInteraction:n.None}},{status:t.Pending,intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp}},{status:t.Pending,intermediateValue:{requiredUserInteraction:n.SignPersonalMessage}},{status:t.Error,error:new d("Mocked error")}],{observable:o}=u(i,a,l());o.subscribe({complete:()=>{try{expect(s).toHaveBeenCalled(),e()}catch(r){e(r)}},error:r=>{e(r)}})}),it("Return a Left if the final state has no signature",e=>{p();const i=new m({input:{derivationPath:"44'/60'/0'/0/0",message:"Hello world"}});jest.spyOn(i,"extractDependencies").mockImplementation(()=>c()),s.mockResolvedValueOnce(A({data:void 0}));const a=[{status:t.Pending,intermediateValue:{requiredUserInteraction:n.None}},{status:t.Pending,intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp}},{status:t.Pending,intermediateValue:{requiredUserInteraction:n.SignPersonalMessage}},{status:t.Error,error:new v("No error in final state")}],{observable:o}=u(i,a,l());o.subscribe({complete:()=>{try{expect(s).toHaveBeenCalledWith(expect.objectContaining({input:expect.objectContaining({derivationPath:"44'/60'/0'/0/0",sendingData:new TextEncoder().encode("Hello world")})})),e()}catch(r){e(r)}},error:r=>{e(r)}})})})});
+//# sourceMappingURL=SignMessageDeviceAction.test.js.map

package/lib/esm/internal/app-binder/device-action/SignMessage/SignMessageDeviceAction.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/device-action/SignMessage/SignMessageDeviceAction.test.ts"],
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  DeviceActionStatus,\n  UnknownDeviceExchangeError,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { UnknownDAError } from \"@ledgerhq/device-management-kit\";\n\nimport { type SignMessageDAState } from \"@api/app-binder/SignMessageDeviceActionTypes\";\nimport { makeDeviceActionInternalApiMock } from \"@internal/app-binder/device-action/__test-utils__/makeInternalApi\";\nimport { setupOpenAppDAMock } from \"@internal/app-binder/device-action/__test-utils__/setupOpenAppDAMock\";\nimport { testDeviceActionStates } from \"@internal/app-binder/device-action/__test-utils__/testDeviceActionStates\";\nimport { SignMessageDeviceAction } from \"@internal/app-binder/device-action/SignMessage/SignMessageDeviceAction\";\n\njest.mock(\n  \"@ledgerhq/device-management-kit\",\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  () => ({\n    ...jest.requireActual(\"@ledgerhq/device-management-kit\"),\n    OpenAppDeviceAction: jest.fn(() => ({\n      makeStateMachine: jest.fn(),\n    })),\n  }),\n);\n\ndescribe(\"SignMessageDeviceAction\", () => {\n  const signMessageMock = jest.fn();\n\n  function extractDependenciesMock() {\n    return {\n      signMessage: signMessageMock,\n    };\n  }\n\n  beforeEach(() => {\n    jest.resetAllMocks();\n  });\n\n  describe(\"Success case\", () => {\n    it(\"should call external dependencies with the correct parameters\", (done) => {\n      setupOpenAppDAMock();\n\n      const deviceAction = new SignMessageDeviceAction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          message: \"Hello world\",\n        },\n      });\n\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockImplementation(() => extractDependenciesMock());\n\n      const signatureData = new Uint8Array([\n        // signature data...\n      ]);\n\n      signMessageMock.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: signatureData,\n        }),\n      );\n\n      const expectedStates: Array<SignMessageDAState> = [\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        {\n          intermediateValue: {\n            requiredUserInteraction:\n              UserInteractionRequired.SignPersonalMessage,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        {\n          output: signatureData,\n          status: DeviceActionStatus.Completed,\n        },\n      ];\n\n      const { observable } = testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n      );\n\n      observable.subscribe({\n        complete: () => {\n          try {\n            expect(signMessageMock).toHaveBeenCalledWith(\n              expect.objectContaining({\n                input: expect.objectContaining({\n                  derivationPath: \"44'/501'/0'/0'\",\n                  sendingData: new TextEncoder().encode(\"Hello world\"),\n                }),\n              }),\n            );\n            done();\n          } catch (error) {\n            done(error);\n          }\n        },\n        error: (err) => {\n          done(err);\n        },\n      });\n    });\n  });\n\n  describe(\"error cases\", () => {\n    it(\"Error if the open app fails\", (done) => {\n      setupOpenAppDAMock(new UnknownDeviceExchangeError(\"Mocked error\"));\n\n      const expectedStates: Array<SignMessageDAState> = [\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n        },\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n        },\n        {\n          status: DeviceActionStatus.Error,\n          error: new UnknownDeviceExchangeError(\"Mocked error\"),\n        },\n      ];\n\n      const deviceAction = new SignMessageDeviceAction({\n        input: {\n          derivationPath: \"44'/60'/0'/0/0\",\n          message: \"Hello world\",\n        },\n      });\n\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockImplementation(() => extractDependenciesMock());\n\n      const { observable } = testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n      );\n\n      observable.subscribe({\n        complete: () => {\n          try {\n            expect(signMessageMock).not.toHaveBeenCalled();\n            done();\n          } catch (error) {\n            done(error);\n          }\n        },\n        error: (err) => {\n          done(err);\n        },\n      });\n    });\n\n    it(\"Error if the signMessage fails\", (done) => {\n      setupOpenAppDAMock();\n\n      const deviceAction = new SignMessageDeviceAction({\n        input: {\n          derivationPath: \"44'/60'/0'/0/0\",\n          message: \"Hello world\",\n        },\n      });\n\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockImplementation(() => extractDependenciesMock());\n\n      signMessageMock.mockResolvedValueOnce(\n        CommandResultFactory({\n          error: new UnknownDeviceExchangeError(\"Mocked error\"),\n        }),\n      );\n\n      const expectedStates: Array<SignMessageDAState> = [\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n        },\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n        },\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction:\n              UserInteractionRequired.SignPersonalMessage,\n          },\n        },\n        {\n          status: DeviceActionStatus.Error,\n          error: new UnknownDeviceExchangeError(\"Mocked error\"),\n        },\n      ];\n\n      const { observable } = testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n      );\n\n      observable.subscribe({\n        complete: () => {\n          try {\n            expect(signMessageMock).toHaveBeenCalled();\n            done();\n          } catch (error) {\n            done(error);\n          }\n        },\n        error: (err) => {\n          done(err);\n        },\n      });\n    });\n\n    it(\"Return a Left if the final state has no signature\", (done) => {\n      setupOpenAppDAMock();\n\n      const deviceAction = new SignMessageDeviceAction({\n        input: {\n          derivationPath: \"44'/60'/0'/0/0\",\n          message: \"Hello world\",\n        },\n      });\n\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockImplementation(() => extractDependenciesMock());\n\n      signMessageMock.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: undefined,\n        }),\n      );\n\n      const expectedStates: Array<SignMessageDAState> = [\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n        },\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n        },\n        {\n          status: DeviceActionStatus.Pending,\n          intermediateValue: {\n            requiredUserInteraction:\n              UserInteractionRequired.SignPersonalMessage,\n          },\n        },\n        {\n          status: DeviceActionStatus.Error,\n          error: new UnknownDAError(\"No error in final state\"),\n        },\n      ];\n\n      const { observable } = testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n      );\n\n      observable.subscribe({\n        complete: () => {\n          try {\n            expect(signMessageMock).toHaveBeenCalledWith(\n              expect.objectContaining({\n                input: expect.objectContaining({\n                  derivationPath: \"44'/60'/0'/0/0\",\n                  sendingData: new TextEncoder().encode(\"Hello world\"),\n                }),\n              }),\n            );\n            done();\n          } catch (error) {\n            done(error);\n          }\n        },\n        error: (err) => {\n          done(err);\n        },\n      });\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["CommandResultFactory", "DeviceActionStatus", "UnknownDeviceExchangeError", "UserInteractionRequired", "UnknownDAError", "makeDeviceActionInternalApiMock", "setupOpenAppDAMock", "testDeviceActionStates", "SignMessageDeviceAction", "signMessageMock", "extractDependenciesMock", "done", "deviceAction", "signatureData", "expectedStates", "observable", "error", "err"]
+}

package/lib/esm/internal/app-binder/device-action/SignTransactionDeviceAction.js

@@ -0,0 +1,2 @@
+import{isSuccessCommandResult as s,OpenAppDeviceAction as c,UnknownDAError as o,UserInteractionRequired as r,XStateDeviceAction as p}from"@ledgerhq/device-management-kit";import{Left as u,Right as S}from"purify-ts";import{assign as e,fromPromise as l,setup as g}from"xstate";import{SignTransactionCommand as d}from"../../app-binder/command/SignTransactionCommand";import{SignDataTask as m}from"../../app-binder/task/SendSignDataTask";class v extends p{makeStateMachine(a){const{signTransaction:i}=this.extractDependencies(a);return g({types:{input:{},context:{},output:{}},actors:{openAppStateMachine:new c({input:{appName:"Solana"}}).makeStateMachine(a),signTransaction:l(i)},guards:{noInternalError:({context:n})=>n._internalState.error===null},actions:{assignErrorFromEvent:e({_internalState:n=>({...n.context._internalState,error:n.event.error})})}}).createMachine({id:"SignTransactionDeviceAction",initial:"OpenAppDeviceAction",context:({input:n})=>({input:n,intermediateValue:{requiredUserInteraction:r.None},_internalState:{error:null,signature:null}}),states:{OpenAppDeviceAction:{exit:e({intermediateValue:{requiredUserInteraction:r.None}}),invoke:{id:"openAppStateMachine",input:{appName:"Solana"},src:"openAppStateMachine",onSnapshot:{actions:e({intermediateValue:n=>n.event.snapshot.context.intermediateValue})},onDone:{actions:e({_internalState:n=>n.event.output.caseOf({Right:()=>n.context._internalState,Left:t=>({...n.context._internalState,error:t})})}),target:"CheckOpenAppDeviceActionResult"}}},CheckOpenAppDeviceActionResult:{always:[{target:"SignTransaction",guard:"noInternalError"},"Error"]},SignTransaction:{entry:e({intermediateValue:{requiredUserInteraction:r.SignTransaction}}),exit:e({intermediateValue:{requiredUserInteraction:r.None}}),invoke:{id:"signTransaction",src:"signTransaction",input:({context:n})=>({derivationPath:n.input.derivationPath,serializedTransaction:n.input.transaction}),onDone:{target:"SignTransactionResultCheck",actions:[e({_internalState:({event:n,context:t})=>s(n.output)?n.output.data.isJust()?{...t._internalState,signature:n.output.data.extract()}:{...t._internalState,error:new o("No Signature available")}:{...t._internalState,error:n.output.error}})]},onError:{target:"Error",actions:"assignErrorFromEvent"}}},SignTransactionResultCheck:{always:[{guard:"noInternalError",target:"Success"},{target:"Error"}]},Success:{type:"final"},Error:{type:"final"}},output:({context:n})=>n._internalState.signature?S(n._internalState.signature):u(n._internalState.error||new o("No error or signature available"))})}extractDependencies(a){return{signTransaction:async n=>new m(a,{commandFactory:t=>new d({serializedTransaction:t.chunkedData,more:t.more,extend:t.extend}),derivationPath:n.input.derivationPath,sendingData:n.input.serializedTransaction}).run()}}}export{v as SignTransactionDeviceAction};
+//# sourceMappingURL=SignTransactionDeviceAction.js.map

package/lib/esm/internal/app-binder/device-action/SignTransactionDeviceAction.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/device-action/SignTransactionDeviceAction.ts"],
+  "sourcesContent": ["import {\n  type CommandResult,\n  type DeviceActionStateMachine,\n  type InternalApi,\n  isSuccessCommandResult,\n  OpenAppDeviceAction,\n  type StateMachineTypes,\n  UnknownDAError,\n  UserInteractionRequired,\n  XStateDeviceAction,\n} from \"@ledgerhq/device-management-kit\";\nimport { Left, type Maybe, Right } from \"purify-ts\";\nimport { assign, fromPromise, setup } from \"xstate\";\n\nimport {\n  type SignTransactionDAError,\n  type SignTransactionDAInput,\n  type SignTransactionDAIntermediateValue,\n  type SignTransactionDAInternalState,\n  type SignTransactionDAOutput,\n} from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nimport { type Signature } from \"@api/model/Signature\";\nimport { SignTransactionCommand } from \"@internal/app-binder/command/SignTransactionCommand\";\nimport { SignDataTask } from \"@internal/app-binder/task/SendSignDataTask\";\n\nexport type MachineDependencies = {\n  readonly signTransaction: (arg0: {\n    input: {\n      derivationPath: string;\n      serializedTransaction: Uint8Array;\n    };\n  }) => Promise<CommandResult<Maybe<Signature>>>;\n};\n\nexport class SignTransactionDeviceAction extends XStateDeviceAction<\n  SignTransactionDAOutput,\n  SignTransactionDAInput,\n  SignTransactionDAError,\n  SignTransactionDAIntermediateValue,\n  SignTransactionDAInternalState\n> {\n  makeStateMachine(\n    internalApi: InternalApi,\n  ): DeviceActionStateMachine<\n    SignTransactionDAOutput,\n    SignTransactionDAInput,\n    SignTransactionDAError,\n    SignTransactionDAIntermediateValue,\n    SignTransactionDAInternalState\n  > {\n    type types = StateMachineTypes<\n      SignTransactionDAOutput,\n      SignTransactionDAInput,\n      SignTransactionDAError,\n      SignTransactionDAIntermediateValue,\n      SignTransactionDAInternalState\n    >;\n\n    const { signTransaction } = this.extractDependencies(internalApi);\n\n    return setup({\n      types: {\n        input: {} as types[\"input\"],\n        context: {} as types[\"context\"],\n        output: {} as types[\"output\"],\n      },\n      actors: {\n        openAppStateMachine: new OpenAppDeviceAction({\n          input: { appName: \"Solana\" },\n        }).makeStateMachine(internalApi),\n        signTransaction: fromPromise(signTransaction),\n      },\n      guards: {\n        noInternalError: ({ context }) => context._internalState.error === null,\n      },\n      actions: {\n        assignErrorFromEvent: assign({\n          _internalState: (_) => ({\n            ..._.context._internalState,\n            error: _.event[\"error\"], // NOTE: it should never happen, the error is not typed anymore here\n          }),\n        }),\n      },\n    }).createMachine({\n      /** @xstate-layout N4IgpgJg5mDOIC5QGUCWUB2AVATgQw1jwGMAXVAewwBEwA3VYsAQTMowDoB5ABzA2Y8etBk1bkqAYghUwHVBjoUA1nIp8BQ5KTykwAWRIALBWADaABgC6iUDwqxUEjLZAAPRABYAzAHYOAJwAHABMFgCMnhYWUSFBvgA0IACeiEEAbOkcAKxBQQGeASG+3tmeISEAvpVJaJi4BERsVCKMLM2cAMJGYMTKvPyCwvRt4uwASnAArgA2pJKWNkgg9o7Orh4IAQEWHN7RvgGH2dne4UHhSakI+Vnpvtkh4eme2Udh3tW16Nj4hCTOVpiDocbq9foaIZA9rOSawWbzMzhJZ2BxOdgbRDbXb7CyHY6nc6XFJpcIcc6+OLebzxCoBbLhL4gOq-RoA9jQsZUDgAcTApG6eBmM34MGksnkihUchgAqMQpFGBgi1cq3RVExCEi+Q4nnO6RC3ji232QSuiBKZPCEQyZwsmSCNKZLIa-w6nJBfLlCtFYEkYBwOAoOA4PBmugAZsGALYcWWC4W+lXLNXrZabbUBXX6w3GgKm803eLk7ZBTwZF6Uz41Zk-V1NQEjYHODgAISmqBmEE6VD0bnmMgwcgUSlUHAARh2uz2MH3SMnUWsMenEOFtv5HhYghEdt5PPvC7ks2v89EAvdwuFDc6638GxymzD2G2p93e2B+-7A8HQ+HSFGcFjSdOzfWcP3naxVTRNNQAzdccjCbc1wsPcDxJBBfFeDgQneDJHgZAib3qO92RaR8uU4AAFIMGAgMAZzncUh0lUc5B4GjUDohjwIXFZoOXWDEBCU4sl8DJwl8Xxogsc8YkLTwxI4TDlMwjJfHSCwqhrF0SPdciQWoihaPo99PwDIMQzDSMY1DDiuNMiCUT4pcNRXBBhO8UTxMk6TZM8QsNO8PYCkpHwghOIIiNZN1G1EJ9uUM4zuP7OEETBPoFkglN+NcwSEFxHEtziB49wCYlrj3XZhM8e5HQiCJCii+tSJofSW0SziTLAlLpjmdLlAWZEoJclw3IKvYiviU5CnKxBsi3DhHT8fd7hwmk9ya3TYtGEEdLZDomOHKUx0cYj9ucXjUwE9xEFKHDyRCfcHhCF411m9zIiU88jXyQ4-CvTbzofOKKI4PaYvYL8LN-azAI4U7ovvKhLpy0a8ru49HoUx5XrKwtqSzfdSgeeILjKmJAYhsiQd228gaoVK+p6DKUZGzVvHghrNKNEoHn89CT2zHYyjOalPIB7S6ap1qaZbcGkYwRm5XBQanKu3KbvyznIm54o-DKQsscW0I3nSZ4TkKalqhrDAKDo+BlnllqPRg5z1TRzWAFp0kLb2OGkgPA4OSmFZd58Bk0YZZeu9WPc2cpCzLEJdRkix5oI-cQ+dtrn36iOoRzhnetIYb3c1dIy11alHWyTIzfSbJEnQvIgmw14t1KwpMOrb4zulsPuS9BNFRgUvXYzc4goZTzgntE980T3wySNPEJPCfZyg5rO9Oj7l2xA5KS+ytm3OeI5FoqGrMiiEofELSlCaJMpsXCx7t+25tnw6+zuqPxcy7chUNOgRHovHwuUbGh5iwETeHEBkcR7Tv2BjtdqdkupziVv1Me11NjFCwshTSKEGTqX5tceauwojiwkluNcb9JZ91DoXTgTsOjYI1psM4+YEKXniK9N4704itx2CUUI4UGTBC0r3RG2dd7MKlgrTBzNlBsLjrdXmCFHT6kiNsV4htPK6keDVFeW4UKZ3odIneKDnzICmMQJgsAHb-3Hl4J4VUXpFGrjEUohY1xZHCLXE4-j8zkIUkg6mVjuQAFFvw4BUZqco1psLuMNDSLx2RDzAMblePU9I7QvWrNUIAA */\n      id: \"SignTransactionDeviceAction\",\n      initial: \"OpenAppDeviceAction\",\n      context: ({ input }) => {\n        return {\n          input,\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          _internalState: {\n            error: null,\n            signature: null,\n          },\n        };\n      },\n      states: {\n        OpenAppDeviceAction: {\n          exit: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          invoke: {\n            id: \"openAppStateMachine\",\n            input: { appName: \"Solana\" },\n            src: \"openAppStateMachine\",\n            onSnapshot: {\n              actions: assign({\n                intermediateValue: (_) =>\n                  _.event.snapshot.context.intermediateValue,\n              }),\n            },\n            onDone: {\n              actions: assign({\n                _internalState: (_) => {\n                  return _.event.output.caseOf<SignTransactionDAInternalState>({\n                    Right: () => _.context._internalState,\n                    Left: (error) => ({\n                      ..._.context._internalState,\n                      error,\n                    }),\n                  });\n                },\n              }),\n              target: \"CheckOpenAppDeviceActionResult\",\n            },\n          },\n        },\n        CheckOpenAppDeviceActionResult: {\n          always: [\n            {\n              target: \"SignTransaction\",\n              guard: \"noInternalError\",\n            },\n            \"Error\",\n          ],\n        },\n        SignTransaction: {\n          entry: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.SignTransaction,\n            },\n          }),\n          exit: assign({\n            intermediateValue: {\n              requiredUserInteraction: UserInteractionRequired.None,\n            },\n          }),\n          invoke: {\n            id: \"signTransaction\",\n            src: \"signTransaction\",\n            input: ({ context }) => ({\n              derivationPath: context.input.derivationPath,\n              serializedTransaction: context.input.transaction,\n            }),\n            onDone: {\n              target: \"SignTransactionResultCheck\",\n              actions: [\n                assign({\n                  _internalState: ({ event, context }) => {\n                    if (!isSuccessCommandResult(event.output))\n                      return {\n                        ...context._internalState,\n                        error: event.output.error,\n                      };\n\n                    if (event.output.data.isJust())\n                      return {\n                        ...context._internalState,\n                        signature: event.output.data.extract(),\n                      };\n\n                    return {\n                      ...context._internalState,\n                      error: new UnknownDAError(\"No Signature available\"),\n                    };\n                  },\n                }),\n              ],\n            },\n            onError: {\n              target: \"Error\",\n              actions: \"assignErrorFromEvent\",\n            },\n          },\n        },\n        SignTransactionResultCheck: {\n          always: [\n            { guard: \"noInternalError\", target: \"Success\" },\n            { target: \"Error\" },\n          ],\n        },\n        Success: {\n          type: \"final\",\n        },\n        Error: {\n          type: \"final\",\n        },\n      },\n      output: ({ context }) =>\n        context._internalState.signature\n          ? Right(context._internalState.signature)\n          : Left(\n              context._internalState.error ||\n                new UnknownDAError(\"No error or signature available\"),\n            ),\n    });\n  }\n\n  extractDependencies(internalApi: InternalApi): MachineDependencies {\n    const signTransaction = async (arg0: {\n      input: {\n        derivationPath: string;\n        serializedTransaction: Uint8Array;\n      };\n    }) => {\n      return new SignDataTask(internalApi, {\n        commandFactory: (args) =>\n          new SignTransactionCommand({\n            serializedTransaction: args.chunkedData,\n            more: args.more,\n            extend: args.extend,\n          }),\n        derivationPath: arg0.input.derivationPath,\n        sendingData: arg0.input.serializedTransaction,\n      }).run();\n    };\n\n    return {\n      signTransaction,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["isSuccessCommandResult", "OpenAppDeviceAction", "UnknownDAError", "UserInteractionRequired", "XStateDeviceAction", "Left", "Right", "assign", "fromPromise", "setup", "SignTransactionCommand", "SignDataTask", "SignTransactionDeviceAction", "internalApi", "signTransaction", "context", "_", "input", "error", "event", "arg0", "args"]
+}

package/lib/esm/internal/app-binder/device-action/SignTransactionDeviceAction.test.js

@@ -0,0 +1,2 @@
+import{CommandResultFactory as d,DeviceActionStatus as e,InvalidStatusWordError as v,UnknownDAError as g,UserInteractionRequired as n}from"@ledgerhq/device-management-kit";import{Just as x,Nothing as f}from"purify-ts";import{makeDeviceActionInternalApiMock as o}from"../../app-binder/device-action/__test-utils__/makeInternalApi";import{setupOpenAppDAMock as l}from"../../app-binder/device-action/__test-utils__/setupOpenAppDAMock";import{testDeviceActionStates as m}from"../../app-binder/device-action/__test-utils__/testDeviceActionStates";import{SignTransactionDeviceAction as p}from"./SignTransactionDeviceAction";jest.mock("@ledgerhq/device-management-kit",()=>({...jest.requireActual("@ledgerhq/device-management-kit"),OpenAppDeviceAction:jest.fn(()=>({makeStateMachine:jest.fn()}))}));describe("SignTransactionDeviceAction",()=>{const s=jest.fn();function u(){return{signTransaction:s}}const c={};let a;beforeEach(()=>{jest.clearAllMocks(),a=new Uint8Array([1,2,3])}),describe("Happy path",()=>{it("should call external dependencies with the correct parameters",i=>{l();const t=new p({input:{derivationPath:"44'/501'/0'/0'",transaction:a,options:c}});s.mockResolvedValueOnce(d({data:x(new Uint8Array([5,6,7]))})),jest.spyOn(t,"extractDependencies").mockReturnValue(u());const r=[{intermediateValue:{requiredUserInteraction:n.None},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.SignTransaction},status:e.Pending},{output:new Uint8Array([5,6,7]),status:e.Completed}],{observable:A}=m(t,r,o(),i);A.subscribe({complete:()=>{expect(s).toHaveBeenCalledWith(expect.objectContaining({input:{derivationPath:"44'/501'/0'/0'",serializedTransaction:new Uint8Array([1,2,3])}}))}})})}),describe("OpenApp errors",()=>{it("should fail if OpenApp throw an error",i=>{l(new g("OpenApp error"));const t=new p({input:{derivationPath:"44'/501'/0'/0'",transaction:a,options:c}});jest.spyOn(t,"extractDependencies").mockReturnValue(u());const r=[{intermediateValue:{requiredUserInteraction:n.None},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp},status:e.Pending},{error:new g("OpenApp error"),status:e.Error}];m(t,r,o(),i)})}),describe("SignTransaction errors",()=>{it("should fail if signTransaction returns an error",i=>{l();const t=new p({input:{derivationPath:"44'/501'/0'/0'",transaction:a,options:c}});s.mockResolvedValueOnce(d({error:new v("signTransaction error")})),jest.spyOn(t,"extractDependencies").mockReturnValue(u());const r=[{intermediateValue:{requiredUserInteraction:n.None},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.SignTransaction},status:e.Pending},{error:new v("signTransaction error"),status:e.Error}];m(t,r,o(),i)}),it("should fail if signTransaction returns nothing",i=>{l();const t=new p({input:{derivationPath:"44'/501'/0'/0'",transaction:a,options:c}});s.mockResolvedValueOnce(d({data:f})),jest.spyOn(t,"extractDependencies").mockReturnValue(u());const r=[{intermediateValue:{requiredUserInteraction:n.None},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.ConfirmOpenApp},status:e.Pending},{intermediateValue:{requiredUserInteraction:n.SignTransaction},status:e.Pending},{error:new g("No Signature available"),status:e.Error}];m(t,r,o(),i)})}),describe("extractDependencies",()=>{it("should extract dependencies",async()=>{const i=new p({input:{derivationPath:"44'/501'/0'/0'",transaction:a,options:c}}),t=o();jest.spyOn(t,"sendCommand").mockResolvedValue(d({data:x(new Uint8Array([5,6,7]))}));const r=i.extractDependencies(o()),A=await r.signTransaction({input:{derivationPath:"44'/501'/0'/0'",serializedTransaction:a}});expect(r.signTransaction).toBeInstanceOf(Function),expect(A).toEqual(d({data:x(new Uint8Array([5,6,7]))})),expect(t.sendCommand).toHaveBeenCalledTimes(1)})})});
+//# sourceMappingURL=SignTransactionDeviceAction.test.js.map

package/lib/esm/internal/app-binder/device-action/SignTransactionDeviceAction.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/device-action/SignTransactionDeviceAction.test.ts"],
+  "sourcesContent": ["import {\n  CommandResultFactory,\n  DeviceActionStatus,\n  InvalidStatusWordError,\n  UnknownDAError,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { type SignTransactionDAState } from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nimport { type Transaction } from \"@api/model/Transaction\";\nimport { makeDeviceActionInternalApiMock } from \"@internal/app-binder/device-action/__test-utils__/makeInternalApi\";\nimport { setupOpenAppDAMock } from \"@internal/app-binder/device-action/__test-utils__/setupOpenAppDAMock\";\nimport { testDeviceActionStates } from \"@internal/app-binder/device-action/__test-utils__/testDeviceActionStates\";\n\nimport { SignTransactionDeviceAction } from \"./SignTransactionDeviceAction\";\n\njest.mock(\n  \"@ledgerhq/device-management-kit\",\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  () => ({\n    ...jest.requireActual(\"@ledgerhq/device-management-kit\"),\n    OpenAppDeviceAction: jest.fn(() => ({\n      makeStateMachine: jest.fn(),\n    })),\n  }),\n);\n\ndescribe(\"SignTransactionDeviceAction\", () => {\n  const signTransactionMock = jest.fn();\n  function extractDependenciesMock() {\n    return {\n      signTransaction: signTransactionMock,\n    };\n  }\n  const defaultOptions = {};\n  let defaultTransaction: Transaction;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n    defaultTransaction = new Uint8Array([0x01, 0x02, 0x03]);\n  });\n\n  describe(\"Happy path\", () => {\n    it(\"should call external dependencies with the correct parameters\", (done) => {\n      setupOpenAppDAMock();\n\n      const deviceAction = new SignTransactionDeviceAction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          transaction: defaultTransaction,\n          options: defaultOptions,\n        },\n      });\n\n      // Mock the dependencies to return some sample data\n      signTransactionMock.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: Just(new Uint8Array([0x05, 0x06, 0x07])),\n        }),\n      );\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockReturnValue(extractDependenciesMock());\n\n      // Expected intermediate values for the following state sequence:\n      //   Initial -> OpenApp -> GetChallenge -> BuildContext -> ProvideContext -> SignTransaction\n      const expectedStates: Array<SignTransactionDAState> = [\n        // Initial state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // OpenApp interaction\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // SignTransaction state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.SignTransaction,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // Final state\n        {\n          output: new Uint8Array([0x05, 0x06, 0x07]),\n          status: DeviceActionStatus.Completed,\n        },\n      ];\n\n      const { observable } = testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n        done,\n      );\n\n      // Verify mocks calls parameters\n      observable.subscribe({\n        complete: () => {\n          expect(signTransactionMock).toHaveBeenCalledWith(\n            expect.objectContaining({\n              input: {\n                derivationPath: \"44'/501'/0'/0'\",\n                serializedTransaction: new Uint8Array([0x01, 0x02, 0x03]),\n              },\n            }),\n          );\n        },\n      });\n    });\n  });\n\n  describe(\"OpenApp errors\", () => {\n    it(\"should fail if OpenApp throw an error\", (done) => {\n      setupOpenAppDAMock(new UnknownDAError(\"OpenApp error\"));\n\n      const deviceAction = new SignTransactionDeviceAction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          transaction: defaultTransaction,\n          options: defaultOptions,\n        },\n      });\n\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockReturnValue(extractDependenciesMock());\n\n      const expectedStates: Array<SignTransactionDAState> = [\n        // Initial state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // OpenApp interaction\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // OpenApp error\n        {\n          error: new UnknownDAError(\"OpenApp error\"),\n          status: DeviceActionStatus.Error,\n        },\n      ];\n\n      testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n        done,\n      );\n    });\n  });\n\n  describe(\"SignTransaction errors\", () => {\n    it(\"should fail if signTransaction returns an error\", (done) => {\n      setupOpenAppDAMock();\n\n      const deviceAction = new SignTransactionDeviceAction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          transaction: defaultTransaction,\n          options: defaultOptions,\n        },\n      });\n\n      signTransactionMock.mockResolvedValueOnce(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"signTransaction error\"),\n        }),\n      );\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockReturnValue(extractDependenciesMock());\n\n      const expectedStates: Array<SignTransactionDAState> = [\n        // Initial state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // OpenApp interaction\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // SignTransaction state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.SignTransaction,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // SignTransaction error\n        {\n          error: new InvalidStatusWordError(\"signTransaction error\"),\n          status: DeviceActionStatus.Error,\n        },\n      ];\n\n      testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n        done,\n      );\n    });\n\n    it(\"should fail if signTransaction returns nothing\", (done) => {\n      setupOpenAppDAMock();\n\n      const deviceAction = new SignTransactionDeviceAction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          transaction: defaultTransaction,\n          options: defaultOptions,\n        },\n      });\n\n      signTransactionMock.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: Nothing,\n        }),\n      );\n      jest\n        .spyOn(deviceAction, \"extractDependencies\")\n        .mockReturnValue(extractDependenciesMock());\n\n      const expectedStates: Array<SignTransactionDAState> = [\n        // Initial state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.None,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // OpenApp interaction\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // SignTransaction state\n        {\n          intermediateValue: {\n            requiredUserInteraction: UserInteractionRequired.SignTransaction,\n          },\n          status: DeviceActionStatus.Pending,\n        },\n        // SignTransaction error\n        {\n          error: new UnknownDAError(\"No Signature available\"),\n          status: DeviceActionStatus.Error,\n        },\n      ];\n\n      testDeviceActionStates(\n        deviceAction,\n        expectedStates,\n        makeDeviceActionInternalApiMock(),\n        done,\n      );\n    });\n  });\n\n  describe(\"extractDependencies\", () => {\n    it(\"should extract dependencies\", async () => {\n      const deviceAction = new SignTransactionDeviceAction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          transaction: defaultTransaction,\n          options: defaultOptions,\n        },\n      });\n      // mock sendCommand to return a successful result\n      const api = makeDeviceActionInternalApiMock();\n      jest.spyOn(api, \"sendCommand\").mockResolvedValue(\n        CommandResultFactory({\n          data: Just(new Uint8Array([0x05, 0x06, 0x07])),\n        }),\n      );\n\n      const dependencies = deviceAction.extractDependencies(\n        makeDeviceActionInternalApiMock(),\n      );\n      const signature = await dependencies.signTransaction({\n        input: {\n          derivationPath: \"44'/501'/0'/0'\",\n          serializedTransaction: defaultTransaction,\n        },\n      });\n\n      expect(dependencies.signTransaction).toBeInstanceOf(Function);\n      expect(signature).toEqual(\n        CommandResultFactory({\n          data: Just(new Uint8Array([0x05, 0x06, 0x07])),\n        }),\n      );\n      expect(api.sendCommand).toHaveBeenCalledTimes(1);\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["CommandResultFactory", "DeviceActionStatus", "InvalidStatusWordError", "UnknownDAError", "UserInteractionRequired", "Just", "Nothing", "makeDeviceActionInternalApiMock", "setupOpenAppDAMock", "testDeviceActionStates", "SignTransactionDeviceAction", "signTransactionMock", "extractDependenciesMock", "defaultOptions", "defaultTransaction", "done", "deviceAction", "expectedStates", "observable", "api", "dependencies", "signature"]
+}

package/lib/esm/internal/app-binder/device-action/__test-utils__/makeInternalApi.js

@@ -0,0 +1,2 @@
+const e=jest.fn(),t=jest.fn(),s=jest.fn(),n=jest.fn(),o=jest.fn();function a(){return{sendCommand:e,getDeviceSessionState:t,getDeviceSessionStateObservable:s,setDeviceSessionState:n,getMetadataForAppHashes:o}}export{a as makeDeviceActionInternalApiMock};
+//# sourceMappingURL=makeInternalApi.js.map

package/lib/esm/internal/app-binder/device-action/__test-utils__/makeInternalApi.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/device-action/__test-utils__/makeInternalApi.ts"],
+  "sourcesContent": ["import { type InternalApi } from \"@ledgerhq/device-management-kit\";\n\nconst sendCommandMock = jest.fn();\nconst apiGetDeviceSessionStateMock = jest.fn();\nconst apiGetDeviceSessionStateObservableMock = jest.fn();\nconst setDeviceSessionStateMock = jest.fn();\nconst getMetadataForAppHashesMock = jest.fn();\n\nexport function makeDeviceActionInternalApiMock(): jest.Mocked<InternalApi> {\n  return {\n    sendCommand: sendCommandMock,\n    getDeviceSessionState: apiGetDeviceSessionStateMock,\n    getDeviceSessionStateObservable: apiGetDeviceSessionStateObservableMock,\n    setDeviceSessionState: setDeviceSessionStateMock,\n    getMetadataForAppHashes: getMetadataForAppHashesMock,\n  };\n}\n"],
+  "mappings": "AAEA,MAAMA,EAAkB,KAAK,GAAG,EAC1BC,EAA+B,KAAK,GAAG,EACvCC,EAAyC,KAAK,GAAG,EACjDC,EAA4B,KAAK,GAAG,EACpCC,EAA8B,KAAK,GAAG,EAErC,SAASC,GAA4D,CAC1E,MAAO,CACL,YAAaL,EACb,sBAAuBC,EACvB,gCAAiCC,EACjC,sBAAuBC,EACvB,wBAAyBC,CAC3B,CACF",
+  "names": ["sendCommandMock", "apiGetDeviceSessionStateMock", "apiGetDeviceSessionStateObservableMock", "setDeviceSessionStateMock", "getMetadataForAppHashesMock", "makeDeviceActionInternalApiMock"]
+}

package/lib/esm/internal/app-binder/device-action/__test-utils__/setupOpenAppDAMock.js

@@ -0,0 +1,2 @@
+import{OpenAppDeviceAction as n,UserInteractionRequired as t}from"@ledgerhq/device-management-kit";import{Left as i,Right as o}from"purify-ts";import{assign as p,createMachine as a}from"xstate";const s=e=>{n.mockImplementation(()=>({makeStateMachine:jest.fn().mockImplementation(()=>a({initial:"pending",states:{pending:{entry:p({intermediateValue:{requiredUserInteraction:t.ConfirmOpenApp}}),after:{0:"done"}},done:{type:"final"}},output:()=>e?i(e):o(void 0)}))}))};export{s as setupOpenAppDAMock};
+//# sourceMappingURL=setupOpenAppDAMock.js.map

package/lib/esm/internal/app-binder/device-action/__test-utils__/setupOpenAppDAMock.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/device-action/__test-utils__/setupOpenAppDAMock.ts"],
+  "sourcesContent": ["import {\n  OpenAppDeviceAction,\n  UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\nimport { Left, Right } from \"purify-ts\";\nimport { assign, createMachine } from \"xstate\";\n\nexport const setupOpenAppDAMock = (error?: unknown) => {\n  (OpenAppDeviceAction as jest.Mock).mockImplementation(() => ({\n    makeStateMachine: jest.fn().mockImplementation(() =>\n      createMachine({\n        initial: \"pending\",\n        states: {\n          pending: {\n            entry: assign({\n              intermediateValue: {\n                requiredUserInteraction: UserInteractionRequired.ConfirmOpenApp,\n              },\n            }),\n            after: {\n              0: \"done\",\n            },\n          },\n          done: {\n            type: \"final\",\n          },\n        },\n        output: () => (error ? Left(error) : Right(undefined)),\n      }),\n    ),\n  }));\n};\n"],
+  "mappings": "AAAA,OACE,uBAAAA,EACA,2BAAAC,MACK,kCACP,OAAS,QAAAC,EAAM,SAAAC,MAAa,YAC5B,OAAS,UAAAC,EAAQ,iBAAAC,MAAqB,SAE/B,MAAMC,EAAsBC,GAAoB,CACpDP,EAAkC,mBAAmB,KAAO,CAC3D,iBAAkB,KAAK,GAAG,EAAE,mBAAmB,IAC7CK,EAAc,CACZ,QAAS,UACT,OAAQ,CACN,QAAS,CACP,MAAOD,EAAO,CACZ,kBAAmB,CACjB,wBAAyBH,EAAwB,cACnD,CACF,CAAC,EACD,MAAO,CACL,EAAG,MACL,CACF,EACA,KAAM,CACJ,KAAM,OACR,CACF,EACA,OAAQ,IAAOM,EAAQL,EAAKK,CAAK,EAAIJ,EAAM,MAAS,CACtD,CAAC,CACH,CACF,EAAE,CACJ",
+  "names": ["OpenAppDeviceAction", "UserInteractionRequired", "Left", "Right", "assign", "createMachine", "setupOpenAppDAMock", "error"]
+}

package/lib/esm/internal/app-binder/device-action/__test-utils__/testDeviceActionStates.js

@@ -0,0 +1,2 @@
+function o(c,a,n,e){const r=[],{observable:i,cancel:u}=c._execute(n);return i.subscribe({next:t=>{r.push(t)},error:t=>{e&&e(t)},complete:()=>{try{expect(r).toEqual(a),e&&e()}catch(t){e&&e(t)}}}),{observable:i,cancel:u}}export{o as testDeviceActionStates};
+//# sourceMappingURL=testDeviceActionStates.js.map

package/lib/esm/internal/app-binder/device-action/__test-utils__/testDeviceActionStates.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/app-binder/device-action/__test-utils__/testDeviceActionStates.ts"],
+  "sourcesContent": ["import {\n  type DeviceAction,\n  type DeviceActionIntermediateValue,\n  type DeviceActionState,\n  type DmkError,\n  type InternalApi,\n} from \"@ledgerhq/device-management-kit\";\n\n/**\n * Test that the states emitted by a device action match the expected states.\n * @param deviceAction The device action to test.\n * @param expectedStates The expected states.\n * @param done The Jest done callback.\n */\nexport function testDeviceActionStates<\n  Output,\n  Input,\n  Error extends DmkError,\n  IntermediateValue extends DeviceActionIntermediateValue,\n>(\n  deviceAction: DeviceAction<Output, Input, Error, IntermediateValue>,\n  expectedStates: Array<DeviceActionState<Output, Error, IntermediateValue>>,\n  internalApi: InternalApi,\n  done?: jest.DoneCallback,\n) {\n  const observedStates: Array<\n    DeviceActionState<Output, Error, IntermediateValue>\n  > = [];\n\n  const { observable, cancel } = deviceAction._execute(internalApi);\n  observable.subscribe({\n    next: (state) => {\n      observedStates.push(state);\n    },\n    error: (error) => {\n      if (done) done(error);\n    },\n    complete: () => {\n      try {\n        expect(observedStates).toEqual(expectedStates);\n        if (done) done();\n      } catch (e) {\n        if (done) done(e);\n      }\n    },\n  });\n  return { observable, cancel };\n}\n"],
+  "mappings": "AAcO,SAASA,EAMdC,EACAC,EACAC,EACAC,EACA,CACA,MAAMC,EAEF,CAAC,EAEC,CAAE,WAAAC,EAAY,OAAAC,CAAO,EAAIN,EAAa,SAASE,CAAW,EAChE,OAAAG,EAAW,UAAU,CACnB,KAAOE,GAAU,CACfH,EAAe,KAAKG,CAAK,CAC3B,EACA,MAAQC,GAAU,CACZL,GAAMA,EAAKK,CAAK,CACtB,EACA,SAAU,IAAM,CACd,GAAI,CACF,OAAOJ,CAAc,EAAE,QAAQH,CAAc,EACzCE,GAAMA,EAAK,CACjB,OAASM,EAAG,CACNN,GAAMA,EAAKM,CAAC,CAClB,CACF,CACF,CAAC,EACM,CAAE,WAAAJ,EAAY,OAAAC,CAAO,CAC9B",
+  "names": ["testDeviceActionStates", "deviceAction", "expectedStates", "internalApi", "done", "observedStates", "observable", "cancel", "state", "error", "e"]
+}

package/lib/esm/internal/app-binder/di/appBinderModule.js

@@ -0,0 +1,2 @@
+import{ContainerModule as o}from"inversify";import{appBinderTypes as i}from"../../app-binder/di/appBinderTypes";import{SolanaAppBinder as r}from"../../app-binder/SolanaAppBinder";const B=()=>new o((n,p,e,t,d,a,m)=>{n(i.AppBinder).to(r)});export{B as appBinderModuleFactory};
+//# sourceMappingURL=appBinderModule.js.map

package/lib/esm/internal/app-binder/di/appBinderModule.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/di/appBinderModule.ts"],
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { SolanaAppBinder } from \"@internal/app-binder/SolanaAppBinder\";\n\nexport const appBinderModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(appBinderTypes.AppBinder).to(SolanaAppBinder);\n    },\n  );\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,kBAAAC,MAAsB,yCAC/B,OAAS,mBAAAC,MAAuB,uCAEzB,MAAMC,EAAyB,IACpC,IAAIH,EACF,CACEI,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAKH,EAAe,SAAS,EAAE,GAAGC,CAAe,CACnD,CACF",
+  "names": ["ContainerModule", "appBinderTypes", "SolanaAppBinder", "appBinderModuleFactory", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+}

package/lib/esm/internal/app-binder/di/appBinderModule.test.js

@@ -0,0 +1,2 @@
+import{Container as r}from"inversify";import{appBinderModuleFactory as t}from"./appBinderModule";describe("appBinderModule",()=>{describe("Default",()=>{let o,e;beforeEach(()=>{e=t(),o=new r,o.load(e)}),it("should return appBinder module",()=>{expect(e).toBeDefined()})})});
+//# sourceMappingURL=appBinderModule.test.js.map

package/lib/esm/internal/app-binder/di/appBinderModule.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/di/appBinderModule.test.ts"],
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { appBinderModuleFactory } from \"./appBinderModule\";\n\ndescribe(\"appBinderModule\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof appBinderModuleFactory>;\n    beforeEach(() => {\n      mod = appBinderModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return appBinder module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,0BAAAC,MAA8B,oBAEvC,SAAS,kBAAmB,IAAM,CAChC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMF,EAAuB,EAC7BC,EAAY,IAAIF,EAChBE,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,iCAAkC,IAAM,CACzC,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["Container", "appBinderModuleFactory", "container", "mod"]
+}

package/lib/esm/internal/app-binder/di/appBinderTypes.js

@@ -0,0 +1,2 @@
+const p={AppBinder:Symbol.for("AppBinder")};export{p as appBinderTypes};
+//# sourceMappingURL=appBinderTypes.js.map

package/lib/esm/internal/app-binder/di/appBinderTypes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/di/appBinderTypes.ts"],
+  "sourcesContent": ["export const appBinderTypes = {\n  AppBinder: Symbol.for(\"AppBinder\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAiB,CAC5B,UAAW,OAAO,IAAI,WAAW,CACnC",
+  "names": ["appBinderTypes"]
+}

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

@@ -0,0 +1,2 @@
+import{APDU_MAX_PAYLOAD as r,ByteArrayBuilder as d,CommandResultFactory as m,InvalidStatusWordError as l,isSuccessCommandResult as u}from"@ledgerhq/device-management-kit";class C{constructor(n,o){this.api=n;this.args=o}async run(){const{data:n,commandFactory:o}=this.args,t=new d(n.length).addBufferToData(n).build();for(let a=0;a<t.length;a+=r){const s=a+r>=t.length,e=await this.api.sendCommand(o({more:!s,extend:a>0,chunkedData:t.slice(a,a+r)}));if(!u(e))return e;if(s)return m({data:e.data})}throw new l("No result after processing all chunks")}}export{C as SendCommandInChunksTask};
+//# sourceMappingURL=SendCommandInChunksTask.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendCommandInChunksTask.ts"],
+  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  ByteArrayBuilder,\n  type Command,\n  type CommandResult,\n  CommandResultFactory,\n  type InternalApi,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\n\nexport type SendCommandInChunksTaskArgs<T> = {\n  data: Uint8Array;\n  commandFactory: CommandFactory<T>;\n};\n\nexport type CommandFactory<T> = <V extends ChunkableCommandArgs>(\n  args: ChunkableCommandArgs,\n) => Command<T, V>;\n\nexport type ChunkableCommandArgs = {\n  chunkedData: Uint8Array;\n  more: boolean;\n  extend: boolean;\n};\n\nexport class SendCommandInChunksTask<T> {\n  constructor(\n    private api: InternalApi,\n    private args: SendCommandInChunksTaskArgs<T>,\n  ) {}\n\n  async run(): Promise<CommandResult<T, void>> {\n    const { data: fullPayload, commandFactory } = this.args;\n\n    const dataBuffer = new ByteArrayBuilder(fullPayload.length)\n      .addBufferToData(fullPayload)\n      .build();\n\n    for (\n      let offset = 0;\n      offset < dataBuffer.length;\n      offset += APDU_MAX_PAYLOAD\n    ) {\n      const isLastChunk = offset + APDU_MAX_PAYLOAD >= dataBuffer.length;\n      const result = await this.api.sendCommand(\n        commandFactory({\n          more: !isLastChunk,\n          extend: offset > 0,\n          chunkedData: dataBuffer.slice(offset, offset + APDU_MAX_PAYLOAD),\n        }),\n      );\n\n      if (!isSuccessCommandResult(result)) {\n        return result;\n      }\n\n      if (isLastChunk) {\n        return CommandResultFactory({\n          data: result.data,\n        });\n      }\n    }\n\n    throw new InvalidStatusWordError(\"No result after processing all chunks\");\n  }\n}\n"],
+  "mappings": "AAAA,OACE,oBAAAA,EACA,oBAAAC,EAGA,wBAAAC,EAEA,0BAAAC,EACA,0BAAAC,MACK,kCAiBA,MAAMC,CAA2B,CACtC,YACUC,EACAC,EACR,CAFQ,SAAAD,EACA,UAAAC,CACP,CAEH,MAAM,KAAuC,CAC3C,KAAM,CAAE,KAAMC,EAAa,eAAAC,CAAe,EAAI,KAAK,KAE7CC,EAAa,IAAIT,EAAiBO,EAAY,MAAM,EACvD,gBAAgBA,CAAW,EAC3B,MAAM,EAET,QACMG,EAAS,EACbA,EAASD,EAAW,OACpBC,GAAUX,EACV,CACA,MAAMY,EAAcD,EAASX,GAAoBU,EAAW,OACtDG,EAAS,MAAM,KAAK,IAAI,YAC5BJ,EAAe,CACb,KAAM,CAACG,EACP,OAAQD,EAAS,EACjB,YAAaD,EAAW,MAAMC,EAAQA,EAASX,CAAgB,CACjE,CAAC,CACH,EAEA,GAAI,CAACI,EAAuBS,CAAM,EAChC,OAAOA,EAGT,GAAID,EACF,OAAOV,EAAqB,CAC1B,KAAMW,EAAO,IACf,CAAC,CAEL,CAEA,MAAM,IAAIV,EAAuB,uCAAuC,CAC1E,CACF",
+  "names": ["APDU_MAX_PAYLOAD", "ByteArrayBuilder", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "SendCommandInChunksTask", "api", "args", "fullPayload", "commandFactory", "dataBuffer", "offset", "isLastChunk", "result"]
+}

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

@@ -0,0 +1,2 @@
+import{ByteArrayBuilder as s}from"@ledgerhq/device-management-kit";import{DerivationPathUtils as d}from"@ledgerhq/signer-utils";import{SendCommandInChunksTask as m}from"./SendCommandInChunksTask";const p=4;class l{constructor(t,r){this.api=t;this.args=r}async run(){const{sendingData:t,derivationPath:r,commandFactory:i}=this.args,n=d.splitPath(r),a=new s(t.length+2+n.length*p);a.add8BitUIntToData(1),a.add8BitUIntToData(n.length),n.forEach(o=>a.add32BitUIntToData(o)),a.addBufferToData(t);const e=a.build();return await new m(this.api,{data:e,commandFactory:i}).run()}}export{l as SignDataTask};
+//# sourceMappingURL=SendSignDataTask.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendSignDataTask.ts"],
+  "sourcesContent": ["import {\n  ByteArrayBuilder,\n  type CommandResult,\n  type InternalApi,\n} from \"@ledgerhq/device-management-kit\";\nimport { DerivationPathUtils } from \"@ledgerhq/signer-utils\";\nimport { type Maybe } from \"purify-ts\";\n\nimport { type Signature } from \"@api/model/Signature\";\n\nimport {\n  type CommandFactory,\n  SendCommandInChunksTask,\n} from \"./SendCommandInChunksTask\";\n\nconst PATH_SIZE = 4;\n\ntype SignDataTaskArgs = {\n  sendingData: Uint8Array;\n  derivationPath: string;\n  commandFactory: CommandFactory<Maybe<Signature>>;\n};\n\nexport class SignDataTask {\n  constructor(\n    private api: InternalApi,\n    private args: SignDataTaskArgs,\n  ) {}\n\n  async run(): Promise<CommandResult<Maybe<Signature>, void>> {\n    const { sendingData, derivationPath, commandFactory } = this.args;\n\n    const paths = DerivationPathUtils.splitPath(derivationPath);\n    const builder = new ByteArrayBuilder(\n      sendingData.length + 2 + paths.length * PATH_SIZE,\n    );\n    // add the number of signers\n    builder.add8BitUIntToData(1);\n    // add the number of derivation\n    builder.add8BitUIntToData(paths.length);\n    // add every derivation path\n    paths.forEach((path) => builder.add32BitUIntToData(path));\n    builder.addBufferToData(sendingData);\n    const buffer = builder.build();\n\n    return await new SendCommandInChunksTask<Maybe<Signature>>(this.api, {\n      data: buffer,\n      commandFactory,\n    }).run();\n  }\n}\n"],
+  "mappings": "AAAA,OACE,oBAAAA,MAGK,kCACP,OAAS,uBAAAC,MAA2B,yBAKpC,OAEE,2BAAAC,MACK,4BAEP,MAAMC,EAAY,EAQX,MAAMC,CAAa,CACxB,YACUC,EACAC,EACR,CAFQ,SAAAD,EACA,UAAAC,CACP,CAEH,MAAM,KAAsD,CAC1D,KAAM,CAAE,YAAAC,EAAa,eAAAC,EAAgB,eAAAC,CAAe,EAAI,KAAK,KAEvDC,EAAQT,EAAoB,UAAUO,CAAc,EACpDG,EAAU,IAAIX,EAClBO,EAAY,OAAS,EAAIG,EAAM,OAASP,CAC1C,EAEAQ,EAAQ,kBAAkB,CAAC,EAE3BA,EAAQ,kBAAkBD,EAAM,MAAM,EAEtCA,EAAM,QAASE,GAASD,EAAQ,mBAAmBC,CAAI,CAAC,EACxDD,EAAQ,gBAAgBJ,CAAW,EACnC,MAAMM,EAASF,EAAQ,MAAM,EAE7B,OAAO,MAAM,IAAIT,EAA0C,KAAK,IAAK,CACnE,KAAMW,EACN,eAAAJ,CACF,CAAC,EAAE,IAAI,CACT,CACF",
+  "names": ["ByteArrayBuilder", "DerivationPathUtils", "SendCommandInChunksTask", "PATH_SIZE", "SignDataTask", "api", "args", "sendingData", "derivationPath", "commandFactory", "paths", "builder", "path", "buffer"]
+}

package/lib/esm/internal/app-binder/task/SendSignDataTask.test.js

@@ -0,0 +1,2 @@
+import{APDU_MAX_PAYLOAD as m,ByteArrayBuilder as u,CommandResultFactory as T,InvalidStatusWordError as h,isSuccessCommandResult as E}from"@ledgerhq/device-management-kit";import{DerivationPathUtils as C}from"@ledgerhq/signer-utils";import{Just as I,Nothing as b}from"purify-ts";import{SignTransactionCommand as x}from"../../app-binder/command/SignTransactionCommand";import{makeDeviceActionInternalApiMock as v}from"../../app-binder/device-action/__test-utils__/makeInternalApi";import{SignDataTask as f}from"../../app-binder/task/SendSignDataTask";const r="44'/501'/0'/0'",g=4;describe("SignDataTask",()=>{const t=v(),p=new Uint8Array([18,52,86,120,144,171,205,239]),A=T({data:I(p)}),D=T({data:b});beforeEach(()=>{jest.resetAllMocks()}),describe("run with SignTransactionCommand",()=>{const i=new Uint8Array([1,2,3,4]),c=new Uint8Array(new Array(500).fill(1));it("should send the transaction in a single command",async()=>{const n=C.splitPath(r),e=new u(i.length+2+n.length*g);e.add8BitUIntToData(1),e.add8BitUIntToData(n.length),n.forEach(s=>e.add32BitUIntToData(s)),e.addBufferToData(i);const o=e.build(),d={derivationPath:r,sendingData:i,commandFactory:s=>new x({serializedTransaction:s.chunkedData,more:s.more,extend:s.extend})};t.sendCommand.mockResolvedValueOnce(A);const a=await new f(t,d).run();expect(t.sendCommand).toHaveBeenCalledTimes(1),expect(Array.from(t.sendCommand.mock.calls[0]?.[0]?.args?.serializedTransaction||[])).toEqual(Array.from(o)),E(a)?expect(a.data).toEqual(I(p)):fail(`Expected a successful result, but got an error: ${a.error}`)}),it("should send the transaction in chunks",async()=>{const n=C.splitPath(r),e=new u(c.length+2+n.length*g);e.add8BitUIntToData(1),e.add8BitUIntToData(n.length),n.forEach(l=>e.add32BitUIntToData(l)),e.addBufferToData(c);const o=e.build(),d=o.slice(0,m),a=o.slice(m,m*2),s=o.slice(m*2,m*3),w={derivationPath:r,sendingData:c,commandFactory:l=>new x({serializedTransaction:l.chunkedData,more:l.more,extend:l.extend})};t.sendCommand.mockResolvedValueOnce(D).mockResolvedValueOnce(D).mockResolvedValueOnce(A);const B=await new f(t,w).run();expect(t.sendCommand).toHaveBeenCalledTimes(3),expect(t.sendCommand).toHaveBeenNthCalledWith(1,expect.objectContaining({args:{serializedTransaction:d,extend:!1,more:!0}})),expect(t.sendCommand).toHaveBeenNthCalledWith(2,expect.objectContaining({args:{serializedTransaction:a,extend:!0,more:!0}})),expect(t.sendCommand).toHaveBeenNthCalledWith(3,expect.objectContaining({args:{serializedTransaction:s,extend:!0,more:!1}})),E(B)?expect(B.data).toEqual(I(p)):fail(`Expected a successful result, but got an error: ${B.error}`)}),it("should return an error if the command fails",async()=>{const n=C.splitPath(r),e=new u(i.length+2+n.length*g);e.add8BitUIntToData(1),e.add8BitUIntToData(n.length),n.forEach(a=>e.add32BitUIntToData(a)),e.addBufferToData(i);const o={derivationPath:r,sendingData:i,commandFactory:a=>new x({serializedTransaction:a.chunkedData,more:a.more,extend:a.extend})};t.sendCommand.mockResolvedValueOnce(T({error:new h("no signature returned")}));const d=await new f(t,o).run();expect(t.sendCommand).toHaveBeenCalledTimes(1),expect(d).toMatchObject({error:new h("no signature returned")})}),it("should return an error if a chunk command fails",async()=>{const n=C.splitPath(r),e=new u(c.length+2+n.length*g);e.add8BitUIntToData(1),e.add8BitUIntToData(n.length),n.forEach(a=>e.add32BitUIntToData(a)),e.addBufferToData(c);const o={derivationPath:r,sendingData:c,commandFactory:a=>new x({serializedTransaction:a.chunkedData,more:a.more,extend:a.extend})};t.sendCommand.mockResolvedValueOnce(D).mockResolvedValueOnce(T({error:new h("An error occurred")}));const d=await new f(t,o).run();expect(t.sendCommand).toHaveBeenCalledTimes(2),expect(d).toMatchObject({error:new h("An error occurred")})})})});
+//# sourceMappingURL=SendSignDataTask.test.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendSignDataTask.test.ts"],
+  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  ByteArrayBuilder,\n  CommandResultFactory,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { DerivationPathUtils } from \"@ledgerhq/signer-utils\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { SignTransactionCommand } from \"@internal/app-binder/command/SignTransactionCommand\";\nimport { makeDeviceActionInternalApiMock } from \"@internal/app-binder/device-action/__test-utils__/makeInternalApi\";\nimport { SignDataTask } from \"@internal/app-binder/task/SendSignDataTask\";\n\nimport { type ChunkableCommandArgs } from \"./SendCommandInChunksTask\";\n\nconst DERIVATION_PATH = \"44'/501'/0'/0'\";\nconst PATH_SIZE = 4;\n\ndescribe(\"SignDataTask\", () => {\n  const apiMock = makeDeviceActionInternalApiMock();\n  const signature = new Uint8Array([\n    0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,\n  ]);\n  const resultOk = CommandResultFactory({ data: Just(signature) });\n  const resultNothing = CommandResultFactory({ data: Nothing });\n\n  beforeEach(() => {\n    jest.resetAllMocks();\n  });\n\n  describe(\"run with SignTransactionCommand\", () => {\n    const SIMPLE_TRANSACTION = new Uint8Array([0x01, 0x02, 0x03, 0x04]);\n    const BIG_TRANSACTION = new Uint8Array(new Array(500).fill(0x01));\n\n    it(\"should send the transaction in a single command\", async () => {\n      // GIVEN-------------------------------\n      //-------------------------------------\n      const paths = DerivationPathUtils.splitPath(DERIVATION_PATH);\n      const builder = new ByteArrayBuilder(\n        SIMPLE_TRANSACTION.length + 2 + paths.length * PATH_SIZE,\n      );\n      builder.add8BitUIntToData(1);\n      builder.add8BitUIntToData(paths.length);\n      paths.forEach((path) => builder.add32BitUIntToData(path));\n      builder.addBufferToData(SIMPLE_TRANSACTION);\n      const EXPECTED_SIMPLE_TRANSACTION = builder.build();\n\n      const args = {\n        derivationPath: DERIVATION_PATH,\n        sendingData: SIMPLE_TRANSACTION,\n        commandFactory: (chunkArgs: ChunkableCommandArgs) =>\n          new SignTransactionCommand({\n            serializedTransaction: chunkArgs.chunkedData,\n            more: chunkArgs.more,\n            extend: chunkArgs.extend,\n          }),\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultOk);\n\n      // WHEN--------------------------------\n      //-------------------------------------\n      const result = await new SignDataTask(apiMock, args).run();\n\n      // THEN--------------------------------\n      //-------------------------------------\n      expect(apiMock.sendCommand).toHaveBeenCalledTimes(1);\n      expect(\n        Array.from(\n          (apiMock.sendCommand.mock.calls[0]?.[0] as SignTransactionCommand)\n            ?.args?.serializedTransaction || [],\n        ),\n      ).toEqual(Array.from(EXPECTED_SIMPLE_TRANSACTION));\n\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toEqual(Just(signature));\n      } else {\n        fail(`Expected a successful result, but got an error: ${result.error}`);\n      }\n    });\n\n    it(\"should send the transaction in chunks\", async () => {\n      // GIVEN-------------------------------\n      //-------------------------------------\n      const paths = DerivationPathUtils.splitPath(DERIVATION_PATH);\n      const builder = new ByteArrayBuilder(\n        BIG_TRANSACTION.length + 2 + paths.length * PATH_SIZE,\n      );\n      builder.add8BitUIntToData(1);\n      builder.add8BitUIntToData(paths.length);\n      paths.forEach((path) => builder.add32BitUIntToData(path));\n      builder.addBufferToData(BIG_TRANSACTION);\n      const dataBuffer = builder.build();\n\n      const EXPECTED_BIG_TRANSACTION_CHUNK_1 = dataBuffer.slice(\n        0,\n        APDU_MAX_PAYLOAD,\n      );\n      const EXPECTED_BIG_TRANSACTION_CHUNK_2 = dataBuffer.slice(\n        APDU_MAX_PAYLOAD,\n        APDU_MAX_PAYLOAD * 2,\n      );\n      const EXPECTED_BIG_TRANSACTION_CHUNK_3 = dataBuffer.slice(\n        APDU_MAX_PAYLOAD * 2,\n        APDU_MAX_PAYLOAD * 3,\n      );\n\n      const args = {\n        derivationPath: DERIVATION_PATH,\n        sendingData: BIG_TRANSACTION,\n        commandFactory: (chunkArgs: ChunkableCommandArgs) =>\n          new SignTransactionCommand({\n            serializedTransaction: chunkArgs.chunkedData,\n            more: chunkArgs.more,\n            extend: chunkArgs.extend,\n          }),\n      };\n      apiMock.sendCommand\n        .mockResolvedValueOnce(resultNothing)\n        .mockResolvedValueOnce(resultNothing)\n        .mockResolvedValueOnce(resultOk);\n\n      // WHEN--------------------------------\n      //-------------------------------------\n      const result = await new SignDataTask(apiMock, args).run();\n\n      // THEN--------------------------------\n      //-------------------------------------\n      expect(apiMock.sendCommand).toHaveBeenCalledTimes(3);\n      expect(apiMock.sendCommand).toHaveBeenNthCalledWith(\n        1,\n        expect.objectContaining({\n          args: {\n            serializedTransaction: EXPECTED_BIG_TRANSACTION_CHUNK_1,\n            extend: false,\n            more: true,\n          },\n        }),\n      );\n      expect(apiMock.sendCommand).toHaveBeenNthCalledWith(\n        2,\n        expect.objectContaining({\n          args: {\n            serializedTransaction: EXPECTED_BIG_TRANSACTION_CHUNK_2,\n            extend: true,\n            more: true,\n          },\n        }),\n      );\n\n      expect(apiMock.sendCommand).toHaveBeenNthCalledWith(\n        3,\n        expect.objectContaining({\n          args: {\n            serializedTransaction: EXPECTED_BIG_TRANSACTION_CHUNK_3,\n            extend: true,\n            more: false,\n          },\n        }),\n      );\n\n      if (isSuccessCommandResult(result)) {\n        expect(result.data).toEqual(Just(signature));\n      } else {\n        fail(`Expected a successful result, but got an error: ${result.error}`);\n      }\n    });\n\n    it(\"should return an error if the command fails\", async () => {\n      // GIVEN-------------------------------\n      //-------------------------------------\n      const paths = DerivationPathUtils.splitPath(DERIVATION_PATH);\n      const builder = new ByteArrayBuilder(\n        SIMPLE_TRANSACTION.length + 2 + paths.length * PATH_SIZE,\n      );\n      builder.add8BitUIntToData(1);\n      builder.add8BitUIntToData(paths.length);\n      paths.forEach((path) => builder.add32BitUIntToData(path));\n      builder.addBufferToData(SIMPLE_TRANSACTION);\n\n      const args = {\n        derivationPath: DERIVATION_PATH,\n        sendingData: SIMPLE_TRANSACTION,\n        commandFactory: (chunkArgs: ChunkableCommandArgs) =>\n          new SignTransactionCommand({\n            serializedTransaction: chunkArgs.chunkedData,\n            more: chunkArgs.more,\n            extend: chunkArgs.extend,\n          }),\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"no signature returned\"),\n        }),\n      );\n\n      // WHEN--------------------------------\n      //-------------------------------------\n      const result = await new SignDataTask(apiMock, args).run();\n\n      // THEN--------------------------------\n      //-------------------------------------\n      expect(apiMock.sendCommand).toHaveBeenCalledTimes(1);\n      expect(result).toMatchObject({\n        error: new InvalidStatusWordError(\"no signature returned\"),\n      });\n    });\n\n    it(\"should return an error if a chunk command fails\", async () => {\n      // GIVEN-------------------------------\n      //-------------------------------------\n      const paths = DerivationPathUtils.splitPath(DERIVATION_PATH);\n      const builder = new ByteArrayBuilder(\n        BIG_TRANSACTION.length + 2 + paths.length * PATH_SIZE,\n      );\n      builder.add8BitUIntToData(1);\n      builder.add8BitUIntToData(paths.length);\n      paths.forEach((path) => builder.add32BitUIntToData(path));\n      builder.addBufferToData(BIG_TRANSACTION);\n\n      const args = {\n        derivationPath: DERIVATION_PATH,\n        sendingData: BIG_TRANSACTION,\n        commandFactory: (chunkArgs: ChunkableCommandArgs) =>\n          new SignTransactionCommand({\n            serializedTransaction: chunkArgs.chunkedData,\n            more: chunkArgs.more,\n            extend: chunkArgs.extend,\n          }),\n      };\n      apiMock.sendCommand\n        .mockResolvedValueOnce(resultNothing)\n        .mockResolvedValueOnce(\n          CommandResultFactory({\n            error: new InvalidStatusWordError(\"An error occurred\"),\n          }),\n        );\n\n      // WHEN--------------------------------\n      //-------------------------------------\n      const result = await new SignDataTask(apiMock, args).run();\n\n      // THEN--------------------------------\n      //-------------------------------------\n      expect(apiMock.sendCommand).toHaveBeenCalledTimes(2);\n      expect(result).toMatchObject({\n        error: new InvalidStatusWordError(\"An error occurred\"),\n      });\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["APDU_MAX_PAYLOAD", "ByteArrayBuilder", "CommandResultFactory", "InvalidStatusWordError", "isSuccessCommandResult", "DerivationPathUtils", "Just", "Nothing", "SignTransactionCommand", "makeDeviceActionInternalApiMock", "SignDataTask", "DERIVATION_PATH", "PATH_SIZE", "apiMock", "signature", "resultOk", "resultNothing", "SIMPLE_TRANSACTION", "BIG_TRANSACTION", "paths", "builder", "path", "EXPECTED_SIMPLE_TRANSACTION", "args", "chunkArgs", "result", "dataBuffer", "EXPECTED_BIG_TRANSACTION_CHUNK_1", "EXPECTED_BIG_TRANSACTION_CHUNK_2", "EXPECTED_BIG_TRANSACTION_CHUNK_3"]
+}

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

@@ -0,0 +1,2 @@
+import{ByteArrayBuilder as g}from"@ledgerhq/device-management-kit";import{DerivationPathUtils as l}from"@ledgerhq/signer-utils";import{SignOffChainMessageCommand as f}from"../../app-binder/command/SignOffChainMessageCommand";class y{constructor(n,e){this.api=n;this.args=e}async run(){const{sendingData:n,derivationPath:e}=this.args,s=this._buildApduCommand(this._buildFullMessage(n),l.splitPath(e));return await this.api.sendCommand(new f({message:s,derivationPath:e}))}_buildFullMessage(n){const e=new TextEncoder().encode("solana offchain"),s=4,a=new Uint8Array(s);a[2]=n.length;const i=new Uint8Array(1+e.length+a.length+n.length);let t=0;return i[t++]=255,i.set(e,t),t+=e.length,i.set(a,t),t+=a.length,i.set(n,t),i}_buildApduCommand(n,e){const o=e.length,r=new g(n.length+1+1+o*4);return r.add8BitUIntToData(1),r.add8BitUIntToData(o),e.forEach(u=>{const d=new Uint8Array(4);new DataView(d.buffer).setUint32(0,u,!1),r.addBufferToData(d)}),r.addBufferToData(n),r.build()}}export{y as SendSignMessageTask};
+//# sourceMappingURL=SendSignMessageTask.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendSignMessageTask.ts"],
+  "sourcesContent": ["import {\n  ByteArrayBuilder,\n  type CommandResult,\n  type InternalApi,\n} from \"@ledgerhq/device-management-kit\";\nimport { DerivationPathUtils } from \"@ledgerhq/signer-utils\";\n\nimport { SignOffChainMessageCommand } from \"@internal/app-binder/command/SignOffChainMessageCommand\";\n\nexport type SendSignMessageTaskArgs = {\n  sendingData: Uint8Array;\n  derivationPath: string;\n};\n\nexport type SendSignMessageTaskRunFunctionReturn = Promise<\n  CommandResult<Uint8Array, void>\n>;\n\nexport class SendSignMessageTask {\n  constructor(\n    private api: InternalApi,\n    private args: SendSignMessageTaskArgs,\n  ) {}\n\n  async run(): SendSignMessageTaskRunFunctionReturn {\n    const { sendingData, derivationPath } = this.args;\n\n    const commandBuffer = this._buildApduCommand(\n      this._buildFullMessage(sendingData),\n      DerivationPathUtils.splitPath(derivationPath),\n    );\n\n    return await this.api.sendCommand(\n      new SignOffChainMessageCommand({\n        message: commandBuffer,\n        derivationPath,\n      }),\n    );\n  }\n\n  private _buildFullMessage(sendingData: Uint8Array): Uint8Array {\n    const prefix = new TextEncoder().encode(\"solana offchain\");\n    const msgLengthFieldSize = 4;\n\n    const lengthBytes = new Uint8Array(msgLengthFieldSize);\n    lengthBytes[2] = sendingData.length;\n\n    const fullMessage = new Uint8Array(\n      1 + prefix.length + lengthBytes.length + sendingData.length,\n    );\n\n    let offset = 0;\n    fullMessage[offset++] = 0xff;\n    fullMessage.set(prefix, offset);\n    offset += prefix.length;\n    fullMessage.set(lengthBytes, offset);\n    offset += lengthBytes.length;\n    fullMessage.set(sendingData, offset);\n\n    return fullMessage;\n  }\n\n  private _buildApduCommand(\n    fullMessage: Uint8Array,\n    paths: number[],\n  ): Uint8Array {\n    const numberOfSigners = 1;\n    const pathSize = 4;\n    const signersCountSize = 1;\n    const derivationsCountSize = 1;\n    const numberOfDerivations = paths.length;\n    const builder = new ByteArrayBuilder(\n      fullMessage.length +\n        signersCountSize +\n        derivationsCountSize +\n        numberOfDerivations * pathSize,\n    );\n\n    builder.add8BitUIntToData(numberOfSigners);\n    builder.add8BitUIntToData(numberOfDerivations);\n\n    paths.forEach((path) => {\n      const buffer = new Uint8Array(4);\n      const view = new DataView(buffer.buffer);\n      view.setUint32(0, path, false);\n      builder.addBufferToData(buffer);\n    });\n\n    builder.addBufferToData(fullMessage);\n    return builder.build();\n  }\n}\n"],
+  "mappings": "AAAA,OACE,oBAAAA,MAGK,kCACP,OAAS,uBAAAC,MAA2B,yBAEpC,OAAS,8BAAAC,MAAkC,0DAWpC,MAAMC,CAAoB,CAC/B,YACUC,EACAC,EACR,CAFQ,SAAAD,EACA,UAAAC,CACP,CAEH,MAAM,KAA4C,CAChD,KAAM,CAAE,YAAAC,EAAa,eAAAC,CAAe,EAAI,KAAK,KAEvCC,EAAgB,KAAK,kBACzB,KAAK,kBAAkBF,CAAW,EAClCL,EAAoB,UAAUM,CAAc,CAC9C,EAEA,OAAO,MAAM,KAAK,IAAI,YACpB,IAAIL,EAA2B,CAC7B,QAASM,EACT,eAAAD,CACF,CAAC,CACH,CACF,CAEQ,kBAAkBD,EAAqC,CAC7D,MAAMG,EAAS,IAAI,YAAY,EAAE,OAAO,iBAAiB,EACnDC,EAAqB,EAErBC,EAAc,IAAI,WAAWD,CAAkB,EACrDC,EAAY,CAAC,EAAIL,EAAY,OAE7B,MAAMM,EAAc,IAAI,WACtB,EAAIH,EAAO,OAASE,EAAY,OAASL,EAAY,MACvD,EAEA,IAAIO,EAAS,EACb,OAAAD,EAAYC,GAAQ,EAAI,IACxBD,EAAY,IAAIH,EAAQI,CAAM,EAC9BA,GAAUJ,EAAO,OACjBG,EAAY,IAAID,EAAaE,CAAM,EACnCA,GAAUF,EAAY,OACtBC,EAAY,IAAIN,EAAaO,CAAM,EAE5BD,CACT,CAEQ,kBACNA,EACAE,EACY,CAKZ,MAAMC,EAAsBD,EAAM,OAC5BE,EAAU,IAAIhB,EAClBY,EAAY,OACV,EACA,EACAG,EAAsB,CAC1B,EAEA,OAAAC,EAAQ,kBAAkB,CAAe,EACzCA,EAAQ,kBAAkBD,CAAmB,EAE7CD,EAAM,QAASG,GAAS,CACtB,MAAMC,EAAS,IAAI,WAAW,CAAC,EAClB,IAAI,SAASA,EAAO,MAAM,EAClC,UAAU,EAAGD,EAAM,EAAK,EAC7BD,EAAQ,gBAAgBE,CAAM,CAChC,CAAC,EAEDF,EAAQ,gBAAgBJ,CAAW,EAC5BI,EAAQ,MAAM,CACvB,CACF",
+  "names": ["ByteArrayBuilder", "DerivationPathUtils", "SignOffChainMessageCommand", "SendSignMessageTask", "api", "args", "sendingData", "derivationPath", "commandBuffer", "prefix", "msgLengthFieldSize", "lengthBytes", "fullMessage", "offset", "paths", "numberOfDerivations", "builder", "path", "buffer"]
+}

package/lib/esm/internal/app-binder/task/SendSignMessageTask.test.js

@@ -0,0 +1,2 @@
+import{CommandResultFactory as d,InvalidStatusWordError as c}from"@ledgerhq/device-management-kit";import{makeDeviceActionInternalApiMock as u}from"../../app-binder/device-action/__test-utils__/makeInternalApi";import{SendSignMessageTask as s}from"../../app-binder/task/SendSignMessageTask";const r="44'/501'/0'/0'";describe("SendSignMessageTask",()=>{const e=u();beforeEach(()=>{jest.resetAllMocks()});const o=new Uint8Array([1,2,3,4]);describe("run with SignOffChainMessageCommand",()=>{it("should return an error if the command fails",async()=>{const n={derivationPath:r,sendingData:o};e.sendCommand.mockResolvedValueOnce(d({error:new c("no signature returned")}));const a=await new s(e,n).run();expect(e.sendCommand).toHaveBeenCalledTimes(1),expect(a).toMatchObject({error:new c("no signature returned")})}),it("should return success when the command executes successfully",async()=>{const n={derivationPath:r,sendingData:o},a=new Uint8Array([170,187,204,221]);e.sendCommand.mockResolvedValueOnce(d({data:a}));const t=await new s(e,n).run();expect(e.sendCommand).toHaveBeenCalledTimes(1),expect(t).toMatchObject({data:a})}),it("should handle invalid derivation paths",async()=>{const a={derivationPath:"invalid/path",sendingData:o},t=new s(e,a);await expect(t.run()).rejects.toThrowError()}),it("should handle empty message data",async()=>{const n=new Uint8Array([]),a={derivationPath:r,sendingData:n};e.sendCommand.mockResolvedValueOnce(d({data:new Uint8Array([])}));const t=await new s(e,a).run();if(expect(e.sendCommand).toHaveBeenCalledTimes(1),"data"in t)expect(t.data).toEqual(new Uint8Array([]));else throw new Error("Expected result to have data property")}),it("should correctly build the APDU command",async()=>{const n={derivationPath:r,sendingData:o},a=new s(e,n),t=a._buildFullMessage(o),i=[-2147483604,-2147483147,-2147483648,0],l=a._buildApduCommand(t,i),m=2+i.length*4+t.length;expect(l.length).toEqual(m)}),it("should handle messages with maximum allowed length",async()=>{const n=new Uint8Array(255).fill(1),a={derivationPath:r,sendingData:n};e.sendCommand.mockResolvedValueOnce(d({data:new Uint8Array([153,136,119])}));const t=await new s(e,a).run();if(expect(e.sendCommand).toHaveBeenCalledTimes(1),"data"in t)expect(t.data).toEqual(new Uint8Array([153,136,119]));else throw new Error("Expected result to have data property")})})});
+//# sourceMappingURL=SendSignMessageTask.test.js.map