@ledgerhq/device-signer-kit-ethereum 1.0.0 → 1.1.0

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

@@ -1 +1,7 @@
-{"version":3,"file":"SendSignTransactionTask.js","sourceRoot":"","sources":["../../../../../src/internal/app-binder/task/SendSignTransactionTask.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAEhB,oBAAoB,EAEpB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EACL,sBAAsB,GAEvB,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAEjF,MAAM,SAAS,GAAG,CAAC,CAAC;AAOpB,MAAM,OAAO,uBAAuB;IAExB;IACA;IAFV,YACU,GAAgB,EAChB,IAAiC;QADjC,QAAG,GAAH,GAAG,CAAa;QAChB,SAAI,GAAJ,IAAI,CAA6B;IACxC,CAAC;IAEJ,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,cAAc,EAAE,qBAAqB,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC;QAC5D,MAAM,KAAK,GAAG,mBAAmB,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC;QAE5D,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAClC,qBAAqB,CAAC,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,CAC5D,CAAC;QACF,kCAAkC;QAClC,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACxC,4BAA4B;QAC5B,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACrB,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QACH,sBAAsB;QACtB,OAAO,CAAC,eAAe,CAAC,qBAAqB,CAAC,CAAC;QAE/C,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;QAE/B,IAAI,MAAM,GAAG,oBAAoB,CAAuC;YACtE,IAAI,EAAE,OAAO;SACd,CAAC,CAAC;QAEH,+BAA+B;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,gBAAgB,EAAE,CAAC;YACzD,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,WAAW,CACjC,IAAI,sBAAsB,CAAC;gBACzB,qBAAqB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC;gBAC5D,YAAY,EAAE,CAAC,KAAK,CAAC;aACtB,CAAC,CACH,CAAC;YAEF,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,EAAE,CAAC;gBACpC,OAAO,MAAM,CAAC;YAChB,CAAC;QACH,CAAC;QAED,IAAI,sBAAsB,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;YAC3D,OAAO,oBAAoB,CAAC;gBAC1B,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE;aAC5B,CAAC,CAAC;QACL,CAAC;QAED,OAAO,oBAAoB,CAAC;YAC1B,KAAK,EAAE,IAAI,sBAAsB,CAAC,uBAAuB,CAAC;SAC3D,CAAC,CAAC;IACL,CAAC;CACF"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendSignTransactionTask.ts"],
+  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  ByteArrayBuilder,\n  type CommandResult,\n  CommandResultFactory,\n  hexaStringToBuffer,\n  type InternalApi,\n  InvalidStatusWordError,\n  isSuccessCommandResult,\n} from \"@ledgerhq/device-management-kit\";\nimport { DerivationPathUtils } from \"@ledgerhq/signer-utils\";\nimport { decodeRlp, encodeRlp } from \"ethers-v6\";\nimport { Nothing } from \"purify-ts\";\n\nimport { type Signature } from \"@api/index\";\nimport { TransactionType } from \"@api/model/Transaction\";\nimport {\n  SignTransactionCommand,\n  type SignTransactionCommandResponse,\n} from \"@internal/app-binder/command/SignTransactionCommand\";\nimport { StartTransactionCommand } from \"@internal/app-binder/command/StartTransactionCommand\";\n\nconst PATH_SIZE = 4;\n\ntype SendSignTransactionTaskArgs = {\n  derivationPath: string;\n  serializedTransaction: Uint8Array;\n  chainId: number;\n  transactionType: TransactionType;\n  isLegacy: boolean;\n};\n\nexport class SendSignTransactionTask {\n  constructor(\n    private api: InternalApi,\n    private args: SendSignTransactionTaskArgs,\n  ) {}\n\n  async run(): Promise<CommandResult<Signature, void>> {\n    // For generic-parser transactions, the derivation path and transaction were previously sent\n    if (!this.args.isLegacy) {\n      const signature = await this.api.sendCommand(\n        new StartTransactionCommand(),\n      );\n      if (!isSuccessCommandResult(signature)) {\n        return signature;\n      }\n      return this.recoverSignature(signature.data).mapOrDefault(\n        (data) => CommandResultFactory({ data }),\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"no signature returned\"),\n        }),\n      );\n    }\n\n    // For other transactions, add derivation path and transaction to the payload\n    const { derivationPath, serializedTransaction } = this.args;\n    const paths = DerivationPathUtils.splitPath(derivationPath);\n    const builder = new ByteArrayBuilder(\n      serializedTransaction.length + 1 + paths.length * PATH_SIZE,\n    );\n    // add the derivation paths length\n    builder.add8BitUIntToData(paths.length);\n    // add every derivation path\n    paths.forEach((path) => {\n      builder.add32BitUIntToData(path);\n    });\n    const derivations = builder.build();\n\n    // Send chunks\n    const chunks = this.getChunks(derivations, serializedTransaction);\n    let resultData: SignTransactionCommandResponse = Nothing;\n    for (let i = 0; i < chunks.length; i++) {\n      const result = await this.api.sendCommand(\n        new SignTransactionCommand({\n          serializedTransaction: chunks[i]!,\n          isFirstChunk: i === 0,\n        }),\n      );\n      if (!isSuccessCommandResult(result)) {\n        return result;\n      }\n      resultData = result.data;\n    }\n\n    return this.recoverSignature(resultData).mapOrDefault(\n      (data) => CommandResultFactory({ data }),\n      CommandResultFactory({\n        error: new InvalidStatusWordError(\"no signature returned\"),\n      }),\n    );\n  }\n\n  private getChunks(\n    derivations: Uint8Array,\n    serializedTransaction: Uint8Array,\n  ): Uint8Array[] {\n    const buffer = Uint8Array.from([...derivations, ...serializedTransaction]);\n\n    // No chunking for small transactions\n    let chunkSize = APDU_MAX_PAYLOAD;\n    if (buffer.length <= chunkSize) {\n      return [buffer];\n    }\n\n    // Since EIP-155, legacy transactions signature encode the chainId in V parity and\n    // it has to be part of the hashed transaction:\n    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md\n    //\n    // A known issue is present in ethereum app for those transactions:\n    // if the last chunk start at the EIP-155 marker (the chainId), then the app\n    // will confuse it with a pre-eip155 transaction, and compute an invalid signature\n    // before receiving the last chunk...\n    // It cannot be fixed without breaking APDU backward compatibility.\n    //\n    // Therefore the client has to make sure the last chunk don't start on that marker.\n    if (this.args.transactionType === TransactionType.LEGACY) {\n      try {\n        // Decode the RLP of the transaction and keep only the last 3 elements (v, r, s)\n        const decodedRlp = decodeRlp(serializedTransaction);\n        if (Array.isArray(decodedRlp)) {\n          const decodedVrs = decodedRlp.slice(-3);\n          // Encode those values back to RLP in order to get the length of this serialized list\n          // Result should be something like [0xc0 + list payload length, list.map(rlp)]\n          // since only v can be used to store the chainId in legacy transactions\n          const encodedVrs = encodeRlp(decodedVrs);\n          // Since chainIds are uint256, the list payload length can be 1B (v rlp description) + 32B (v) + 1B (r) + 1B (s) = 35B max (< 55B)\n          // Therefore, the RLP of this vrs list should be prefixed by a value between [0xc1, 0xe3] (0xc0 + 35B = 0xe3 max)\n          // @see https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/\n          // `encodedVrs` is then everything but the first byte of this serialization\n          const encodedVrsBuff = hexaStringToBuffer(encodedVrs)!.subarray(1);\n\n          // Now we search for the biggest chunk value that won't chunk just before the v,r,s values.\n          for (\n            chunkSize = APDU_MAX_PAYLOAD;\n            chunkSize > derivations.length;\n            chunkSize--\n          ) {\n            const lastChunkSize = buffer.length % chunkSize;\n            if (lastChunkSize === 0 || lastChunkSize > encodedVrsBuff.length) {\n              break;\n            }\n          }\n        }\n      } catch (_error) {\n        // fallback to \"standard\" APDU chunk size if the transaction cannot be decoded\n        chunkSize = APDU_MAX_PAYLOAD;\n      }\n    }\n\n    // Finally we can chunk the buffer\n    let offset = 0;\n    const chunks: Uint8Array[] = [];\n    while (offset < buffer.length) {\n      chunks.push(buffer.slice(offset, offset + chunkSize));\n      offset += chunkSize;\n    }\n    return chunks;\n  }\n\n  private recoverSignature(\n    data: SignTransactionCommandResponse,\n  ): SignTransactionCommandResponse {\n    return data.map(({ v, r, s }) => {\n      if (this.args.transactionType !== TransactionType.LEGACY) {\n        return { v, r, s };\n      }\n\n      // Legacy transactions after EIP-155 has a signature parity formatted as:\n      //   V = CHAIN_ID * 2 + 35 + {0,1}\n      //     where {0,1} is the parity\n      // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md\n      //\n      // A known issue is present in ethereum app:\n      // - chainId is encoded on 32 bits\n      // - V is encoded on 8 bits\n      // It means both can overflow for big chain IDs.\n      //\n      // That's why the client has to reconstruct it, to keep APDU backward compatibility\n      // for main chain IDs.\n      //\n      // For more infos:\n      // https://github.com/LedgerHQ/app-ethereum/blob/1.12.2/src_features/signTx/ui_common_signTx.c#L36\n      // https://github.com/LedgerHQ/app-ethereum/blob/1.12.2/client/src/ledger_app_clients/ethereum/utils.py#L35\n\n      // First truncate the chainId\n      const MAX_UINT32 = 0xffffffff;\n      let truncatedChainId = this.args.chainId;\n      while (truncatedChainId > MAX_UINT32) {\n        truncatedChainId = truncatedChainId >> 8;\n      }\n\n      // Then truncate the parity encoding\n      const MAX_UINT8 = 0xff;\n      const v0 = (truncatedChainId * 2 + 35) & MAX_UINT8;\n\n      // Now reconstruct the full V\n      const parity = v == v0 ? 0 : 1;\n      const fullV = parity + this.args.chainId * 2 + 35;\n      return { v: fullV, r, s };\n    });\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["APDU_MAX_PAYLOAD", "ByteArrayBuilder", "CommandResultFactory", "hexaStringToBuffer", "InvalidStatusWordError", "isSuccessCommandResult", "DerivationPathUtils", "decodeRlp", "encodeRlp", "Nothing", "TransactionType", "SignTransactionCommand", "StartTransactionCommand", "PATH_SIZE", "SendSignTransactionTask", "api", "args", "signature", "data", "derivationPath", "serializedTransaction", "paths", "builder", "path", "derivations", "chunks", "resultData", "i", "result", "buffer", "chunkSize", "decodedRlp", "decodedVrs", "encodedVrs", "encodedVrsBuff", "lastChunkSize", "offset", "v", "s", "MAX_UINT32", "truncatedChainId", "v0"]
+}

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

