@ledgerhq/device-signer-kit-ethereum 1.0.0 → 1.2.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\";\nimport { Nothing } from \"purify-ts\";\n\nimport { type Signature } from \"@api/index\";\nimport { TransactionType } from \"@api/model/TransactionType\";\nimport {\n  SignTransactionCommand,\n  type SignTransactionCommandResponse,\n} from \"@internal/app-binder/command/SignTransactionCommand\";\nimport { StartTransactionCommand } from \"@internal/app-binder/command/StartTransactionCommand\";\nimport { type EthErrorCodes } from \"@internal/app-binder/command/utils/ethAppErrors\";\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, EthErrorCodes>> {\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", "r", "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";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(()=>{vi.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\";\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    vi.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,SAC5B,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:vi.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: vi.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,GAAG,GAAG,CAC7B,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{EthersRawTransactionMapper as n}from"../../transaction/service/mapper/EthersRawTransactionMapper";import{TransactionMapperService as t}from"../../transaction/service/mapper/TransactionMapperService";import{TransactionParserService as i}from"../../transaction/service/parser/TransactionParserService";import{SignTransactionUseCase as e}from"../../transaction/use-case/SignTransactionUseCase";const y=()=>new a((r,s,c,p,m,T,f)=>{r(o.SignTransactionUseCase).to(e),r(o.TransactionMapperService).to(t),r(o.TransactionParserService).to(i),r(o.TransactionMappers).to(n)});export{y 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 { EthersRawTransactionMapper } from \"@internal/transaction/service/mapper/EthersRawTransactionMapper\";\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(EthersRawTransactionMapper);\n    },\n  );\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,oBAAAC,MAAwB,4CACjC,OAAS,8BAAAC,MAAkC,kEAC3C,OAAS,4BAAAC,MAAgC,gEACzC,OAAS,4BAAAC,MAAgC,gEACzC,OAAS,0BAAAC,MAA8B,wDAEhC,MAAMC,EAA2B,IACtC,IAAIN,EACF,CACEO,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAKN,EAAiB,sBAAsB,EAAE,GAAGI,CAAsB,EACvEE,EAAKN,EAAiB,wBAAwB,EAAE,GAC9CE,CACF,EACAI,EAAKN,EAAiB,wBAAwB,EAAE,GAC9CG,CACF,EACAG,EAAKN,EAAiB,kBAAkB,EAAE,GAAGC,CAA0B,CACzE,CACF",
+  "names": ["ContainerModule", "transactionTypes", "EthersRawTransactionMapper", "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 transaction mapper",()=>{expect(t.getAll(r.TransactionMappers)).toHaveLength(1)})})});
+//# 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 transaction mapper\", () => {\n      expect(\n        container.getAll(transactionTypes.TransactionMappers),\n      ).toHaveLength(1);\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,mCAAoC,IAAM,CAC3C,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/EthersRawTransactionMapper.js