@@ -0,0 +1,2 @@
+import{APDU_MAX_PAYLOAD as d,CommandResultFactory as i,hexaStringToBuffer as v,InvalidStatusWordError as y}from"@ledgerhq/device-management-kit";import{Transaction as k}from"ethers-v6";import{Just as m,Nothing as C}from"purify-ts";import{SignTransactionCommand as s}from"../../app-binder/command/SignTransactionCommand";import{StartTransactionCommand as w}from"../../app-binder/command/StartTransactionCommand";import{makeDeviceActionInternalApiMock as T}from"../../app-binder/device-action/__test-utils__/makeInternalApi";import{SendSignTransactionTask as n}from"./SendSignTransactionTask";const r=new Uint8Array([5,128,0,0,44,128,0,0,60,128,0,0,0,0,0,0,0,0,0,0,0]),t=new Uint8Array([5,128,0,0,44,128,0,0,60,128,0,0,0,0,0,0,0,0,0,0,0,248,107,130,6,126,132,87,25,19,31,131,1,16,104,148,218,193,127,149,141,46,229,35,162,32,98,6,153,69,151,193,61,131,30,199,128,184,68,169,5,156,187,0,0]),l=new Uint8Array([249,8,175,38,133,1,178,61,148,131,131,5,193,252,148,222,241,192,222,217,190,199,241,161,103,8,25,131,50,64,240,39,178,94,255,128,185,8,136,65,85,101,176,0,0,0,0,0,0,0,0,0,0,0,0,31,152,64,168,93,90,245,191,29,23,98,249,37,189,173,220,66,1,249,132,0,0,0,0,0,0,0,0,0,0,0,0,160,184,105,145,198,33,139,54,193,209,157,74,46,158,176,206,54,6,235,72,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,97,233,51,89,83,149,108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,51,239,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,96,0,0,0,0,0,0,0,0,0]);describe("SendSignTransactionTask",()=>{const x=T(),u={v:27,r:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",s:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"},f=i({data:m(u)}),o=i({data:C});beforeEach(()=>{jest.resetAllMocks()}),describe("run",()=>{it("should send the transaction in one command",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:1,transactionType:1,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(f);const a=await new n(x,e).run();expect(x.sendCommand.mock.calls).toHaveLength(1),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new s({serializedTransaction:new Uint8Array([...r,...t]),isFirstChunk:!0})),expect(a.data).toStrictEqual(u)}),it("Generic-parser transaction should be signed without payload",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:1,transactionType:1,isLegacy:!1};x.sendCommand.mockResolvedValueOnce(f);const a=await new n(x,e).run();expect(x.sendCommand.mock.calls).toHaveLength(1),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new w),expect(a.data).toStrictEqual(u)}),it("should send the transaction in chunks",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:l,chainId:1,transactionType:1,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(o),x.sendCommand.mockResolvedValueOnce(f);const a=await new n(x,e).run();expect(x.sendCommand.mock.calls).toHaveLength(2),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new s({serializedTransaction:new Uint8Array([...r,...l]).slice(0,d),isFirstChunk:!0})),expect(x.sendCommand.mock.calls[1][0]).toStrictEqual(new s({serializedTransaction:new Uint8Array([...r,...l]).slice(d,d*2),isFirstChunk:!1})),expect(a.data).toStrictEqual(u)}),it.each([[458,127,254],[458,0x818181818181,254],[452,0x818181818181,251]])("should prevent chunking legacy transactions just before the [r,s,v] for dataSize %i, chainId %i",async(e,a,h)=>{const c=new k;c.to="0x0123456789abcdef0123456789abcdef01234567",c.nonce=0,c.value=0n,c.gasLimit=1n,c.gasPrice=2n,c.data="0x"+new Array(e).fill("00").join(""),c.chainId=a,c.type=0;const p=v(c.unsignedSerialized),g={derivationPath:"44'/60'/0'/0/0",serializedTransaction:p,chainId:a,transactionType:0,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(o),x.sendCommand.mockResolvedValueOnce(o),x.sendCommand.mockResolvedValue(f),await new n(x,g).run();const b=Uint8Array.from([...r,...p]);expect(x.sendCommand.mock.calls).toHaveLength(3),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new s({serializedTransaction:b.slice(0,h),isFirstChunk:!0})),expect(x.sendCommand.mock.calls[1][0]).toStrictEqual(new s({serializedTransaction:b.slice(h,h*2),isFirstChunk:!1})),expect(x.sendCommand.mock.calls[2][0]).toStrictEqual(new s({serializedTransaction:b.slice(h*2),isFirstChunk:!1}))}),it("should return an error if the command fails",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:1,transactionType:1,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(o);const a=await new n(x,e).run();expect(x.sendCommand.mock.calls).toHaveLength(1),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new s({serializedTransaction:new Uint8Array([...r,...t]),isFirstChunk:!0})),expect(a.error).toStrictEqual(new y("no signature returned"))}),it("should return an error if the generic-parser command fails",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:1,transactionType:1,isLegacy:!1};x.sendCommand.mockResolvedValueOnce(o);const a=await new n(x,e).run();expect(x.sendCommand.mock.calls).toHaveLength(1),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new w),expect(a.error).toStrictEqual(new y("no signature returned"))}),it("should return an error if the command fails in the middle of the transaction",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:l,chainId:1,transactionType:1,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(o),x.sendCommand.mockResolvedValueOnce(i({error:new y("An error")}));const a=await new n(x,e).run();expect(x.sendCommand.mock.calls).toHaveLength(2),expect(x.sendCommand.mock.calls[0][0]).toStrictEqual(new s({serializedTransaction:new Uint8Array([...r,...l]).slice(0,d),isFirstChunk:!0})),expect(x.sendCommand.mock.calls[1][0]).toStrictEqual(new s({serializedTransaction:new Uint8Array([...r,...l]).slice(d,d*2),isFirstChunk:!1})),expect(a.error).toStrictEqual(new y("An error"))}),it("legacy transaction with small chainId",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:56,transactionType:0,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(i({data:m({v:147,r:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",s:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"})}));const a=await new n(x,e).run();expect(a.data.v).toStrictEqual(147)}),it("legacy transaction with small chainId with positive parity",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:56,transactionType:0,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(i({data:m({v:148,r:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",s:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"})}));const a=await new n(x,e).run();expect(a.data.v).toStrictEqual(148)}),it("legacy transaction with big chainId",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:11297108109,transactionType:0,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(i({data:m({v:131,r:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",s:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"})}));const a=await new n(x,e).run();expect(a.data.v).toStrictEqual(22594216253)}),it("legacy transaction with big chainId with positive parity",async()=>{const e={derivationPath:"44'/60'/0'/0/0",serializedTransaction:t,chainId:11297108109,transactionType:0,isLegacy:!0};x.sendCommand.mockResolvedValueOnce(i({data:m({v:132,r:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",s:"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"})}));const a=await new n(x,e).run();expect(a.data.v).toStrictEqual(22594216254)})})});
+//# sourceMappingURL=SendSignTransactionTask.test.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/app-binder/task/SendSignTransactionTask.test.ts"],
+  "sourcesContent": ["import {\n  APDU_MAX_PAYLOAD,\n  CommandResultFactory,\n  hexaStringToBuffer,\n  InvalidStatusWordError,\n} from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers-v6\";\nimport { Just, Nothing } from \"purify-ts\";\n\nimport { SignTransactionCommand } from \"@internal/app-binder/command/SignTransactionCommand\";\nimport { StartTransactionCommand } from \"@internal/app-binder/command/StartTransactionCommand\";\nimport { makeDeviceActionInternalApiMock } from \"@internal/app-binder/device-action/__test-utils__/makeInternalApi\";\n\nimport { SendSignTransactionTask } from \"./SendSignTransactionTask\";\n\nconst PATH = new Uint8Array([\n  0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\nconst SIMPLE_TRANSACTION = new Uint8Array([\n  0x05, 0x80, 0x00, 0x00, 0x2c, 0x80, 0x00, 0x00, 0x3c, 0x80, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x6b, 0x82, 0x06, 0x7e,\n  0x84, 0x57, 0x19, 0x13, 0x1f, 0x83, 0x01, 0x10, 0x68, 0x94, 0xda, 0xc1, 0x7f,\n  0x95, 0x8d, 0x2e, 0xe5, 0x23, 0xa2, 0x20, 0x62, 0x06, 0x99, 0x45, 0x97, 0xc1,\n  0x3d, 0x83, 0x1e, 0xc7, 0x80, 0xb8, 0x44, 0xa9, 0x05, 0x9c, 0xbb, 0x00, 0x00,\n]);\n\nconst BIG_TRANSACTION = new Uint8Array([\n  0xf9, 0x08, 0xaf, 0x26, 0x85, 0x01, 0xb2, 0x3d, 0x94, 0x83, 0x83, 0x05, 0xc1,\n  0xfc, 0x94, 0xde, 0xf1, 0xc0, 0xde, 0xd9, 0xbe, 0xc7, 0xf1, 0xa1, 0x67, 0x08,\n  0x19, 0x83, 0x32, 0x40, 0xf0, 0x27, 0xb2, 0x5e, 0xff, 0x80, 0xb9, 0x08, 0x88,\n  0x41, 0x55, 0x65, 0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x1f, 0x98, 0x40, 0xa8, 0x5d, 0x5a, 0xf5, 0xbf, 0x1d, 0x17,\n  0x62, 0xf9, 0x25, 0xbd, 0xad, 0xdc, 0x42, 0x01, 0xf9, 0x84, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0xb8, 0x69, 0x91,\n  0xc6, 0x21, 0x8b, 0x36, 0xc1, 0xd1, 0x9d, 0x4a, 0x2e, 0x9e, 0xb0, 0xce, 0x36,\n  0x06, 0xeb, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x61, 0xe9, 0x33, 0x59, 0x53, 0x95, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x33,\n  0xef, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x05, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x40, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n  0x00, 0x00, 0x03, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n]);\n\ndescribe(\"SendSignTransactionTask\", () => {\n  const apiMock = makeDeviceActionInternalApiMock();\n  const signature = {\n    v: 27,\n    r: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n    s: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n  };\n  const resultOk = CommandResultFactory({\n    data: Just(signature),\n  });\n  const resultNothing = CommandResultFactory({ data: Nothing });\n\n  beforeEach(() => {\n    jest.resetAllMocks();\n  });\n\n  describe(\"run\", () => {\n    it(\"should send the transaction in one command\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 1,\n        transactionType: 1,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultOk);\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      expect(apiMock.sendCommand.mock.calls).toHaveLength(1);\n      expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n        new SignTransactionCommand({\n          serializedTransaction: new Uint8Array([\n            ...PATH,\n            ...SIMPLE_TRANSACTION,\n          ]),\n          isFirstChunk: true,\n        }),\n      );\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data).toStrictEqual(signature);\n    });\n\n    it(\"Generic-parser transaction should be signed without payload\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 1,\n        transactionType: 1,\n        isLegacy: false,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultOk);\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      expect(apiMock.sendCommand.mock.calls).toHaveLength(1);\n      expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n        new StartTransactionCommand(),\n      );\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data).toStrictEqual(signature);\n    });\n\n    it(\"should send the transaction in chunks\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: BIG_TRANSACTION,\n        chainId: 1,\n        transactionType: 1,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultNothing);\n      apiMock.sendCommand.mockResolvedValueOnce(resultOk);\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      expect(apiMock.sendCommand.mock.calls).toHaveLength(2);\n      expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n        new SignTransactionCommand({\n          serializedTransaction: new Uint8Array([\n            ...PATH,\n            ...BIG_TRANSACTION,\n          ]).slice(0, APDU_MAX_PAYLOAD),\n          isFirstChunk: true,\n        }),\n      );\n      expect(apiMock.sendCommand.mock.calls[1]![0]).toStrictEqual(\n        new SignTransactionCommand({\n          serializedTransaction: new Uint8Array([\n            ...PATH,\n            ...BIG_TRANSACTION,\n          ]).slice(APDU_MAX_PAYLOAD, APDU_MAX_PAYLOAD * 2),\n          isFirstChunk: false,\n        }),\n      );\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data).toStrictEqual(signature);\n    });\n\n    it.each([\n      [458, 127, 254],\n      [458, 0x818181818181, 254],\n      [452, 0x818181818181, 251],\n    ])(\n      \"should prevent chunking legacy transactions just before the [r,s,v] for dataSize %i, chainId %i\",\n      async (dataSize, chainId, chunkSize) => {\n        // GIVEN\n        const transaction = new Transaction();\n        transaction.to = \"0x0123456789abcdef0123456789abcdef01234567\";\n        transaction.nonce = 0;\n        transaction.value = 0n;\n        transaction.gasLimit = 1n;\n        transaction.gasPrice = 2n;\n        transaction.data = \"0x\" + new Array(dataSize).fill(\"00\").join(\"\");\n        transaction.chainId = chainId;\n        transaction.type = 0;\n        const serialized = hexaStringToBuffer(transaction.unsignedSerialized)!;\n        const args = {\n          derivationPath: \"44'/60'/0'/0/0\",\n          serializedTransaction: serialized,\n          chainId,\n          transactionType: 0,\n          isLegacy: true,\n        };\n        apiMock.sendCommand.mockResolvedValueOnce(resultNothing);\n        apiMock.sendCommand.mockResolvedValueOnce(resultNothing);\n        apiMock.sendCommand.mockResolvedValue(resultOk);\n\n        // WHEN\n        await new SendSignTransactionTask(apiMock, args).run();\n\n        // THEN\n        const payload = Uint8Array.from([...PATH, ...serialized]);\n        expect(apiMock.sendCommand.mock.calls).toHaveLength(3);\n        expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n          new SignTransactionCommand({\n            serializedTransaction: payload.slice(0, chunkSize),\n            isFirstChunk: true,\n          }),\n        );\n        expect(apiMock.sendCommand.mock.calls[1]![0]).toStrictEqual(\n          new SignTransactionCommand({\n            serializedTransaction: payload.slice(chunkSize, chunkSize * 2),\n            isFirstChunk: false,\n          }),\n        );\n        expect(apiMock.sendCommand.mock.calls[2]![0]).toStrictEqual(\n          new SignTransactionCommand({\n            serializedTransaction: payload.slice(chunkSize * 2),\n            isFirstChunk: false,\n          }),\n        );\n      },\n    );\n\n    it(\"should return an error if the command fails\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 1,\n        transactionType: 1,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultNothing);\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      expect(apiMock.sendCommand.mock.calls).toHaveLength(1);\n      expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n        new SignTransactionCommand({\n          serializedTransaction: new Uint8Array([\n            ...PATH,\n            ...SIMPLE_TRANSACTION,\n          ]),\n          isFirstChunk: true,\n        }),\n      );\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).error).toStrictEqual(\n        new InvalidStatusWordError(\"no signature returned\"),\n      );\n    });\n\n    it(\"should return an error if the generic-parser command fails\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 1,\n        transactionType: 1,\n        isLegacy: false,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultNothing);\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      expect(apiMock.sendCommand.mock.calls).toHaveLength(1);\n      expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n        new StartTransactionCommand(),\n      );\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).error).toStrictEqual(\n        new InvalidStatusWordError(\"no signature returned\"),\n      );\n    });\n\n    it(\"should return an error if the command fails in the middle of the transaction\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: BIG_TRANSACTION,\n        chainId: 1,\n        transactionType: 1,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(resultNothing);\n      apiMock.sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          error: new InvalidStatusWordError(\"An error\"),\n        }),\n      );\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      expect(apiMock.sendCommand.mock.calls).toHaveLength(2);\n      expect(apiMock.sendCommand.mock.calls[0]![0]).toStrictEqual(\n        new SignTransactionCommand({\n          serializedTransaction: new Uint8Array([\n            ...PATH,\n            ...BIG_TRANSACTION,\n          ]).slice(0, APDU_MAX_PAYLOAD),\n          isFirstChunk: true,\n        }),\n      );\n      expect(apiMock.sendCommand.mock.calls[1]![0]).toStrictEqual(\n        new SignTransactionCommand({\n          serializedTransaction: new Uint8Array([\n            ...PATH,\n            ...BIG_TRANSACTION,\n          ]).slice(APDU_MAX_PAYLOAD, APDU_MAX_PAYLOAD * 2),\n          isFirstChunk: false,\n        }),\n      );\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).error).toStrictEqual(\n        new InvalidStatusWordError(\"An error\"),\n      );\n    });\n\n    it(\"legacy transaction with small chainId\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 56,\n        transactionType: 0,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: Just({\n            v: 147,\n            r: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n            s: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n          }),\n        }),\n      );\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data.v).toStrictEqual(147);\n    });\n\n    it(\"legacy transaction with small chainId with positive parity\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 56,\n        transactionType: 0,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: Just({\n            v: 148,\n            r: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n            s: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n          }),\n        }),\n      );\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data.v).toStrictEqual(148);\n    });\n\n    it(\"legacy transaction with big chainId\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 11297108109,\n        transactionType: 0,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: Just({\n            v: 131,\n            r: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n            s: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n          }),\n        }),\n      );\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data.v).toStrictEqual(22594216253);\n    });\n\n    it(\"legacy transaction with big chainId with positive parity\", async () => {\n      // GIVEN\n      const args = {\n        derivationPath: \"44'/60'/0'/0/0\",\n        serializedTransaction: SIMPLE_TRANSACTION,\n        chainId: 11297108109,\n        transactionType: 0,\n        isLegacy: true,\n      };\n      apiMock.sendCommand.mockResolvedValueOnce(\n        CommandResultFactory({\n          data: Just({\n            v: 132,\n            r: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n            s: \"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef\",\n          }),\n        }),\n      );\n\n      // WHEN\n      const result = await new SendSignTransactionTask(apiMock, args).run();\n\n      // THEN\n      // eslint-disable-next-line  @typescript-eslint/no-explicit-any\n      expect((result as any).data.v).toStrictEqual(22594216254);\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OACE,oBAAAA,EACA,wBAAAC,EACA,sBAAAC,EACA,0BAAAC,MACK,kCACP,OAAS,eAAAC,MAAmB,YAC5B,OAAS,QAAAC,EAAM,WAAAC,MAAe,YAE9B,OAAS,0BAAAC,MAA8B,sDACvC,OAAS,2BAAAC,MAA+B,uDACxC,OAAS,mCAAAC,MAAuC,oEAEhD,OAAS,2BAAAC,MAA+B,4BAExC,MAAMC,EAAO,IAAI,WAAW,CAC1B,EAAM,IAAM,EAAM,EAAM,GAAM,IAAM,EAAM,EAAM,GAAM,IAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,CAC5C,CAAC,EAEKC,EAAqB,IAAI,WAAW,CACxC,EAAM,IAAM,EAAM,EAAM,GAAM,IAAM,EAAM,EAAM,GAAM,IAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,IAAM,IAAM,IAAM,EAAM,IACxE,IAAM,GAAM,GAAM,GAAM,GAAM,IAAM,EAAM,GAAM,IAAM,IAAM,IAAM,IAAM,IACxE,IAAM,IAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,EAAM,IAAM,GAAM,IAAM,IACxE,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,IAAM,EAAM,IAAM,IAAM,EAAM,CAC1E,CAAC,EAEKC,EAAkB,IAAI,WAAW,CACrC,IAAM,EAAM,IAAM,GAAM,IAAM,EAAM,IAAM,GAAM,IAAM,IAAM,IAAM,EAAM,IACxE,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EACxE,GAAM,IAAM,GAAM,GAAM,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,EAAM,IACxE,GAAM,GAAM,IAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,GAAM,IAAM,GAAM,IAAM,GAAM,GAAM,IAAM,IAAM,GAAM,GACxE,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,EAAM,IAAM,IAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,IAAM,IAAM,IAAM,IACxE,IAAM,GAAM,IAAM,GAAM,IAAM,IAAM,IAAM,GAAM,GAAM,IAAM,IAAM,IAAM,GACxE,EAAM,IAAM,GAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,GAAM,IAAM,GAAM,GAAM,GAAM,IAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,GACxE,IAAM,GAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,IAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,GACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EAAM,EACxE,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",
+  "names": ["APDU_MAX_PAYLOAD", "CommandResultFactory", "hexaStringToBuffer", "InvalidStatusWordError", "Transaction", "Just", "Nothing", "SignTransactionCommand", "StartTransactionCommand", "makeDeviceActionInternalApiMock", "SendSignTransactionTask", "PATH", "SIMPLE_TRANSACTION", "BIG_TRANSACTION", "apiMock", "signature", "resultOk", "resultNothing", "args", "result", "dataSize", "chainId", "chunkSize", "transaction", "serialized", "payload"]
+}

package/lib/esm/internal/di.js

@@ -1,23 +1,2 @@
-import { Container } from "inversify";
-// import { makeLoggerMiddleware } from "inversify-logger-middleware";
-import { addressModuleFactory } from "./address/di/addressModule";
-import { appBindingModuleFactory } from "./app-binder/di/appBinderModule";
-import { externalTypes } from "./externalTypes";
-import { messageModuleFactory } from "./message/di/messageModule";
-import { transactionModuleFactory } from "./transaction/di/transactionModule";
-import { typedDataModuleFactory } from "./typed-data/di/typedDataModule";
-export const makeContainer = ({ sdk, sessionId, contextModule, }) => {
-    const container = new Container();
-    // Uncomment this line to enable the logger middleware
-    // container.applyMiddleware(logger);
-    container.bind(externalTypes.Sdk).toConstantValue(sdk);
-    container
-        .bind(externalTypes.ContextModule)
-        .toConstantValue(contextModule);
-    container
-        .bind(externalTypes.SessionId)
-        .toConstantValue(sessionId);
-    container.load(addressModuleFactory(), appBindingModuleFactory(), messageModuleFactory(), transactionModuleFactory(), typedDataModuleFactory());
-    return container;
-};
-//# sourceMappingURL=di.js.map
+import{Container as a}from"inversify";import{addressModuleFactory as i}from"./address/di/addressModule";import{appBindingModuleFactory as m}from"./app-binder/di/appBinderModule";import{externalTypes as o}from"./externalTypes";import{messageModuleFactory as d}from"./message/di/messageModule";import{transactionModuleFactory as s}from"./transaction/di/transactionModule";import{typedDataModuleFactory as p}from"./typed-data/di/typedDataModule";const x=({dmk:t,sessionId:n,contextModule:r})=>{const e=new a;return e.bind(o.Dmk).toConstantValue(t),e.bind(o.ContextModule).toConstantValue(r),e.bind(o.SessionId).toConstantValue(n),e.load(i(),m(),d(),s(),p()),e};export{x as makeContainer};
+//# sourceMappingURL=di.js.map

package/lib/esm/internal/di.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../src/internal/di.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC,sEAAsE;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,EAAE,sBAAsB,EAAE,MAAM,yCAAyC,CAAC;AAWjF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,EAC5B,GAAG,EACH,SAAS,EACT,aAAa,GACM,EAAE,EAAE;IACvB,MAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;IAElC,sDAAsD;IACtD,qCAAqC;IAErC,SAAS,CAAC,IAAI,CAAY,aAAa,CAAC,GAAG,CAAC,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;IAClE,SAAS;SACN,IAAI,CAAgB,aAAa,CAAC,aAAa,CAAC;SAChD,eAAe,CAAC,aAAa,CAAC,CAAC;IAClC,SAAS;SACN,IAAI,CAAkB,aAAa,CAAC,SAAS,CAAC;SAC9C,eAAe,CAAC,SAAS,CAAC,CAAC;IAE9B,SAAS,CAAC,IAAI,CACZ,oBAAoB,EAAE,EACtB,uBAAuB,EAAE,EACzB,oBAAoB,EAAE,EACtB,wBAAwB,EAAE,EAC1B,sBAAsB,EAAE,CACzB,CAAC;IAEF,OAAO,SAAS,CAAC;AACnB,CAAC,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../src/internal/di.ts"],
+  "sourcesContent": ["import { type ContextModule } from \"@ledgerhq/context-module\";\nimport {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { Container } from \"inversify\";\n\n// import { makeLoggerMiddleware } from \"inversify-logger-middleware\";\nimport { addressModuleFactory } from \"@internal/address/di/addressModule\";\nimport { appBindingModuleFactory } from \"@internal/app-binder/di/appBinderModule\";\nimport { externalTypes } from \"@internal/externalTypes\";\nimport { messageModuleFactory } from \"@internal/message/di/messageModule\";\nimport { transactionModuleFactory } from \"@internal/transaction/di/transactionModule\";\nimport { typedDataModuleFactory } from \"@internal/typed-data/di/typedDataModule\";\n\n// Uncomment this line to enable the logger middleware\n// const logger = makeLoggerMiddleware();\n\nexport type MakeContainerProps = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  contextModule: ContextModule;\n};\n\nexport const makeContainer = ({\n  dmk,\n  sessionId,\n  contextModule,\n}: MakeContainerProps) => {\n  const container = new Container();\n\n  // Uncomment this line to enable the logger middleware\n  // container.applyMiddleware(logger);\n\n  container.bind<DeviceManagementKit>(externalTypes.Dmk).toConstantValue(dmk);\n  container\n    .bind<ContextModule>(externalTypes.ContextModule)\n    .toConstantValue(contextModule);\n  container\n    .bind<DeviceSessionId>(externalTypes.SessionId)\n    .toConstantValue(sessionId);\n\n  container.load(\n    addressModuleFactory(),\n    appBindingModuleFactory(),\n    messageModuleFactory(),\n    transactionModuleFactory(),\n    typedDataModuleFactory(),\n  );\n\n  return container;\n};\n"],
+  "mappings": "AAKA,OAAS,aAAAA,MAAiB,YAG1B,OAAS,wBAAAC,MAA4B,qCACrC,OAAS,2BAAAC,MAA+B,0CACxC,OAAS,iBAAAC,MAAqB,0BAC9B,OAAS,wBAAAC,MAA4B,qCACrC,OAAS,4BAAAC,MAAgC,6CACzC,OAAS,0BAAAC,MAA8B,0CAWhC,MAAMC,EAAgB,CAAC,CAC5B,IAAAC,EACA,UAAAC,EACA,cAAAC,CACF,IAA0B,CACxB,MAAMC,EAAY,IAAIX,EAKtB,OAAAW,EAAU,KAA0BR,EAAc,GAAG,EAAE,gBAAgBK,CAAG,EAC1EG,EACG,KAAoBR,EAAc,aAAa,EAC/C,gBAAgBO,CAAa,EAChCC,EACG,KAAsBR,EAAc,SAAS,EAC7C,gBAAgBM,CAAS,EAE5BE,EAAU,KACRV,EAAqB,EACrBC,EAAwB,EACxBE,EAAqB,EACrBC,EAAyB,EACzBC,EAAuB,CACzB,EAEOK,CACT",
+  "names": ["Container", "addressModuleFactory", "appBindingModuleFactory", "externalTypes", "messageModuleFactory", "transactionModuleFactory", "typedDataModuleFactory", "makeContainer", "dmk", "sessionId", "contextModule", "container"]
+}

package/lib/esm/internal/externalTypes.js

@@ -1,6 +1,2 @@
-export const externalTypes = {
-    Sdk: Symbol.for("Sdk"),
-    SessionId: Symbol.for("SessionId"),
-    ContextModule: Symbol.for("ContextModule"),
-};
-//# sourceMappingURL=externalTypes.js.map
+const o={Dmk:Symbol.for("Dmk"),SessionId:Symbol.for("SessionId"),ContextModule:Symbol.for("ContextModule")};export{o as externalTypes};
+//# sourceMappingURL=externalTypes.js.map

package/lib/esm/internal/externalTypes.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"externalTypes.js","sourceRoot":"","sources":["../../../src/internal/externalTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC;IAClC,aAAa,EAAE,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC;CAC3C,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../src/internal/externalTypes.ts"],
+  "sourcesContent": ["export const externalTypes = {\n  Dmk: Symbol.for(\"Dmk\"),\n  SessionId: Symbol.for(\"SessionId\"),\n  ContextModule: Symbol.for(\"ContextModule\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAgB,CAC3B,IAAK,OAAO,IAAI,KAAK,EACrB,UAAW,OAAO,IAAI,WAAW,EACjC,cAAe,OAAO,IAAI,eAAe,CAC3C",
+  "names": ["externalTypes"]
+}

package/lib/esm/internal/message/di/messageModule.js

@@ -1,7 +1,2 @@
-import { ContainerModule } from "inversify";
-import { messageTypes } from "../../message/di/messageTypes";
-import { SignMessageUseCase } from "../../message/use-case/SignMessageUseCase";
-export const messageModuleFactory = () => new ContainerModule((bind, _unbind, _isBound, _rebind, _unbindAsync, _onActivation, _onDeactivation) => {
-    bind(messageTypes.SignMessageUseCase).to(SignMessageUseCase);
-});
-//# sourceMappingURL=messageModule.js.map
+import{ContainerModule as o}from"inversify";import{messageTypes as n}from"../../message/di/messageTypes";import{SignMessageUseCase as s}from"../../message/use-case/SignMessageUseCase";const p=()=>new o((e,i,t,a,r,m,d)=>{e(n.SignMessageUseCase).to(s)});export{p as messageModuleFactory};
+//# sourceMappingURL=messageModule.js.map

package/lib/esm/internal/message/di/messageModule.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"messageModule.js","sourceRoot":"","sources":["../../../../../src/internal/message/di/messageModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC;AAEnF,MAAM,CAAC,MAAM,oBAAoB,GAAG,GAAG,EAAE,CACvC,IAAI,eAAe,CACjB,CACE,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,aAAa,EACb,eAAe,EACf,EAAE;IACF,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,kBAAkB,CAAC,CAAC;AAC/D,CAAC,CACF,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/message/di/messageModule.ts"],
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { messageTypes } from \"@internal/message/di/messageTypes\";\nimport { SignMessageUseCase } from \"@internal/message/use-case/SignMessageUseCase\";\n\nexport const messageModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(messageTypes.SignMessageUseCase).to(SignMessageUseCase);\n    },\n  );\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,gBAAAC,MAAoB,oCAC7B,OAAS,sBAAAC,MAA0B,gDAE5B,MAAMC,EAAuB,IAClC,IAAIH,EACF,CACEI,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAKH,EAAa,kBAAkB,EAAE,GAAGC,CAAkB,CAC7D,CACF",
+  "names": ["ContainerModule", "messageTypes", "SignMessageUseCase", "messageModuleFactory", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+}

package/lib/esm/internal/message/di/messageModule.test.js

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

package/lib/esm/internal/message/di/messageModule.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/message/di/messageModule.test.ts"],
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { messageModuleFactory } from \"./messageModule\";\n\ndescribe(\"messageModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof messageModuleFactory>;\n    beforeEach(() => {\n      mod = messageModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the message module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,wBAAAC,MAA4B,kBAErC,SAAS,uBAAwB,IAAM,CACrC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMF,EAAqB,EAC3BC,EAAY,IAAIF,EAChBE,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,mCAAoC,IAAM,CAC3C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["Container", "messageModuleFactory", "container", "mod"]
+}

package/lib/esm/internal/message/di/messageTypes.js

@@ -1,4 +1,2 @@
-export const messageTypes = {
-    SignMessageUseCase: Symbol.for("SignMessageUseCase"),
-};
-//# sourceMappingURL=messageTypes.js.map
+const e={SignMessageUseCase:Symbol.for("SignMessageUseCase")};export{e as messageTypes};
+//# sourceMappingURL=messageTypes.js.map

package/lib/esm/internal/message/di/messageTypes.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"messageTypes.js","sourceRoot":"","sources":["../../../../../src/internal/message/di/messageTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,kBAAkB,EAAE,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC;CACrD,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/message/di/messageTypes.ts"],
+  "sourcesContent": ["export const messageTypes = {\n  SignMessageUseCase: Symbol.for(\"SignMessageUseCase\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAe,CAC1B,mBAAoB,OAAO,IAAI,oBAAoB,CACrD",
+  "names": ["messageTypes"]
+}

package/lib/esm/internal/message/use-case/SignMessageUseCase.js

@@ -1,35 +1,2 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { inject, injectable } from "inversify";
-import { appBinderTypes } from "../../app-binder/di/appBinderTypes";
-import { EthAppBinder } from "../../app-binder/EthAppBinder";
-let SignMessageUseCase = class SignMessageUseCase {
-    _appBinding;
-    constructor(appBinding) {
-        this._appBinding = appBinding;
-    }
-    execute(derivationPath, message) {
-        // 1- Sign the transaction using the app binding
-        return this._appBinding.signPersonalMessage({
-            derivationPath,
-            message,
-        });
-    }
-};
-SignMessageUseCase = __decorate([
-    injectable(),
-    __param(0, inject(appBinderTypes.AppBinding)),
-    __metadata("design:paramtypes", [EthAppBinder])
-], SignMessageUseCase);
-export { SignMessageUseCase };
-//# sourceMappingURL=SignMessageUseCase.js.map
+var B=Object.defineProperty;var A=Object.getOwnPropertyDescriptor;var d=(n,r,p,i)=>{for(var t=i>1?void 0:i?A(r,p):r,o=n.length-1,a;o>=0;o--)(a=n[o])&&(t=(i?a(r,p,t):a(t))||t);return i&&t&&B(r,p,t),t},m=(n,r)=>(p,i)=>r(p,i,n);import{inject as c,injectable as s}from"inversify";import{appBinderTypes as h}from"../../app-binder/di/appBinderTypes";let e=class{_appBinder;constructor(r){this._appBinder=r}execute(r,p){return this._appBinder.signPersonalMessage({derivationPath:r,message:p})}};e=d([s(),m(0,c(h.AppBinding))],e);export{e as SignMessageUseCase};
+//# sourceMappingURL=SignMessageUseCase.js.map

package/lib/esm/internal/message/use-case/SignMessageUseCase.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"SignMessageUseCase.js","sourceRoot":"","sources":["../../../../../src/internal/message/use-case/SignMessageUseCase.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAG/C,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAG1D,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IACrB,WAAW,CAAe;IAElC,YAEE,UAAwB;QAExB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAED,OAAO,CACL,cAAsB,EACtB,OAAe;QAEf,gDAAgD;QAChD,OAAO,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC;YAC1C,cAAc;YACd,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AApBY,kBAAkB;IAD9B,UAAU,EAAE;IAKR,WAAA,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAA;qCACtB,YAAY;GALf,kBAAkB,CAoB9B"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/message/use-case/SignMessageUseCase.ts"],
+  "sourcesContent": ["import { inject, injectable } from \"inversify\";\n\nimport { SignPersonalMessageDAReturnType } from \"@api/app-binder/SignPersonalMessageDeviceActionTypes\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\n@injectable()\nexport class SignMessageUseCase {\n  private _appBinder: EthAppBinder;\n\n  constructor(\n    @inject(appBinderTypes.AppBinding)\n    appBinding: EthAppBinder,\n  ) {\n    this._appBinder = appBinding;\n  }\n\n  execute(\n    derivationPath: string,\n    message: string | Uint8Array,\n  ): SignPersonalMessageDAReturnType {\n    // 1- Sign the transaction using the app binding\n    return this._appBinder.signPersonalMessage({\n      derivationPath,\n      message,\n    });\n  }\n}\n"],
+  "mappings": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAGnC,OAAS,kBAAAC,MAAsB,yCAIxB,IAAMC,EAAN,KAAyB,CACtB,WAER,YAEEC,EACA,CACA,KAAK,WAAaA,CACpB,CAEA,QACEC,EACAC,EACiC,CAEjC,OAAO,KAAK,WAAW,oBAAoB,CACzC,eAAAD,EACA,QAAAC,CACF,CAAC,CACH,CACF,EApBaH,EAANI,EAAA,CADNC,EAAW,EAKPC,EAAA,EAAAC,EAAOC,EAAe,UAAU,IAJxBR",
+  "names": ["inject", "injectable", "appBinderTypes", "SignMessageUseCase", "appBinding", "derivationPath", "message", "__decorateClass", "injectable", "__decorateParam", "inject", "appBinderTypes"]
+}

package/lib/esm/internal/message/use-case/SignMessageUseCase.test.js

@@ -0,0 +1,2 @@
+import{SignMessageUseCase as a}from"./SignMessageUseCase";describe("SignMessageUseCase",()=>{it("should call signPersonalMessage on appBinder with the correct arguments",()=>{const e="44'/501'/0'/0'",s="Hello world",n={signPersonalMessage:jest.fn()};new a(n).execute(e,s),expect(n.signPersonalMessage).toHaveBeenCalledWith({derivationPath:e,message:s})})});
+//# sourceMappingURL=SignMessageUseCase.test.js.map

package/lib/esm/internal/message/use-case/SignMessageUseCase.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/message/use-case/SignMessageUseCase.test.ts"],
+  "sourcesContent": ["import { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\nimport { SignMessageUseCase } from \"./SignMessageUseCase\";\n\ndescribe(\"SignMessageUseCase\", () => {\n  it(\"should call signPersonalMessage on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"44'/501'/0'/0'\";\n    const message = \"Hello world\";\n    const appBinder = {\n      signPersonalMessage: jest.fn(),\n    };\n    const signMessageUseCase = new SignMessageUseCase(\n      appBinder as unknown as EthAppBinder,\n    );\n\n    // When\n    signMessageUseCase.execute(derivationPath, message);\n\n    // Then\n    expect(appBinder.signPersonalMessage).toHaveBeenCalledWith({\n      derivationPath,\n      message,\n    });\n  });\n});\n"],
+  "mappings": "AAEA,OAAS,sBAAAA,MAA0B,uBAEnC,SAAS,qBAAsB,IAAM,CACnC,GAAG,0EAA2E,IAAM,CAElF,MAAMC,EAAiB,iBACjBC,EAAU,cACVC,EAAY,CAChB,oBAAqB,KAAK,GAAG,CAC/B,EAC2B,IAAIH,EAC7BG,CACF,EAGmB,QAAQF,EAAgBC,CAAO,EAGlD,OAAOC,EAAU,mBAAmB,EAAE,qBAAqB,CACzD,eAAAF,EACA,QAAAC,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["SignMessageUseCase", "derivationPath", "message", "appBinder"]
+}

package/lib/esm/internal/shared/utils/PayloadUtils.js

@@ -0,0 +1,2 @@
+import{ByteArrayBuilder as a,hexaStringToBuffer as e}from"@ledgerhq/device-management-kit";class i{static PAYLOAD_LENGTH_BYTES=2;static getBufferFromPayload(r){const t=e(r);return t===null||t.length===0?null:new a(t.length+this.PAYLOAD_LENGTH_BYTES).add16BitUIntToData(t.length).addBufferToData(t).build()}}export{i as PayloadUtils};
+//# sourceMappingURL=PayloadUtils.js.map

package/lib/esm/internal/shared/utils/PayloadUtils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/shared/utils/PayloadUtils.ts"],
+  "sourcesContent": ["import {\n  ByteArrayBuilder,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\n\nexport class PayloadUtils {\n  private static PAYLOAD_LENGTH_BYTES = 2;\n\n  static getBufferFromPayload(payload: string): Uint8Array | null {\n    const buffer = hexaStringToBuffer(payload);\n\n    if (buffer === null || buffer.length === 0) {\n      return null;\n    }\n\n    return new ByteArrayBuilder(buffer.length + this.PAYLOAD_LENGTH_BYTES)\n      .add16BitUIntToData(buffer.length)\n      .addBufferToData(buffer)\n      .build();\n  }\n}\n"],
+  "mappings": "AAAA,OACE,oBAAAA,EACA,sBAAAC,MACK,kCAEA,MAAMC,CAAa,CACxB,OAAe,qBAAuB,EAEtC,OAAO,qBAAqBC,EAAoC,CAC9D,MAAMC,EAASH,EAAmBE,CAAO,EAEzC,OAAIC,IAAW,MAAQA,EAAO,SAAW,EAChC,KAGF,IAAIJ,EAAiBI,EAAO,OAAS,KAAK,oBAAoB,EAClE,mBAAmBA,EAAO,MAAM,EAChC,gBAAgBA,CAAM,EACtB,MAAM,CACX,CACF",
+  "names": ["ByteArrayBuilder", "hexaStringToBuffer", "PayloadUtils", "payload", "buffer"]
+}

package/lib/esm/internal/shared/utils/PayloadUtils.test.js

@@ -0,0 +1,2 @@
+import{PayloadUtils as a}from"./PayloadUtils";describe("PayloadUtils",()=>{describe("getBufferFromPayload",()=>{it("should return null if the payload is empty",()=>{const o=a.getBufferFromPayload("");expect(o).toBeNull()}),it("should return null if the payload is invalid",()=>{const o=a.getBufferFromPayload("invalid");expect(o).toBeNull()}),it("should return the buffer from the payload",()=>{const o=a.getBufferFromPayload("010203");expect(o).toStrictEqual(Uint8Array.from([0,3,1,2,3]))})})});
+//# sourceMappingURL=PayloadUtils.test.js.map

package/lib/esm/internal/shared/utils/PayloadUtils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/shared/utils/PayloadUtils.test.ts"],
+  "sourcesContent": ["import { PayloadUtils } from \"./PayloadUtils\";\n\ndescribe(\"PayloadUtils\", () => {\n  describe(\"getBufferFromPayload\", () => {\n    it(\"should return null if the payload is empty\", () => {\n      // GIVEN\n      const payload = \"\";\n      // WHEN\n      const buffer = PayloadUtils.getBufferFromPayload(payload);\n      // THEN\n      expect(buffer).toBeNull();\n    });\n\n    it(\"should return null if the payload is invalid\", () => {\n      // GIVEN\n      const payload = \"invalid\";\n      // WHEN\n      const buffer = PayloadUtils.getBufferFromPayload(payload);\n      // THEN\n      expect(buffer).toBeNull();\n    });\n\n    it(\"should return the buffer from the payload\", () => {\n      // GIVEN\n      const payload = \"010203\";\n      // WHEN\n      const buffer = PayloadUtils.getBufferFromPayload(payload);\n      // THEN\n      expect(buffer).toStrictEqual(\n        Uint8Array.from([0x00, 0x03, 0x01, 0x02, 0x03]),\n      );\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,gBAAAA,MAAoB,iBAE7B,SAAS,eAAgB,IAAM,CAC7B,SAAS,uBAAwB,IAAM,CACrC,GAAG,6CAA8C,IAAM,CAIrD,MAAMC,EAASD,EAAa,qBAFZ,EAEwC,EAExD,OAAOC,CAAM,EAAE,SAAS,CAC1B,CAAC,EAED,GAAG,+CAAgD,IAAM,CAIvD,MAAMA,EAASD,EAAa,qBAFZ,SAEwC,EAExD,OAAOC,CAAM,EAAE,SAAS,CAC1B,CAAC,EAED,GAAG,4CAA6C,IAAM,CAIpD,MAAMA,EAASD,EAAa,qBAFZ,QAEwC,EAExD,OAAOC,CAAM,EAAE,cACb,WAAW,KAAK,CAAC,EAAM,EAAM,EAAM,EAAM,CAAI,CAAC,CAChD,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["PayloadUtils", "buffer"]
+}

package/lib/esm/internal/transaction/di/transactionModule.js

@@ -1,13 +1,2 @@
-import { ContainerModule } from "inversify";
-import { transactionTypes } from "../../transaction/di/transactionTypes";
-import { EthersV5TransactionMapper } from "../../transaction/service/mapper/EthersV5TransactionMapper";
-import { EthersV6TransactionMapper } from "../../transaction/service/mapper/EthersV6TransactionMapper";
-import { TransactionMapperService } from "../../transaction/service/mapper/TransactionMapperService";
-import { SignTransactionUseCase } from "../../transaction/use-case/SignTransactionUseCase";
-export const transactionModuleFactory = () => new ContainerModule((bind, _unbind, _isBound, _rebind, _unbindAsync, _onActivation, _onDeactivation) => {
-    bind(transactionTypes.SignTransactionUseCase).to(SignTransactionUseCase);
-    bind(transactionTypes.TransactionMapperService).to(TransactionMapperService);
-    bind(transactionTypes.TransactionMappers).to(EthersV5TransactionMapper);
-    bind(transactionTypes.TransactionMappers).to(EthersV6TransactionMapper);
-});
-//# sourceMappingURL=transactionModule.js.map
+import{ContainerModule as a}from"inversify";import{transactionTypes as o}from"../../transaction/di/transactionTypes";import{EthersV5TransactionMapper as n}from"../../transaction/service/mapper/EthersV5TransactionMapper";import{EthersV6TransactionMapper as t}from"../../transaction/service/mapper/EthersV6TransactionMapper";import{TransactionMapperService as e}from"../../transaction/service/mapper/TransactionMapperService";import{TransactionParserService as i}from"../../transaction/service/parser/TransactionParserService";import{SignTransactionUseCase as s}from"../../transaction/use-case/SignTransactionUseCase";const g=()=>new a((r,c,p,m,T,M,f)=>{r(o.SignTransactionUseCase).to(s),r(o.TransactionMapperService).to(e),r(o.TransactionParserService).to(i),r(o.TransactionMappers).to(n),r(o.TransactionMappers).to(t)});export{g as transactionModuleFactory};
+//# sourceMappingURL=transactionModule.js.map

package/lib/esm/internal/transaction/di/transactionModule.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"transactionModule.js","sourceRoot":"","sources":["../../../../../src/internal/transaction/di/transactionModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,gEAAgE,CAAC;AAC3G,OAAO,EAAE,yBAAyB,EAAE,MAAM,gEAAgE,CAAC;AAC3G,OAAO,EAAE,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AACzG,OAAO,EAAE,sBAAsB,EAAE,MAAM,uDAAuD,CAAC;AAE/F,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,EAAE,CAC3C,IAAI,eAAe,CACjB,CACE,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,aAAa,EACb,eAAe,EACf,EAAE;IACF,IAAI,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAAC,sBAAsB,CAAC,CAAC;IACzE,IAAI,CAAC,gBAAgB,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAChD,wBAAwB,CACzB,CAAC;IACF,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,yBAAyB,CAAC,CAAC;IACxE,IAAI,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,yBAAyB,CAAC,CAAC;AAC1E,CAAC,CACF,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/transaction/di/transactionModule.ts"],
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { transactionTypes } from \"@internal/transaction/di/transactionTypes\";\nimport { EthersV5TransactionMapper } from \"@internal/transaction/service/mapper/EthersV5TransactionMapper\";\nimport { EthersV6TransactionMapper } from \"@internal/transaction/service/mapper/EthersV6TransactionMapper\";\nimport { TransactionMapperService } from \"@internal/transaction/service/mapper/TransactionMapperService\";\nimport { TransactionParserService } from \"@internal/transaction/service/parser/TransactionParserService\";\nimport { SignTransactionUseCase } from \"@internal/transaction/use-case/SignTransactionUseCase\";\n\nexport const transactionModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(transactionTypes.SignTransactionUseCase).to(SignTransactionUseCase);\n      bind(transactionTypes.TransactionMapperService).to(\n        TransactionMapperService,\n      );\n      bind(transactionTypes.TransactionParserService).to(\n        TransactionParserService,\n      );\n      bind(transactionTypes.TransactionMappers).to(EthersV5TransactionMapper);\n      bind(transactionTypes.TransactionMappers).to(EthersV6TransactionMapper);\n    },\n  );\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,oBAAAC,MAAwB,4CACjC,OAAS,6BAAAC,MAAiC,iEAC1C,OAAS,6BAAAC,MAAiC,iEAC1C,OAAS,4BAAAC,MAAgC,gEACzC,OAAS,4BAAAC,MAAgC,gEACzC,OAAS,0BAAAC,MAA8B,wDAEhC,MAAMC,EAA2B,IACtC,IAAIP,EACF,CACEQ,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAKP,EAAiB,sBAAsB,EAAE,GAAGK,CAAsB,EACvEE,EAAKP,EAAiB,wBAAwB,EAAE,GAC9CG,CACF,EACAI,EAAKP,EAAiB,wBAAwB,EAAE,GAC9CI,CACF,EACAG,EAAKP,EAAiB,kBAAkB,EAAE,GAAGC,CAAyB,EACtEM,EAAKP,EAAiB,kBAAkB,EAAE,GAAGE,CAAyB,CACxE,CACF",
+  "names": ["ContainerModule", "transactionTypes", "EthersV5TransactionMapper", "EthersV6TransactionMapper", "TransactionMapperService", "TransactionParserService", "SignTransactionUseCase", "transactionModuleFactory", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+}

package/lib/esm/internal/transaction/di/transactionModule.test.js

@@ -0,0 +1,2 @@
+import{Container as o}from"inversify";import{transactionModuleFactory as a}from"./transactionModule";import{transactionTypes as r}from"./transactionTypes";describe("transactionModuleFactory",()=>{describe("Default",()=>{let t,e;beforeEach(()=>{e=a(),t=new o,t.load(e)}),it("should return the transaction module",()=>{expect(e).toBeDefined()}),it("should bind a list of transaction mappers",()=>{expect(t.getAll(r.TransactionMappers)).toHaveLength(2)})})});
+//# sourceMappingURL=transactionModule.test.js.map

package/lib/esm/internal/transaction/di/transactionModule.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/transaction/di/transactionModule.test.ts"],
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { transactionModuleFactory } from \"./transactionModule\";\nimport { transactionTypes } from \"./transactionTypes\";\n\ndescribe(\"transactionModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof transactionModuleFactory>;\n    beforeEach(() => {\n      mod = transactionModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the transaction module\", () => {\n      expect(mod).toBeDefined();\n    });\n\n    it(\"should bind a list of transaction mappers\", () => {\n      expect(\n        container.getAll(transactionTypes.TransactionMappers),\n      ).toHaveLength(2);\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,4BAAAC,MAAgC,sBACzC,OAAS,oBAAAC,MAAwB,qBAEjC,SAAS,2BAA4B,IAAM,CACzC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMH,EAAyB,EAC/BE,EAAY,IAAIH,EAChBG,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,uCAAwC,IAAM,CAC/C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,EAED,GAAG,4CAA6C,IAAM,CACpD,OACED,EAAU,OAAOD,EAAiB,kBAAkB,CACtD,EAAE,aAAa,CAAC,CAClB,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["Container", "transactionModuleFactory", "transactionTypes", "container", "mod"]
+}

package/lib/esm/internal/transaction/di/transactionTypes.js

@@ -1,6 +1,2 @@
-export const transactionTypes = {
-    SignTransactionUseCase: Symbol.for("SignTransactionUseCase"),
-    TransactionMapperService: Symbol.for("TransactionMapperService"),
-    TransactionMappers: Symbol.for("TransactionMappers"),
-};
-//# sourceMappingURL=transactionTypes.js.map
+const a={SignTransactionUseCase:Symbol.for("SignTransactionUseCase"),TransactionParserService:Symbol.for("TransactionParserService"),TransactionMapperService:Symbol.for("TransactionMapperService"),TransactionMappers:Symbol.for("TransactionMappers")};export{a as transactionTypes};
+//# sourceMappingURL=transactionTypes.js.map

package/lib/esm/internal/transaction/di/transactionTypes.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"transactionTypes.js","sourceRoot":"","sources":["../../../../../src/internal/transaction/di/transactionTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,sBAAsB,EAAE,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC;IAC5D,wBAAwB,EAAE,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC;IAChE,kBAAkB,EAAE,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC;CACrD,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/transaction/di/transactionTypes.ts"],
+  "sourcesContent": ["export const transactionTypes = {\n  SignTransactionUseCase: Symbol.for(\"SignTransactionUseCase\"),\n  TransactionParserService: Symbol.for(\"TransactionParserService\"),\n  TransactionMapperService: Symbol.for(\"TransactionMapperService\"),\n  TransactionMappers: Symbol.for(\"TransactionMappers\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAmB,CAC9B,uBAAwB,OAAO,IAAI,wBAAwB,EAC3D,yBAA0B,OAAO,IAAI,0BAA0B,EAC/D,yBAA0B,OAAO,IAAI,0BAA0B,EAC/D,mBAAoB,OAAO,IAAI,oBAAoB,CACrD",
+  "names": ["transactionTypes"]
+}

package/lib/esm/internal/transaction/service/mapper/EthersV5TransactionMapper.js

@@ -1,57 +1,2 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { BigNumber, ethers, } from "ethers-v5";
-import { injectable } from "inversify";
-import { Just, Nothing } from "purify-ts";
-let EthersV5TransactionMapper = class EthersV5TransactionMapper {
-    constructor() { }
-    map(transaction) {
-        if (this.isEthersV5Transaction(transaction)) {
-            // ensure that we have a valid non signed transaction
-            const txUnsigned = {
-                to: transaction.to,
-                nonce: transaction.nonce,
-                gasLimit: transaction.gasLimit,
-                gasPrice: transaction.gasPrice,
-                data: transaction.data,
-                value: transaction.value,
-                chainId: transaction.chainId,
-            };
-            const serializedTransaction = ethers.utils.arrayify(ethers.utils.serializeTransaction(txUnsigned));
-            return Just({
-                subset: {
-                    chainId: transaction.chainId,
-                    to: transaction.to,
-                    data: transaction.data,
-                },
-                serializedTransaction,
-            });
-        }
-        return Nothing;
-    }
-    isEthersV5Transaction(transaction) {
-        const tx = transaction;
-        return (typeof tx === "object" &&
-            tx !== null &&
-            (tx.to === undefined || typeof tx.to === "string") &&
-            typeof tx.nonce === "number" &&
-            tx.gasLimit instanceof BigNumber &&
-            (tx.gasPrice === undefined || tx.gasPrice instanceof BigNumber) &&
-            typeof tx.data === "string" &&
-            tx.value instanceof BigNumber &&
-            typeof tx.chainId === "number");
-    }
-};
-EthersV5TransactionMapper = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [])
-], EthersV5TransactionMapper);
-export { EthersV5TransactionMapper };
-//# sourceMappingURL=EthersV5TransactionMapper.js.map
+var u=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var m=(r,e,t,a)=>{for(var i=a>1?void 0:a?f(e,t):e,o=r.length-1,s;o>=0;o--)(s=r[o])&&(i=(a?s(e,t,i):s(i))||i);return a&&i&&u(e,t,i),i};import{BigNumber as c,ethers as p}from"ethers-v5";import{injectable as d}from"inversify";import{Just as l,Nothing as y}from"purify-ts";let n=class{constructor(){}map(e){if(this.isEthersV5Transaction(e)){const t={to:e.to,nonce:e.nonce,gasLimit:e.gasLimit,gasPrice:e.gasPrice,data:e.data,value:e.value,chainId:e.chainId},a=p.utils.arrayify(p.utils.serializeTransaction(t));return l({subset:{chainId:e.chainId,to:e.to,data:e.data},serializedTransaction:a,type:e.type||0})}return y}isEthersV5Transaction(e){const t=e;return typeof t=="object"&&t!==null&&(t.to===void 0||typeof t.to=="string")&&typeof t.nonce=="number"&&t.gasLimit instanceof c&&(t.gasPrice===void 0||t.gasPrice instanceof c)&&typeof t.data=="string"&&t.value instanceof c&&typeof t.chainId=="number"&&(t.type===void 0||typeof t.type=="number")}};n=m([d()],n);export{n as EthersV5TransactionMapper};
+//# sourceMappingURL=EthersV5TransactionMapper.js.map

package/lib/esm/internal/transaction/service/mapper/EthersV5TransactionMapper.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"EthersV5TransactionMapper.js","sourceRoot":"","sources":["../../../../../../src/internal/transaction/service/mapper/EthersV5TransactionMapper.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EACL,SAAS,EACT,MAAM,GAEP,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,IAAI,EAAS,OAAO,EAAE,MAAM,WAAW,CAAC;AAQ1C,IAAM,yBAAyB,GAA/B,MAAM,yBAAyB;IACpC,gBAAe,CAAC;IAEhB,GAAG,CAAC,WAAwB;QAC1B,IAAI,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC5C,qDAAqD;YACrD,MAAM,UAAU,GAAG;gBACjB,EAAE,EAAE,WAAW,CAAC,EAAE;gBAClB,KAAK,EAAE,WAAW,CAAC,KAAK;gBACxB,QAAQ,EAAE,WAAW,CAAC,QAAQ;gBAC9B,QAAQ,EAAE,WAAW,CAAC,QAAQ;gBAC9B,IAAI,EAAE,WAAW,CAAC,IAAI;gBACtB,KAAK,EAAE,WAAW,CAAC,KAAK;gBACxB,OAAO,EAAE,WAAW,CAAC,OAAO;aAC7B,CAAC;YACF,MAAM,qBAAqB,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CACjD,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAC9C,CAAC;YAEF,OAAO,IAAI,CAAC;gBACV,MAAM,EAAE;oBACN,OAAO,EAAE,WAAW,CAAC,OAAO;oBAC5B,EAAE,EAAE,WAAW,CAAC,EAAE;oBAClB,IAAI,EAAE,WAAW,CAAC,IAAI;iBACvB;gBACD,qBAAqB;aACtB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,qBAAqB,CAC3B,WAAwB;QAExB,MAAM,EAAE,GAAG,WAAkC,CAAC;QAC9C,OAAO,CACL,OAAO,EAAE,KAAK,QAAQ;YACtB,EAAE,KAAK,IAAI;YACX,CAAC,EAAE,CAAC,EAAE,KAAK,SAAS,IAAI,OAAO,EAAE,CAAC,EAAE,KAAK,QAAQ,CAAC;YAClD,OAAO,EAAE,CAAC,KAAK,KAAK,QAAQ;YAC5B,EAAE,CAAC,QAAQ,YAAY,SAAS;YAChC,CAAC,EAAE,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,CAAC,QAAQ,YAAY,SAAS,CAAC;YAC/D,OAAO,EAAE,CAAC,IAAI,KAAK,QAAQ;YAC3B,EAAE,CAAC,KAAK,YAAY,SAAS;YAC7B,OAAO,EAAE,CAAC,OAAO,KAAK,QAAQ,CAC/B,CAAC;IACJ,CAAC;CACF,CAAA;AAhDY,yBAAyB;IADrC,UAAU,EAAE;;GACA,yBAAyB,CAgDrC"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersV5TransactionMapper.ts"],
+  "sourcesContent": ["import {\n  BigNumber,\n  ethers,\n  Transaction as EthersV5Transaction,\n} from \"ethers-v5\";\nimport { injectable } from \"inversify\";\nimport { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport { Transaction } from \"@api/index\";\n\nimport { TransactionMapperResult } from \"./model/TransactionMapperResult\";\nimport { TransactionMapper } from \"./TransactionMapper\";\n\n@injectable()\nexport class EthersV5TransactionMapper implements TransactionMapper {\n  constructor() {}\n\n  map(transaction: Transaction): Maybe<TransactionMapperResult> {\n    if (this.isEthersV5Transaction(transaction)) {\n      // ensure that we have a valid non signed transaction\n      const txUnsigned = {\n        to: transaction.to,\n        nonce: transaction.nonce,\n        gasLimit: transaction.gasLimit,\n        gasPrice: transaction.gasPrice,\n        data: transaction.data,\n        value: transaction.value,\n        chainId: transaction.chainId,\n      };\n      const serializedTransaction = ethers.utils.arrayify(\n        ethers.utils.serializeTransaction(txUnsigned),\n      );\n\n      return Just({\n        subset: {\n          chainId: transaction.chainId,\n          to: transaction.to,\n          data: transaction.data,\n        },\n        serializedTransaction,\n        type: transaction.type || 0,\n      });\n    }\n\n    return Nothing;\n  }\n\n  private isEthersV5Transaction(\n    transaction: Transaction,\n  ): transaction is EthersV5Transaction {\n    const tx = transaction as EthersV5Transaction;\n    return (\n      typeof tx === \"object\" &&\n      tx !== null &&\n      (tx.to === undefined || typeof tx.to === \"string\") &&\n      typeof tx.nonce === \"number\" &&\n      tx.gasLimit instanceof BigNumber &&\n      (tx.gasPrice === undefined || tx.gasPrice instanceof BigNumber) &&\n      typeof tx.data === \"string\" &&\n      tx.value instanceof BigNumber &&\n      typeof tx.chainId === \"number\" &&\n      (tx.type === undefined || typeof tx.type === \"number\")\n    );\n  }\n}\n"],
+  "mappings": "wMAAA,OACE,aAAAA,EACA,UAAAC,MAEK,YACP,OAAS,cAAAC,MAAkB,YAC3B,OAAS,QAAAC,EAAa,WAAAC,MAAe,YAQ9B,IAAMC,EAAN,KAA6D,CAClE,aAAc,CAAC,CAEf,IAAIC,EAA0D,CAC5D,GAAI,KAAK,sBAAsBA,CAAW,EAAG,CAE3C,MAAMC,EAAa,CACjB,GAAID,EAAY,GAChB,MAAOA,EAAY,MACnB,SAAUA,EAAY,SACtB,SAAUA,EAAY,SACtB,KAAMA,EAAY,KAClB,MAAOA,EAAY,MACnB,QAASA,EAAY,OACvB,EACME,EAAwBC,EAAO,MAAM,SACzCA,EAAO,MAAM,qBAAqBF,CAAU,CAC9C,EAEA,OAAOG,EAAK,CACV,OAAQ,CACN,QAASJ,EAAY,QACrB,GAAIA,EAAY,GAChB,KAAMA,EAAY,IACpB,EACA,sBAAAE,EACA,KAAMF,EAAY,MAAQ,CAC5B,CAAC,CACH,CAEA,OAAOK,CACT,CAEQ,sBACNL,EACoC,CACpC,MAAMM,EAAKN,EACX,OACE,OAAOM,GAAO,UACdA,IAAO,OACNA,EAAG,KAAO,QAAa,OAAOA,EAAG,IAAO,WACzC,OAAOA,EAAG,OAAU,UACpBA,EAAG,oBAAoBC,IACtBD,EAAG,WAAa,QAAaA,EAAG,oBAAoBC,IACrD,OAAOD,EAAG,MAAS,UACnBA,EAAG,iBAAiBC,GACpB,OAAOD,EAAG,SAAY,WACrBA,EAAG,OAAS,QAAa,OAAOA,EAAG,MAAS,SAEjD,CACF,EAlDaP,EAANS,EAAA,CADNC,EAAW,GACCV",
+  "names": ["BigNumber", "ethers", "injectable", "Just", "Nothing", "EthersV5TransactionMapper", "transaction", "txUnsigned", "serializedTransaction", "ethers", "Just", "Nothing", "tx", "BigNumber", "__decorateClass", "injectable"]
+}