@@ -0,0 +1,2 @@
+var s=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var p=(n,e,t,o)=>{for(var r=o>1?void 0:o?c(e,t):e,a=n.length-1,m;a>=0;a--)(m=n[a])&&(r=(o?m(e,t,r):m(r))||r);return o&&r&&s(e,t,r),r};import{bufferToHexaString as f}from"@ledgerhq/device-management-kit";import{ethers as u,getBytes as d}from"ethers";import{injectable as l}from"inversify";import{Just as y,Nothing as b}from"purify-ts";let i=class{map(e){try{const t=u.Transaction.from(f(e));return y({subset:{chainId:Number(t.chainId.toString()),to:t.to??void 0,data:t.data},serializedTransaction:d(t.unsignedSerialized),type:t.type||0})}catch{return b}}};i=p([l()],i);export{i as EthersRawTransactionMapper};
+//# sourceMappingURL=EthersRawTransactionMapper.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersRawTransactionMapper.ts"],
+  "sourcesContent": ["import { bufferToHexaString } from \"@ledgerhq/device-management-kit\";\nimport { ethers, getBytes } from \"ethers\";\nimport { injectable } from \"inversify\";\nimport { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport { TransactionMapperResult } from \"./model/TransactionMapperResult\";\nimport { TransactionMapper } from \"./TransactionMapper\";\n\n@injectable()\nexport class EthersRawTransactionMapper implements TransactionMapper {\n  map(transaction: Uint8Array): Maybe<TransactionMapperResult> {\n    try {\n      const tx = ethers.Transaction.from(bufferToHexaString(transaction));\n      return Just({\n        subset: {\n          chainId: Number(tx.chainId.toString()),\n          to: tx.to ?? undefined,\n          data: tx.data,\n        },\n        serializedTransaction: getBytes(tx.unsignedSerialized),\n        type: tx.type || 0,\n      });\n    } catch (_error) {\n      return Nothing;\n    }\n  }\n}\n"],
+  "mappings": "wMAAA,OAAS,sBAAAA,MAA0B,kCACnC,OAAS,UAAAC,EAAQ,YAAAC,MAAgB,SACjC,OAAS,cAAAC,MAAkB,YAC3B,OAAS,QAAAC,EAAa,WAAAC,MAAe,YAM9B,IAAMC,EAAN,KAA8D,CACnE,IAAIC,EAAyD,CAC3D,GAAI,CACF,MAAMC,EAAKC,EAAO,YAAY,KAAKC,EAAmBH,CAAW,CAAC,EAClE,OAAOI,EAAK,CACV,OAAQ,CACN,QAAS,OAAOH,EAAG,QAAQ,SAAS,CAAC,EACrC,GAAIA,EAAG,IAAM,OACb,KAAMA,EAAG,IACX,EACA,sBAAuBI,EAASJ,EAAG,kBAAkB,EACrD,KAAMA,EAAG,MAAQ,CACnB,CAAC,CACH,MAAiB,CACf,OAAOK,CACT,CACF,CACF,EAjBaP,EAANQ,EAAA,CADNC,EAAW,GACCT",
+  "names": ["bufferToHexaString", "ethers", "getBytes", "injectable", "Just", "Nothing", "EthersRawTransactionMapper", "transaction", "tx", "ethers", "bufferToHexaString", "Just", "getBytes", "Nothing", "__decorateClass", "injectable"]
+}

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