package/lib/esm/internal/transaction/service/mapper/EthersV5TransactionMapper.test.js

@@ -0,0 +1,2 @@
+import{BigNumber as n}from"ethers-v5";import{Transaction as s}from"ethers-v6";import{Just as o}from"purify-ts";import{EthersV5TransactionMapper as i}from"./EthersV5TransactionMapper";describe("EthersV5TransactionMapper",()=>{let r;beforeEach(()=>{r=new i}),describe("map",()=>{it("should return the correct TransactionSubset",()=>{const t={chainId:1,nonce:0,gasLimit:n.from(0),value:n.from(0),data:"0x"},a=new Uint8Array([201,128,128,128,128,128,128,1,128,128]),e=r.map(t);expect(e).toEqual(o({subset:{chainId:1,to:void 0,data:"0x"},serializedTransaction:a,type:0}))}),it("should return the correct TransactionSubset with to attribute",()=>{const t={chainId:1,nonce:0,gasLimit:n.from(0),value:n.from(0),data:"0x",to:"0x"},a=new Uint8Array([201,128,128,128,128,128,128,1,128,128]),e=r.map(t);expect(e).toEqual(o({subset:{chainId:1,to:"0x",data:"0x"},serializedTransaction:a,type:0}))}),it("should return the correct TransactionSubset with all attributes",()=>{const t={chainId:1,nonce:0,gasLimit:n.from(0),gasPrice:n.from(0),value:n.from(0),data:"0x",from:"0x",r:"0x",s:"0x",v:0,type:1,maxFeePerGas:n.from(0),maxPriorityFeePerGas:n.from(0)},a=new Uint8Array([201,128,128,128,128,128,128,1,128,128]),e=r.map(t);expect(e).toEqual(o({subset:{chainId:1,to:void 0,data:"0x"},serializedTransaction:a,type:1}))}),it("should return Nothing when the transaction is not an EthersV5Transaction",()=>{const t={},a=r.map(t);expect(a.isNothing()).toBeTruthy()}),it("should return Nothing when the transaction is an EthersV6Transaction",()=>{const t=new s;t.chainId=1n,t.nonce=0,t.data="0x",t.to="0x0123456789abcdef0123456789abcdef01234567";const a=r.map(t);expect(a.isNothing()).toBeTruthy()})})});
+//# sourceMappingURL=EthersV5TransactionMapper.test.js.map