@@ -0,0 +1,2 @@
+import{hexaStringToBuffer as n}from"@ledgerhq/device-management-kit";import{getBytes as r,Transaction as o}from"ethers";import{EthersRawTransactionMapper as s}from"./EthersRawTransactionMapper";describe("RawTransactionMapper",()=>{const a=new s;it("should return Nothing when empty raw transaction",()=>{const e=new Uint8Array(0),t=a.map(e);expect(t.isNothing()).toBeTruthy()}),it("should return Nothing when invalid raw transaction",()=>{const e=new Uint8Array(1),t=a.map(e);expect(t.isNothing()).toBeTruthy()}),it("should return a TransactionMapperResult",()=>{const e=n(o.from({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x123456"}).unsignedSerialized),t=a.map(e);expect(t.isJust()).toBeTruthy(),expect(t.extract()?.serializedTransaction).toEqual(r(e)),expect(t.extract()?.subset).toEqual({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x123456"}),expect(t.extract()?.type).toEqual(2)}),it("should return a TransactionMapperResult with undefined to",()=>{const e=n(o.from({chainId:1,data:"0x123456"}).unsignedSerialized),t=a.map(e);expect(t.isJust()).toBeTruthy(),expect(t.extract()?.serializedTransaction).toEqual(r(e)),expect(t.extract()?.subset).toEqual({chainId:1,to:void 0,data:"0x123456"}),expect(t.extract()?.type).toEqual(2)}),it("should return a TransactionMapperResult with empty data",()=>{const e=n(o.from({chainId:1,to:"0x1234567890123456789012345678901234567890"}).unsignedSerialized),t=a.map(e);expect(t.isJust()).toBeTruthy(),expect(t.extract()?.serializedTransaction).toEqual(r(e)),expect(t.extract()?.subset).toEqual({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x"}),expect(t.extract()?.type).toEqual(2)}),it("should return a TransactionMapperResult with a custom type",()=>{const e=n(o.from({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x123456",type:1}).unsignedSerialized),t=a.map(e);expect(t.isJust()).toBeTruthy(),expect(t.extract()?.serializedTransaction).toEqual(r(e)),expect(t.extract()?.subset).toEqual({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x123456"}),expect(t.extract()?.type).toEqual(1)})});
+//# sourceMappingURL=EthersRawTransactionMapper.test.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersRawTransactionMapper.test.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { getBytes, Transaction } from \"ethers\";\n\nimport { EthersRawTransactionMapper } from \"./EthersRawTransactionMapper\";\n\ndescribe(\"RawTransactionMapper\", () => {\n  const mapper = new EthersRawTransactionMapper();\n\n  it(\"should return Nothing when empty raw transaction\", () => {\n    // GIVEN\n    const transaction = new Uint8Array(0);\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 invalid raw transaction\", () => {\n    // GIVEN\n    const transaction = new Uint8Array(1);\n\n    // WHEN\n    const result = mapper.map(transaction);\n\n    // THEN\n    expect(result.isNothing()).toBeTruthy();\n  });\n\n  it(\"should return a TransactionMapperResult\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        to: \"0x1234567890123456789012345678901234567890\",\n        data: \"0x123456\",\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.map(transaction);\n\n    // THEN\n    expect(result.isJust()).toBeTruthy();\n    expect(result.extract()?.serializedTransaction).toEqual(\n      getBytes(transaction),\n    );\n    expect(result.extract()?.subset).toEqual({\n      chainId: 1,\n      to: \"0x1234567890123456789012345678901234567890\",\n      data: \"0x123456\",\n    });\n    expect(result.extract()?.type).toEqual(2);\n  });\n\n  it(\"should return a TransactionMapperResult with undefined to\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        data: \"0x123456\",\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.map(transaction);\n\n    // THEN\n    expect(result.isJust()).toBeTruthy();\n    expect(result.extract()?.serializedTransaction).toEqual(\n      getBytes(transaction),\n    );\n    expect(result.extract()?.subset).toEqual({\n      chainId: 1,\n      to: undefined,\n      data: \"0x123456\",\n    });\n    expect(result.extract()?.type).toEqual(2);\n  });\n\n  it(\"should return a TransactionMapperResult with empty data\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        to: \"0x1234567890123456789012345678901234567890\",\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.map(transaction);\n\n    // THEN\n    expect(result.isJust()).toBeTruthy();\n    expect(result.extract()?.serializedTransaction).toEqual(\n      getBytes(transaction),\n    );\n    expect(result.extract()?.subset).toEqual({\n      chainId: 1,\n      to: \"0x1234567890123456789012345678901234567890\",\n      data: \"0x\",\n    });\n    expect(result.extract()?.type).toEqual(2);\n  });\n\n  it(\"should return a TransactionMapperResult with a custom type\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        to: \"0x1234567890123456789012345678901234567890\",\n        data: \"0x123456\",\n        type: 1,\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.map(transaction);\n\n    // THEN\n    expect(result.isJust()).toBeTruthy();\n    expect(result.extract()?.serializedTransaction).toEqual(\n      getBytes(transaction),\n    );\n    expect(result.extract()?.subset).toEqual({\n      chainId: 1,\n      to: \"0x1234567890123456789012345678901234567890\",\n      data: \"0x123456\",\n    });\n    expect(result.extract()?.type).toEqual(1);\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,sBAAAA,MAA0B,kCACnC,OAAS,YAAAC,EAAU,eAAAC,MAAmB,SAEtC,OAAS,8BAAAC,MAAkC,+BAE3C,SAAS,uBAAwB,IAAM,CACrC,MAAMC,EAAS,IAAID,EAEnB,GAAG,mDAAoD,IAAM,CAE3D,MAAME,EAAc,IAAI,WAAW,CAAC,EAG9BC,EAASF,EAAO,IAAIC,CAAW,EAGrC,OAAOC,EAAO,UAAU,CAAC,EAAE,WAAW,CACxC,CAAC,EAED,GAAG,qDAAsD,IAAM,CAE7D,MAAMD,EAAc,IAAI,WAAW,CAAC,EAG9BC,EAASF,EAAO,IAAIC,CAAW,EAGrC,OAAOC,EAAO,UAAU,CAAC,EAAE,WAAW,CACxC,CAAC,EAED,GAAG,0CAA2C,IAAM,CAElD,MAAMD,EAAcL,EAClBE,EAAY,KAAK,CACf,QAAS,EACT,GAAI,6CACJ,KAAM,UACR,CAAC,EAAE,kBACL,EAGMI,EAASF,EAAO,IAAIC,CAAW,EAGrC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,EACnC,OAAOA,EAAO,QAAQ,GAAG,qBAAqB,EAAE,QAC9CL,EAASI,CAAW,CACtB,EACA,OAAOC,EAAO,QAAQ,GAAG,MAAM,EAAE,QAAQ,CACvC,QAAS,EACT,GAAI,6CACJ,KAAM,UACR,CAAC,EACD,OAAOA,EAAO,QAAQ,GAAG,IAAI,EAAE,QAAQ,CAAC,CAC1C,CAAC,EAED,GAAG,4DAA6D,IAAM,CAEpE,MAAMD,EAAcL,EAClBE,EAAY,KAAK,CACf,QAAS,EACT,KAAM,UACR,CAAC,EAAE,kBACL,EAGMI,EAASF,EAAO,IAAIC,CAAW,EAGrC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,EACnC,OAAOA,EAAO,QAAQ,GAAG,qBAAqB,EAAE,QAC9CL,EAASI,CAAW,CACtB,EACA,OAAOC,EAAO,QAAQ,GAAG,MAAM,EAAE,QAAQ,CACvC,QAAS,EACT,GAAI,OACJ,KAAM,UACR,CAAC,EACD,OAAOA,EAAO,QAAQ,GAAG,IAAI,EAAE,QAAQ,CAAC,CAC1C,CAAC,EAED,GAAG,0DAA2D,IAAM,CAElE,MAAMD,EAAcL,EAClBE,EAAY,KAAK,CACf,QAAS,EACT,GAAI,4CACN,CAAC,EAAE,kBACL,EAGMI,EAASF,EAAO,IAAIC,CAAW,EAGrC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,EACnC,OAAOA,EAAO,QAAQ,GAAG,qBAAqB,EAAE,QAC9CL,EAASI,CAAW,CACtB,EACA,OAAOC,EAAO,QAAQ,GAAG,MAAM,EAAE,QAAQ,CACvC,QAAS,EACT,GAAI,6CACJ,KAAM,IACR,CAAC,EACD,OAAOA,EAAO,QAAQ,GAAG,IAAI,EAAE,QAAQ,CAAC,CAC1C,CAAC,EAED,GAAG,6DAA8D,IAAM,CAErE,MAAMD,EAAcL,EAClBE,EAAY,KAAK,CACf,QAAS,EACT,GAAI,6CACJ,KAAM,WACN,KAAM,CACR,CAAC,EAAE,kBACL,EAGMI,EAASF,EAAO,IAAIC,CAAW,EAGrC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,EACnC,OAAOA,EAAO,QAAQ,GAAG,qBAAqB,EAAE,QAC9CL,EAASI,CAAW,CACtB,EACA,OAAOC,EAAO,QAAQ,GAAG,MAAM,EAAE,QAAQ,CACvC,QAAS,EACT,GAAI,6CACJ,KAAM,UACR,CAAC,EACD,OAAOA,EAAO,QAAQ,GAAG,IAAI,EAAE,QAAQ,CAAC,CAC1C,CAAC,CACH,CAAC",
+  "names": ["hexaStringToBuffer", "getBytes", "Transaction", "EthersRawTransactionMapper", "mapper", "transaction", "result"]
+}

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

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=TransactionMapper.js.map
+//# sourceMappingURL=TransactionMapper.js.map

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

@@ -1 +1,7 @@
-{"version":3,"file":"TransactionMapper.js","sourceRoot":"","sources":["../../../../../../src/internal/transaction/service/mapper/TransactionMapper.ts"],"names":[],"mappings":""}
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

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

@@ -1,38 +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 { injectable, multiInject } from "inversify";
-import { Left, Right } from "purify-ts";
-import { transactionTypes } from "../../../transaction/di/transactionTypes";
-let TransactionMapperService = class TransactionMapperService {
-    _mappers;
-    constructor(mappers) {
-        this._mappers = mappers;
-    }
-    mapTransactionToSubset(transaction) {
-        for (const mapper of this._mappers) {
-            const result = mapper.map(transaction);
-            if (result.isJust()) {
-                return Right(result.extract());
-            }
-        }
-        // TODO: handle correctly with the future error type
-        return Left(new Error("Unsupported transaction type"));
-    }
-};
-TransactionMapperService = __decorate([
-    injectable(),
-    __param(0, multiInject(transactionTypes.TransactionMappers)),
-    __metadata("design:paramtypes", [Array])
-], TransactionMapperService);
-export { TransactionMapperService };
-//# sourceMappingURL=TransactionMapperService.js.map
+var c=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var i=(a,r,o,t)=>{for(var p=t>1?void 0:t?u(r,o):r,n=a.length-1,e;n>=0;n--)(e=a[n])&&(p=(t?e(r,o,p):e(p))||p);return t&&p&&c(r,o,p),p},m=(a,r)=>(o,t)=>r(o,t,a);import{injectable as f,multiInject as l}from"inversify";import{Left as T,Right as h}from"purify-ts";import{transactionTypes as E}from"../../../transaction/di/transactionTypes";let s=class{_mappers;constructor(r){this._mappers=r}mapTransactionToSubset(r){for(const o of this._mappers){const t=o.map(r);if(t.isJust())return h(t.extract())}return T(new Error("Unsupported transaction type"))}};s=i([f(),m(0,l(E.TransactionMappers))],s);export{s as TransactionMapperService};
+//# sourceMappingURL=TransactionMapperService.js.map

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

@@ -1 +1,7 @@
-{"version":3,"file":"TransactionMapperService.js","sourceRoot":"","sources":["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAU,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAMtE,IAAM,wBAAwB,GAA9B,MAAM,wBAAwB;IAC3B,QAAQ,CAAsB;IAEtC,YAEE,OAA4B;QAE5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED,sBAAsB,CACpB,WAAwB;QAExB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACvC,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;gBACpB,OAAO,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QAED,oDAAoD;QACpD,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAC;IACzD,CAAC;CACF,CAAA;AAvBY,wBAAwB;IADpC,UAAU,EAAE;IAKR,WAAA,WAAW,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAA;;GAJxC,wBAAwB,CAuBpC"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.ts"],
+  "sourcesContent": ["import { injectable, multiInject } from \"inversify\";\nimport { Either, Left, Right } from \"purify-ts\";\n\nimport { transactionTypes } from \"@internal/transaction/di/transactionTypes\";\n\nimport { TransactionMapperResult } from \"./model/TransactionMapperResult\";\nimport { TransactionMapper } from \"./TransactionMapper\";\n\n@injectable()\nexport class TransactionMapperService {\n  private _mappers: TransactionMapper[];\n\n  constructor(\n    @multiInject(transactionTypes.TransactionMappers)\n    mappers: TransactionMapper[],\n  ) {\n    this._mappers = mappers;\n  }\n\n  mapTransactionToSubset(\n    transaction: Uint8Array,\n  ): Either<Error, TransactionMapperResult> {\n    for (const mapper of this._mappers) {\n      const result = mapper.map(transaction);\n      if (result.isJust()) {\n        return Right(result.extract());\n      }\n    }\n\n    // TODO: handle correctly with the future error type\n    return Left(new Error(\"Unsupported transaction type\"));\n  }\n}\n"],
+  "mappings": "iOAAA,OAAS,cAAAA,EAAY,eAAAC,MAAmB,YACxC,OAAiB,QAAAC,EAAM,SAAAC,MAAa,YAEpC,OAAS,oBAAAC,MAAwB,4CAM1B,IAAMC,EAAN,KAA+B,CAC5B,SAER,YAEEC,EACA,CACA,KAAK,SAAWA,CAClB,CAEA,uBACEC,EACwC,CACxC,UAAWC,KAAU,KAAK,SAAU,CAClC,MAAMC,EAASD,EAAO,IAAID,CAAW,EACrC,GAAIE,EAAO,OAAO,EAChB,OAAOC,EAAMD,EAAO,QAAQ,CAAC,CAEjC,CAGA,OAAOE,EAAK,IAAI,MAAM,8BAA8B,CAAC,CACvD,CACF,EAvBaN,EAANO,EAAA,CADNC,EAAW,EAKPC,EAAA,EAAAC,EAAYC,EAAiB,kBAAkB,IAJvCX",
+  "names": ["injectable", "multiInject", "Left", "Right", "transactionTypes", "TransactionMapperService", "mappers", "transaction", "mapper", "result", "Right", "Left", "__decorateClass", "injectable", "__decorateParam", "multiInject", "transactionTypes"]
+}

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

@@ -0,0 +1,2 @@
+import{Just as s,Nothing as r,Right as p}from"purify-ts";import{TransactionMapperService as o}from"./TransactionMapperService";const t=a=>({map:vi.fn().mockReturnValue(a)});describe("TransactionMapperService",()=>{let a;beforeEach(()=>{vi.clearAllMocks()}),it("should return a TransactionSubset",()=>{const e=[t(s({data:"data"})),t(r)];a=new o(e);const n=a.mapTransactionToSubset(new Uint8Array(0));expect(e[0].map).toHaveBeenCalled(),expect(e[1].map).not.toHaveBeenCalled(),expect(n).toEqual(p({data:"data"}))}),it("should return a TransactionSubset for the second mapper",()=>{const e=[t(r),t(s({data:"data-2"}))];a=new o(e);const n=a.mapTransactionToSubset(new Uint8Array(0));expect(e[0].map).toHaveBeenCalled(),expect(e[1].map).toHaveBeenCalled(),expect(n).toEqual(p({data:"data-2"}))}),it("should return an error",()=>{const e=[t(r),t(r)];a=new o(e);const n=a.mapTransactionToSubset(new Uint8Array(0));expect(e[0].map).toHaveBeenCalled(),expect(e[1].map).toHaveBeenCalled(),expect(n.isLeft()).toBeTruthy()})});
+//# sourceMappingURL=TransactionMapperService.test.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.test.ts"],
+  "sourcesContent": ["import { type TransactionSubset } from \"@ledgerhq/context-module\";\nimport { Just, type Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { TransactionMapperService } from \"./TransactionMapperService\";\n\nconst transactionMapperBuilder = (value?: Maybe<TransactionSubset>) => {\n  const map = vi.fn().mockReturnValue(value);\n  return { map };\n};\n\ndescribe(\"TransactionMapperService\", () => {\n  let service: TransactionMapperService;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n  });\n\n  it(\"should return a TransactionSubset\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Just({ data: \"data\" } as TransactionSubset)),\n      transactionMapperBuilder(Nothing),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset(new Uint8Array(0));\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).not.toHaveBeenCalled();\n    expect(result).toEqual(Right({ data: \"data\" }));\n  });\n\n  it(\"should return a TransactionSubset for the second mapper\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Nothing),\n      transactionMapperBuilder(Just({ data: \"data-2\" } as TransactionSubset)),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset(new Uint8Array(0));\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).toHaveBeenCalled();\n    expect(result).toEqual(Right({ data: \"data-2\" }));\n  });\n\n  it(\"should return an error\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Nothing),\n      transactionMapperBuilder(Nothing),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset(new Uint8Array(0));\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).toHaveBeenCalled();\n    expect(result.isLeft()).toBeTruthy();\n  });\n});\n"],
+  "mappings": "AACA,OAAS,QAAAA,EAAkB,WAAAC,EAAS,SAAAC,MAAa,YAEjD,OAAS,4BAAAC,MAAgC,6BAEzC,MAAMC,EAA4BC,IAEzB,CAAE,IADG,GAAG,GAAG,EAAE,gBAAgBA,CAAK,CAC5B,GAGf,SAAS,2BAA4B,IAAM,CACzC,IAAIC,EAEJ,WAAW,IAAM,CACf,GAAG,cAAc,CACnB,CAAC,EAED,GAAG,oCAAqC,IAAM,CAE5C,MAAMC,EAAU,CACdH,EAAyBJ,EAAK,CAAE,KAAM,MAAO,CAAsB,CAAC,EACpEI,EAAyBH,CAAO,CAClC,EACAK,EAAU,IAAIH,EAAyBI,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,IAAI,WAAW,CAAC,CAAC,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,IAAI,iBAAiB,EAC7C,OAAOC,CAAM,EAAE,QAAQN,EAAM,CAAE,KAAM,MAAO,CAAC,CAAC,CAChD,CAAC,EAED,GAAG,0DAA2D,IAAM,CAElE,MAAMK,EAAU,CACdH,EAAyBH,CAAO,EAChCG,EAAyBJ,EAAK,CAAE,KAAM,QAAS,CAAsB,CAAC,CACxE,EACAM,EAAU,IAAIH,EAAyBI,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,IAAI,WAAW,CAAC,CAAC,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,CAAM,EAAE,QAAQN,EAAM,CAAE,KAAM,QAAS,CAAC,CAAC,CAClD,CAAC,EAED,GAAG,yBAA0B,IAAM,CAEjC,MAAMK,EAAU,CACdH,EAAyBH,CAAO,EAChCG,EAAyBH,CAAO,CAClC,EACAK,EAAU,IAAIH,EAAyBI,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,IAAI,WAAW,CAAC,CAAC,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,CACrC,CAAC,CACH,CAAC",
+  "names": ["Just", "Nothing", "Right", "TransactionMapperService", "transactionMapperBuilder", "value", "service", "mappers", "result"]
+}