package/lib/esm/internal/transaction/service/mapper/EthersV5TransactionMapper.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersV5TransactionMapper.test.ts"],
+  "sourcesContent": ["import {\n  BigNumber as EthersV5BigNumber,\n  type Transaction as EthersV5Transaction,\n} from \"ethers-v5\";\nimport { Transaction as EthersV6Transaction } from \"ethers-v6\";\nimport { Just } from \"purify-ts\";\n\nimport { type Transaction } from \"@api/index\";\n\nimport { EthersV5TransactionMapper } from \"./EthersV5TransactionMapper\";\nimport { type TransactionMapper } from \"./TransactionMapper\";\n\ndescribe(\"EthersV5TransactionMapper\", () => {\n  let mapper: TransactionMapper;\n\n  beforeEach(() => {\n    mapper = new EthersV5TransactionMapper();\n  });\n\n  describe(\"map\", () => {\n    it(\"should return the correct TransactionSubset\", () => {\n      // GIVEN\n      const transaction: EthersV5Transaction = {\n        chainId: 1,\n        nonce: 0,\n        gasLimit: EthersV5BigNumber.from(0),\n        value: EthersV5BigNumber.from(0),\n        data: \"0x\",\n      };\n      const serializedTransaction = new Uint8Array([\n        0xc9, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x80, 0x80,\n      ]);\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result).toEqual(\n        Just({\n          subset: {\n            chainId: 1,\n            to: undefined,\n            data: \"0x\",\n          },\n          serializedTransaction,\n          type: 0,\n        }),\n      );\n    });\n\n    it(\"should return the correct TransactionSubset with to attribute\", () => {\n      // GIVEN\n      const transaction: EthersV5Transaction = {\n        chainId: 1,\n        nonce: 0,\n        gasLimit: EthersV5BigNumber.from(0),\n        value: EthersV5BigNumber.from(0),\n        data: \"0x\",\n        to: \"0x\",\n      };\n      const serializedTransaction = new Uint8Array([\n        0xc9, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x80, 0x80,\n      ]);\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result).toEqual(\n        Just({\n          subset: {\n            chainId: 1,\n            to: \"0x\",\n            data: \"0x\",\n          },\n          serializedTransaction,\n          type: 0,\n        }),\n      );\n    });\n\n    it(\"should return the correct TransactionSubset with all attributes\", () => {\n      // GIVEN\n      const transaction: EthersV5Transaction = {\n        chainId: 1,\n        nonce: 0,\n        gasLimit: EthersV5BigNumber.from(0),\n        gasPrice: EthersV5BigNumber.from(0),\n        value: EthersV5BigNumber.from(0),\n        data: \"0x\",\n        from: \"0x\",\n        r: \"0x\",\n        s: \"0x\",\n        v: 0,\n        type: 1,\n        maxFeePerGas: EthersV5BigNumber.from(0),\n        maxPriorityFeePerGas: EthersV5BigNumber.from(0),\n      };\n      const serializedTransaction = new Uint8Array([\n        0xc9, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x80, 0x80,\n      ]);\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result).toEqual(\n        Just({\n          subset: {\n            chainId: 1,\n            to: undefined,\n            data: \"0x\",\n          },\n          serializedTransaction,\n          type: 1,\n        }),\n      );\n    });\n\n    it(\"should return Nothing when the transaction is not an EthersV5Transaction\", () => {\n      // GIVEN\n      const transaction = {} as Transaction;\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result.isNothing()).toBeTruthy();\n    });\n\n    it(\"should return Nothing when the transaction is an EthersV6Transaction\", () => {\n      // GIVEN\n      const transaction = new EthersV6Transaction();\n      transaction.chainId = 1n;\n      transaction.nonce = 0;\n      transaction.data = \"0x\";\n      transaction.to = \"0x0123456789abcdef0123456789abcdef01234567\";\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result.isNothing()).toBeTruthy();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OACE,aAAaA,MAER,YACP,OAAS,eAAeC,MAA2B,YACnD,OAAS,QAAAC,MAAY,YAIrB,OAAS,6BAAAC,MAAiC,8BAG1C,SAAS,4BAA6B,IAAM,CAC1C,IAAIC,EAEJ,WAAW,IAAM,CACfA,EAAS,IAAID,CACf,CAAC,EAED,SAAS,MAAO,IAAM,CACpB,GAAG,8CAA+C,IAAM,CAEtD,MAAME,EAAmC,CACvC,QAAS,EACT,MAAO,EACP,SAAUL,EAAkB,KAAK,CAAC,EAClC,MAAOA,EAAkB,KAAK,CAAC,EAC/B,KAAM,IACR,EACMM,EAAwB,IAAI,WAAW,CAC3C,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EAAM,IAAM,GACxD,CAAC,EAGKC,EAASH,EAAO,IAAIC,CAAW,EAGrC,OAAOE,CAAM,EAAE,QACbL,EAAK,CACH,OAAQ,CACN,QAAS,EACT,GAAI,OACJ,KAAM,IACR,EACA,sBAAAI,EACA,KAAM,CACR,CAAC,CACH,CACF,CAAC,EAED,GAAG,gEAAiE,IAAM,CAExE,MAAMD,EAAmC,CACvC,QAAS,EACT,MAAO,EACP,SAAUL,EAAkB,KAAK,CAAC,EAClC,MAAOA,EAAkB,KAAK,CAAC,EAC/B,KAAM,KACN,GAAI,IACN,EACMM,EAAwB,IAAI,WAAW,CAC3C,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EAAM,IAAM,GACxD,CAAC,EAGKC,EAASH,EAAO,IAAIC,CAAW,EAGrC,OAAOE,CAAM,EAAE,QACbL,EAAK,CACH,OAAQ,CACN,QAAS,EACT,GAAI,KACJ,KAAM,IACR,EACA,sBAAAI,EACA,KAAM,CACR,CAAC,CACH,CACF,CAAC,EAED,GAAG,kEAAmE,IAAM,CAE1E,MAAMD,EAAmC,CACvC,QAAS,EACT,MAAO,EACP,SAAUL,EAAkB,KAAK,CAAC,EAClC,SAAUA,EAAkB,KAAK,CAAC,EAClC,MAAOA,EAAkB,KAAK,CAAC,EAC/B,KAAM,KACN,KAAM,KACN,EAAG,KACH,EAAG,KACH,EAAG,EACH,KAAM,EACN,aAAcA,EAAkB,KAAK,CAAC,EACtC,qBAAsBA,EAAkB,KAAK,CAAC,CAChD,EACMM,EAAwB,IAAI,WAAW,CAC3C,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,IAAM,EAAM,IAAM,GACxD,CAAC,EAGKC,EAASH,EAAO,IAAIC,CAAW,EAGrC,OAAOE,CAAM,EAAE,QACbL,EAAK,CACH,OAAQ,CACN,QAAS,EACT,GAAI,OACJ,KAAM,IACR,EACA,sBAAAI,EACA,KAAM,CACR,CAAC,CACH,CACF,CAAC,EAED,GAAG,2EAA4E,IAAM,CAEnF,MAAMD,EAAc,CAAC,EAGfE,EAASH,EAAO,IAAIC,CAAW,EAGrC,OAAOE,EAAO,UAAU,CAAC,EAAE,WAAW,CACxC,CAAC,EAED,GAAG,uEAAwE,IAAM,CAE/E,MAAMF,EAAc,IAAIJ,EACxBI,EAAY,QAAU,GACtBA,EAAY,MAAQ,EACpBA,EAAY,KAAO,KACnBA,EAAY,GAAK,6CAGjB,MAAME,EAASH,EAAO,IAAIC,CAAW,EAGrC,OAAOE,EAAO,UAAU,CAAC,EAAE,WAAW,CACxC,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["EthersV5BigNumber", "EthersV6Transaction", "Just", "EthersV5TransactionMapper", "mapper", "transaction", "serializedTransaction", "result"]
+}

package/lib/esm/internal/transaction/service/mapper/EthersV6TransactionMapper.js

@@ -1,33 +1,2 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { getBytes, Transaction as EthersV6Transaction } from "ethers-v6";
-import { injectable } from "inversify";
-import { Just, Nothing } from "purify-ts";
-let EthersV6TransactionMapper = class EthersV6TransactionMapper {
-    map(transaction) {
-        if (this.isEthersV6Transaction(transaction)) {
-            const serializedTransaction = getBytes(transaction.unsignedSerialized);
-            return Just({
-                subset: {
-                    chainId: Number(transaction.chainId.toString()),
-                    to: transaction.to ?? undefined,
-                    data: transaction.data,
-                },
-                serializedTransaction,
-            });
-        }
-        return Nothing;
-    }
-    isEthersV6Transaction(transaction) {
-        return transaction instanceof EthersV6Transaction;
-    }
-};
-EthersV6TransactionMapper = __decorate([
-    injectable()
-], EthersV6TransactionMapper);
-export { EthersV6TransactionMapper };
-//# sourceMappingURL=EthersV6TransactionMapper.js.map
+var f=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var m=(i,e,s,t)=>{for(var r=t>1?void 0:t?n(e,s):e,l=i.length-1,o;l>=0;l--)(o=i[l])&&(r=(t?o(e,s,r):o(r))||r);return t&&r&&f(e,s,r),r};import{getBytes as g}from"ethers-v6";import{injectable as y}from"inversify";import{Just as h,Nothing as b}from"purify-ts";let p=class{map(e){if(this.isEthersV6Transaction(e)){const s=g(e.unsignedSerialized);return h({subset:{chainId:Number(e.chainId.toString()),to:e.to??void 0,data:e.data},serializedTransaction:s,type:e.type||0})}return b}isEthersV6Transaction(e){return typeof e=="object"&&(e.hash===null||typeof e.hash=="string")&&(e.to===null||typeof e.to=="string")&&(e.gasLimit==null||u(e.gasLimit))&&(e.gasPrice===null||u(e.gasPrice))&&(e.value===null||u(e.value))&&(e.chainId===null||u(typeof e.chainId))&&(e.type===null||typeof e.type=="number")}};p=m([y()],p);const u=i=>typeof i=="string"||typeof i=="number"||typeof i=="bigint";export{p as EthersV6TransactionMapper};
+//# sourceMappingURL=EthersV6TransactionMapper.js.map