npm - @ledgerhq/device-signer-kit-ethereum - Versions diffs - 0.0.0-signer-eth-20250122093657 → 0.0.0-try-to-fix-20250429171448 - Mend

@ledgerhq/device-signer-kit-ethereum 0.0.0-signer-eth-20250122093657 → 0.0.0-try-to-fix-20250429171448

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

Files changed (297) hide show

package/lib/cjs/internal/transaction/service/parser/TransactionParserService.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var s=require("@ledgerhq/context-module"),a=require("@ledgerhq/device-management-kit"),l=require("ethers"),n=require("./TransactionParserService");describe("TransactionParserService",()=>{const i=new n.TransactionParserService,o=(0,a.hexaStringToBuffer)("0x3f32cF0B1DF94157EE1c3876c49BE3732C92a98f"),r=81818275935222000n,p=new a.ByteArrayBuilder().add256BitUIntToData(81818275935222000n).build();beforeEach(()=>{jest.clearAllMocks()}),describe("Container paths",()=>{it("should extract TO of the container",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x"}).unsignedSerialized),e=i.extractValue(c,s.ContainerPath.TO);expect(e.isRight()).toStrictEqual(!0),expect(e.unsafeCoerce()).toStrictEqual([o])}),it("should extract VALUE of the container",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x"}).unsignedSerialized),e=i.extractValue(c,s.ContainerPath.VALUE);expect(e.isRight()).toStrictEqual(!0),expect(e.unsafeCoerce()).toStrictEqual([p])}),it("Unavailable container fields",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({data:"0x",signature:{r:"0x73b969418389828a6328fdb96e747296226832894b8bb46d60f231a9960ec3b5",s:"0x4806aaccc52354f4a42ef9efe0d89dd8cf95210829443ad7f4a9017d6b02de07",v:1}}).unsignedSerialized),e=i.extractValue(c,s.ContainerPath.FROM),t=i.extractValue(c,s.ContainerPath.TO);expect(e.isRight()).toStrictEqual(!1),expect(t.isRight()).toStrictEqual(!1)}),it("invalid transaction format",()=>{const c=(0,a.hexaStringToBuffer)("0xdeadbeef"),e=i.extractValue(c,s.ContainerPath.FROM);expect(e.isRight()).toStrictEqual(!1)})}),describe("Data paths in a calldata with static elements",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001"}).unsignedSerialized);it("Extract the first element",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000045")])}),it("Extract the second element",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001")])}),it("Slice the static leaf",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"},{type:"SLICE",start:-4}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x00000045")])}),it("Out of bounds",()=>{const e=[{type:"TUPLE",offset:2},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)})}),describe("Data paths in a calldata with dynamic elements",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000"}).unsignedSerialized);it("Extract all the elements of x, concatenated together",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000003")])}),it("Extract all the elements of x[0]",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1,start:0,end:1},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002")])}),it("Extract all the elements of x[0:-1][-1:]",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1,start:0,end:-1},{type:"REF"},{type:"ARRAY",itemSize:1,start:-1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002")])}),it("Array out of bounds",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1,start:0,end:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Extract all the elements of x[1]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x6f6e65"),(0,a.hexaStringToBuffer)("0x74776f"),(0,a.hexaStringToBuffer)("0x7468726565")])}),it("Extract all the elements of x[1][:2]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,end:2},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x6f6e65"),(0,a.hexaStringToBuffer)("0x74776f")])}),it("Slice the dynamic leaf with [1:-2]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",start:1,end:-2}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x6872")])}),it("Slice the dynamic leaf with [-1:]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",start:-1}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x65")])}),it("Slice the dynamic leaf with [:1]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",end:1}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x74")])}),it("Error no leaf",()=>{const e=[{type:"TUPLE",offset:1}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Error slice not at the end",()=>{const e=[{type:"TUPLE",offset:1},{type:"SLICE",start:0,end:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Error empty slice",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",start:0,end:0}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)})}),describe("Array of tuples, with bigger itemSize",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006"}).unsignedSerialized);it("Extract the first tuple element of all array elements",()=>{const e=[{type:"REF"},{type:"ARRAY",itemSize:2},{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000003"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000005")])}),it("Extract the second tuple element of all array elements",()=>{const e=[{type:"REF"},{type:"ARRAY",itemSize:2},{type:"TUPLE",offset:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000004"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000006")])})}),describe("Malformed calldata",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002"}).unsignedSerialized);it("Dynamic leaf length overflow",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Calldata smaller than dynamic leaf",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Array length overflow",()=>{const e=[{type:"TUPLE",offset:1},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Calldata smaller than array length",()=>{const e=[{type:"TUPLE",offset:0},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Ref out of bounds",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)})})});
+"use strict";var s=require("@ledgerhq/context-module"),a=require("@ledgerhq/device-management-kit"),l=require("ethers"),n=require("./TransactionParserService");describe("TransactionParserService",()=>{const i=new n.TransactionParserService,o=(0,a.hexaStringToBuffer)("0x3f32cF0B1DF94157EE1c3876c49BE3732C92a98f"),r=81818275935222000n,p=new a.ByteArrayBuilder().add256BitUIntToData(81818275935222000n).build();beforeEach(()=>{vi.clearAllMocks()}),describe("Container paths",()=>{it("should extract TO of the container",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x"}).unsignedSerialized),e=i.extractValue(c,s.ContainerPath.TO);expect(e.isRight()).toStrictEqual(!0),expect(e.unsafeCoerce()).toStrictEqual([o])}),it("should extract VALUE of the container",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x"}).unsignedSerialized),e=i.extractValue(c,s.ContainerPath.VALUE);expect(e.isRight()).toStrictEqual(!0),expect(e.unsafeCoerce()).toStrictEqual([p])}),it("Unavailable container fields",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({data:"0x",signature:{r:"0x73b969418389828a6328fdb96e747296226832894b8bb46d60f231a9960ec3b5",s:"0x4806aaccc52354f4a42ef9efe0d89dd8cf95210829443ad7f4a9017d6b02de07",v:1}}).unsignedSerialized),e=i.extractValue(c,s.ContainerPath.FROM),t=i.extractValue(c,s.ContainerPath.TO);expect(e.isRight()).toStrictEqual(!1),expect(t.isRight()).toStrictEqual(!1)}),it("invalid transaction format",()=>{const c=(0,a.hexaStringToBuffer)("0xdeadbeef"),e=i.extractValue(c,s.ContainerPath.FROM);expect(e.isRight()).toStrictEqual(!1)})}),describe("Data paths in a calldata with static elements",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001"}).unsignedSerialized);it("Extract the first element",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000045")])}),it("Extract the second element",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001")])}),it("Slice the static leaf",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"},{type:"SLICE",start:-4}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x00000045")])}),it("Out of bounds",()=>{const e=[{type:"TUPLE",offset:2},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)})}),describe("Data paths in a calldata with dynamic elements",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000"}).unsignedSerialized);it("Extract all the elements of x, concatenated together",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000003")])}),it("Extract all the elements of x[0]",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1,start:0,end:1},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002")])}),it("Extract all the elements of x[0:-1][-1:]",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1,start:0,end:-1},{type:"REF"},{type:"ARRAY",itemSize:1,start:-1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002")])}),it("Array out of bounds",()=>{const e=[{type:"TUPLE",offset:0},{type:"REF"},{type:"ARRAY",itemSize:1,start:0,end:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Extract all the elements of x[1]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x6f6e65"),(0,a.hexaStringToBuffer)("0x74776f"),(0,a.hexaStringToBuffer)("0x7468726565")])}),it("Extract all the elements of x[1][:2]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,end:2},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x6f6e65"),(0,a.hexaStringToBuffer)("0x74776f")])}),it("Slice the dynamic leaf with [1:-2]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",start:1,end:-2}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x6872")])}),it("Slice the dynamic leaf with [-1:]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",start:-1}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x65")])}),it("Slice the dynamic leaf with [:1]",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"ARRAY",itemSize:1,start:2,end:3},{type:"REF"},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",end:1}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x74")])}),it("Error no leaf",()=>{const e=[{type:"TUPLE",offset:1}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Error slice not at the end",()=>{const e=[{type:"TUPLE",offset:1},{type:"SLICE",start:0,end:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Error empty slice",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"DYNAMIC_LEAF"},{type:"SLICE",start:0,end:0}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)})}),describe("Array of tuples, with bigger itemSize",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006"}).unsignedSerialized);it("Extract the first tuple element of all array elements",()=>{const e=[{type:"REF"},{type:"ARRAY",itemSize:2},{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000003"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000005")])}),it("Extract the second tuple element of all array elements",()=>{const e=[{type:"REF"},{type:"ARRAY",itemSize:2},{type:"TUPLE",offset:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000004"),(0,a.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000006")])})}),describe("Malformed calldata",()=>{const c=(0,a.hexaStringToBuffer)(l.Transaction.from({to:(0,a.bufferToHexaString)(o),value:r,data:"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002"}).unsignedSerialized);it("Dynamic leaf length overflow",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Calldata smaller than dynamic leaf",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Array length overflow",()=>{const e=[{type:"TUPLE",offset:1},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Calldata smaller than array length",()=>{const e=[{type:"TUPLE",offset:0},{type:"ARRAY",itemSize:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)}),it("Ref out of bounds",()=>{const e=[{type:"TUPLE",offset:1},{type:"REF"},{type:"LEAF",leafType:"STATIC_LEAF"}],t=i.extractValue(c,e);expect(t.isRight()).toStrictEqual(!1)})})});
 //# sourceMappingURL=TransactionParserService.test.js.map

package/lib/cjs/internal/transaction/service/parser/TransactionParserService.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/parser/TransactionParserService.test.ts"],
-  "sourcesContent": ["import { ContainerPath, type DataPathElement } from \"@ledgerhq/context-module\";\nimport {\n  bufferToHexaString,\n  ByteArrayBuilder,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers\";\n\nimport { TransactionParserService } from \"./TransactionParserService\";\n\ndescribe(\"TransactionParserService\", () => {\n  const parser = new TransactionParserService();\n\n  const TO = hexaStringToBuffer(\"0x3f32cF0B1DF94157EE1c3876c49BE3732C92a98f\")!;\n  const VALUE = 81818275935222000n;\n  const VALUE_BIN = new ByteArrayBuilder()\n    .add256BitUIntToData(81818275935222000n)\n    .build();\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  describe(\"Container paths\", () => {\n    it(\"should extract TO of the container\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          to: bufferToHexaString(TO),\n          value: VALUE,\n          data: \"0x\",\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const value = parser.extractValue(transaction, ContainerPath.TO);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([TO]);\n    });\n\n    it(\"should extract VALUE of the container\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          to: bufferToHexaString(TO),\n          value: VALUE,\n          data: \"0x\",\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const value = parser.extractValue(transaction, ContainerPath.VALUE);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([VALUE_BIN]);\n    });\n\n    it(\"Unavailable container fields\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          data: \"0x\",\n          signature: {\n            r: \"0x73b969418389828a6328fdb96e747296226832894b8bb46d60f231a9960ec3b5\",\n            s: \"0x4806aaccc52354f4a42ef9efe0d89dd8cf95210829443ad7f4a9017d6b02de07\",\n            v: 1,\n          },\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const from = parser.extractValue(transaction, ContainerPath.FROM);\n      const to = parser.extractValue(transaction, ContainerPath.TO);\n\n      // THEN\n      expect(from.isRight()).toStrictEqual(false);\n      expect(to.isRight()).toStrictEqual(false);\n    });\n\n    it(\"invalid transaction format\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\"0xdeadbeef\")!;\n\n      // WHEN\n      const from = parser.extractValue(transaction, ContainerPath.FROM);\n\n      // THEN\n      expect(from.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Data paths in a calldata with static elements\", () => {\n    // Example from abi specification:\n    // https://docs.soliditylang.org/en/latest/abi-spec.html\n    //\n    // function baz(uint32 x, bool y)\n    // parameters: x = 69\n    //             y = true\n    // calldata:\n    //   0xcdcd77c0\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000045\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000001\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract the first element\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000045\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract the second element\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n      ]);\n    });\n\n    it(\"Slice the static leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: -4,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x00000045\")!,\n      ]);\n    });\n\n    it(\"Out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 2,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Data paths in a calldata with dynamic elements\", () => {\n    // Example from abi specification:\n    // https://docs.soliditylang.org/en/latest/abi-spec.html\n    //\n    // function g(uint256[][] x, string[] x)\n    // parameters: x = [[1, 2], [3]]\n    //             y = [\"one\", \"two\", \"three\"]\n    // calldata:\n    //   0x2289b18c\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000140: offset of y\n    //   [2] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x\n    //   [3] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x[0]\n    //   [4] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of x[1]\n    //   [5] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x[0]\n    //   [6] 0x0000000000000000000000000000000000000000000000000000000000000001: value of x[0][0] = 1\n    //   [7] 0x0000000000000000000000000000000000000000000000000000000000000002: value of x[0][1] = 2\n    //   [8] 0x0000000000000000000000000000000000000000000000000000000000000001: length of x[1]\n    //   [9] 0x0000000000000000000000000000000000000000000000000000000000000003: value of x[1][0] = 3\n    //   [10] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y\n    //   [11] 0x0000000000000000000000000000000000000000000000000000000000000060: offset of y[0]\n    //   [12] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of y[1]\n    //   [13] 0x00000000000000000000000000000000000000000000000000000000000000e0: offset of y[2]\n    //   [14] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[0]\n    //   [15] 0x6f6e650000000000000000000000000000000000000000000000000000000000: value of y[0] = \"one\"\n    //   [16] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[1]\n    //   [17] 0x74776f0000000000000000000000000000000000000000000000000000000000: value of y[1] = \"two\"\n    //   [18] 0x0000000000000000000000000000000000000000000000000000000000000005: length of y[2]\n    //   [19] 0x7468726565000000000000000000000000000000000000000000000000000000: value of y[2] = \"three\"\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract all the elements of x, concatenated together\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000003\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[0]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[0:-1][-1:]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: -1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: -1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n      ]);\n    });\n\n    it(\"Array out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Extract all the elements of x[1]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6f6e65\")!,\n        hexaStringToBuffer(\"0x74776f\")!,\n        hexaStringToBuffer(\"0x7468726565\")!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[1][:2]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          end: 2,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6f6e65\")!,\n        hexaStringToBuffer(\"0x74776f\")!,\n      ]);\n    });\n\n    it(\"Slice the dynamic leaf with [1:-2]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: 1,\n          end: -2,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6872\")!,\n      ]);\n    });\n\n    it(\"Slice the dynamic leaf with [-1:]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: -1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([hexaStringToBuffer(\"0x65\")!]);\n    });\n\n    it(\"Slice the dynamic leaf with [:1]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          end: 1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([hexaStringToBuffer(\"0x74\")!]);\n    });\n\n    it(\"Error no leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Error slice not at the end\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"SLICE\",\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Error empty slice\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: 0,\n          end: 0,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Array of tuples, with bigger itemSize\", () => {\n    // Example constructed with an array of tuples just for the tests\n    //\n    // function baz((uint32, uint32) myTuple[])\n    // parameters: myTuple = [ (1, 2), (3, 4), (5, 6) ]\n    // calldata:\n    //   0xcdcd77c0\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000020\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000003\n    //   [2] 0x0000000000000000000000000000000000000000000000000000000000000001\n    //   [3] 0x0000000000000000000000000000000000000000000000000000000000000002\n    //   [4] 0x0000000000000000000000000000000000000000000000000000000000000003\n    //   [5] 0x0000000000000000000000000000000000000000000000000000000000000004\n    //   [6] 0x0000000000000000000000000000000000000000000000000000000000000005\n    //   [7] 0x0000000000000000000000000000000000000000000000000000000000000006\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract the first tuple element of all array elements\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 2,\n        },\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000003\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000005\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract the second tuple element of all array elements\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 2,\n        },\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000004\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000006\",\n        )!,\n      ]);\n    });\n  });\n\n  describe(\"Malformed calldata\", () => {\n    // Example constructed with invalid data just for the tests\n    //\n    // calldata:\n    //   0x2289b18c\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000080\n    //   [1] 0xf000000000000000000000000000000000000000000000000000000000000140\n    //   [2] 0xf000000000000000000000000000000000000000000000000000000000000002\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Dynamic leaf length overflow\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Calldata smaller than dynamic leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Array length overflow\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Calldata smaller than array length\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Ref out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n});\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { ContainerPath, type DataPathElement } from \"@ledgerhq/context-module\";\nimport {\n  bufferToHexaString,\n  ByteArrayBuilder,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers\";\n\nimport { TransactionParserService } from \"./TransactionParserService\";\n\ndescribe(\"TransactionParserService\", () => {\n  const parser = new TransactionParserService();\n\n  const TO = hexaStringToBuffer(\"0x3f32cF0B1DF94157EE1c3876c49BE3732C92a98f\")!;\n  const VALUE = 81818275935222000n;\n  const VALUE_BIN = new ByteArrayBuilder()\n    .add256BitUIntToData(81818275935222000n)\n    .build();\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n  });\n\n  describe(\"Container paths\", () => {\n    it(\"should extract TO of the container\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          to: bufferToHexaString(TO),\n          value: VALUE,\n          data: \"0x\",\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const value = parser.extractValue(transaction, ContainerPath.TO);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([TO]);\n    });\n\n    it(\"should extract VALUE of the container\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          to: bufferToHexaString(TO),\n          value: VALUE,\n          data: \"0x\",\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const value = parser.extractValue(transaction, ContainerPath.VALUE);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([VALUE_BIN]);\n    });\n\n    it(\"Unavailable container fields\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          data: \"0x\",\n          signature: {\n            r: \"0x73b969418389828a6328fdb96e747296226832894b8bb46d60f231a9960ec3b5\",\n            s: \"0x4806aaccc52354f4a42ef9efe0d89dd8cf95210829443ad7f4a9017d6b02de07\",\n            v: 1,\n          },\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const from = parser.extractValue(transaction, ContainerPath.FROM);\n      const to = parser.extractValue(transaction, ContainerPath.TO);\n\n      // THEN\n      expect(from.isRight()).toStrictEqual(false);\n      expect(to.isRight()).toStrictEqual(false);\n    });\n\n    it(\"invalid transaction format\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\"0xdeadbeef\")!;\n\n      // WHEN\n      const from = parser.extractValue(transaction, ContainerPath.FROM);\n\n      // THEN\n      expect(from.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Data paths in a calldata with static elements\", () => {\n    // Example from abi specification:\n    // https://docs.soliditylang.org/en/latest/abi-spec.html\n    //\n    // function baz(uint32 x, bool y)\n    // parameters: x = 69\n    //             y = true\n    // calldata:\n    //   0xcdcd77c0\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000045\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000001\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract the first element\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000045\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract the second element\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n      ]);\n    });\n\n    it(\"Slice the static leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: -4,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x00000045\")!,\n      ]);\n    });\n\n    it(\"Out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 2,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Data paths in a calldata with dynamic elements\", () => {\n    // Example from abi specification:\n    // https://docs.soliditylang.org/en/latest/abi-spec.html\n    //\n    // function g(uint256[][] x, string[] x)\n    // parameters: x = [[1, 2], [3]]\n    //             y = [\"one\", \"two\", \"three\"]\n    // calldata:\n    //   0x2289b18c\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000140: offset of y\n    //   [2] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x\n    //   [3] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x[0]\n    //   [4] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of x[1]\n    //   [5] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x[0]\n    //   [6] 0x0000000000000000000000000000000000000000000000000000000000000001: value of x[0][0] = 1\n    //   [7] 0x0000000000000000000000000000000000000000000000000000000000000002: value of x[0][1] = 2\n    //   [8] 0x0000000000000000000000000000000000000000000000000000000000000001: length of x[1]\n    //   [9] 0x0000000000000000000000000000000000000000000000000000000000000003: value of x[1][0] = 3\n    //   [10] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y\n    //   [11] 0x0000000000000000000000000000000000000000000000000000000000000060: offset of y[0]\n    //   [12] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of y[1]\n    //   [13] 0x00000000000000000000000000000000000000000000000000000000000000e0: offset of y[2]\n    //   [14] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[0]\n    //   [15] 0x6f6e650000000000000000000000000000000000000000000000000000000000: value of y[0] = \"one\"\n    //   [16] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[1]\n    //   [17] 0x74776f0000000000000000000000000000000000000000000000000000000000: value of y[1] = \"two\"\n    //   [18] 0x0000000000000000000000000000000000000000000000000000000000000005: length of y[2]\n    //   [19] 0x7468726565000000000000000000000000000000000000000000000000000000: value of y[2] = \"three\"\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract all the elements of x, concatenated together\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000003\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[0]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[0:-1][-1:]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: -1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: -1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n      ]);\n    });\n\n    it(\"Array out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Extract all the elements of x[1]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6f6e65\")!,\n        hexaStringToBuffer(\"0x74776f\")!,\n        hexaStringToBuffer(\"0x7468726565\")!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[1][:2]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          end: 2,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6f6e65\")!,\n        hexaStringToBuffer(\"0x74776f\")!,\n      ]);\n    });\n\n    it(\"Slice the dynamic leaf with [1:-2]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: 1,\n          end: -2,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6872\")!,\n      ]);\n    });\n\n    it(\"Slice the dynamic leaf with [-1:]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: -1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([hexaStringToBuffer(\"0x65\")!]);\n    });\n\n    it(\"Slice the dynamic leaf with [:1]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          end: 1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([hexaStringToBuffer(\"0x74\")!]);\n    });\n\n    it(\"Error no leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Error slice not at the end\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"SLICE\",\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Error empty slice\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: 0,\n          end: 0,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Array of tuples, with bigger itemSize\", () => {\n    // Example constructed with an array of tuples just for the tests\n    //\n    // function baz((uint32, uint32) myTuple[])\n    // parameters: myTuple = [ (1, 2), (3, 4), (5, 6) ]\n    // calldata:\n    //   0xcdcd77c0\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000020\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000003\n    //   [2] 0x0000000000000000000000000000000000000000000000000000000000000001\n    //   [3] 0x0000000000000000000000000000000000000000000000000000000000000002\n    //   [4] 0x0000000000000000000000000000000000000000000000000000000000000003\n    //   [5] 0x0000000000000000000000000000000000000000000000000000000000000004\n    //   [6] 0x0000000000000000000000000000000000000000000000000000000000000005\n    //   [7] 0x0000000000000000000000000000000000000000000000000000000000000006\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract the first tuple element of all array elements\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 2,\n        },\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000003\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000005\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract the second tuple element of all array elements\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 2,\n        },\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000004\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000006\",\n        )!,\n      ]);\n    });\n  });\n\n  describe(\"Malformed calldata\", () => {\n    // Example constructed with invalid data just for the tests\n    //\n    // calldata:\n    //   0x2289b18c\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000080\n    //   [1] 0xf000000000000000000000000000000000000000000000000000000000000140\n    //   [2] 0xf000000000000000000000000000000000000000000000000000000000000002\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Dynamic leaf length overflow\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Calldata smaller than dynamic leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Array length overflow\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Calldata smaller than array length\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Ref out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n});\n"],
+  "mappings": "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",
   "names": ["import_context_module", "import_device_management_kit", "import_ethers", "import_TransactionParserService", "parser", "TO", "VALUE", "VALUE_BIN", "transaction", "value", "from", "to", "TX", "path"]
 }

package/lib/cjs/internal/transaction/use-case/SignTransactionUseCase.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var i=require("@ledgerhq/device-management-kit"),r=require("ethers"),s=require("./SignTransactionUseCase");describe("SignTransactionUseCase",()=>{it("should call signTransaction on appBinder with the correct arguments",()=>{const t="m/44'/60'/0'/0/0",n=new r.Transaction;n.to="0x1234567890123456789012345678901234567890",n.value=0n,n.data="0x";const a={signTransaction:jest.fn()},o=new s.SignTransactionUseCase(a),e=(0,i.hexaStringToBuffer)(n.unsignedSerialized);o.execute(t,e),expect(a.signTransaction).toHaveBeenCalledWith({derivationPath:t,transaction:e})})});
+"use strict";var i=require("@ledgerhq/device-management-kit"),r=require("ethers"),o=require("./SignTransactionUseCase");describe("SignTransactionUseCase",()=>{it("should call signTransaction on appBinder with the correct arguments",()=>{const t="m/44'/60'/0'/0/0",n=new r.Transaction;n.to="0x1234567890123456789012345678901234567890",n.value=0n,n.data="0x";const a={signTransaction:vi.fn()},s=new o.SignTransactionUseCase(a),e=(0,i.hexaStringToBuffer)(n.unsignedSerialized);s.execute(t,e),expect(a.signTransaction).toHaveBeenCalledWith({derivationPath:t,transaction:e})})});
 //# sourceMappingURL=SignTransactionUseCase.test.js.map

package/lib/cjs/internal/transaction/use-case/SignTransactionUseCase.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/transaction/use-case/SignTransactionUseCase.test.ts"],
-  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers\";\n\nimport { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\nimport { SignTransactionUseCase } from \"./SignTransactionUseCase\";\n\ndescribe(\"SignTransactionUseCase\", () => {\n  it(\"should call signTransaction on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"m/44'/60'/0'/0/0\";\n    const tx: Transaction = new Transaction();\n    tx.to = \"0x1234567890123456789012345678901234567890\";\n    tx.value = 0n;\n    tx.data = \"0x\";\n    const appBinder: EthAppBinder = {\n      signTransaction: jest.fn(),\n    } as unknown as EthAppBinder;\n    const useCase = new SignTransactionUseCase(appBinder);\n    const transaction = hexaStringToBuffer(tx.unsignedSerialized) as Uint8Array;\n\n    // When\n    useCase.execute(derivationPath, transaction);\n\n    // Then\n    expect(appBinder.signTransaction).toHaveBeenCalledWith({\n      derivationPath,\n      transaction,\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAAmC,2CACnCC,EAA4B,kBAI5BC,EAAuC,oCAEvC,SAAS,yBAA0B,IAAM,CACvC,GAAG,sEAAuE,IAAM,CAE9E,MAAMC,EAAiB,mBACjBC,EAAkB,IAAI,cAC5BA,EAAG,GAAK,6CACRA,EAAG,MAAQ,GACXA,EAAG,KAAO,KACV,MAAMC,EAA0B,CAC9B,gBAAiB,KAAK,GAAG,CAC3B,EACMC,EAAU,IAAI,yBAAuBD,CAAS,EAC9CE,KAAc,sBAAmBH,EAAG,kBAAkB,EAG5DE,EAAQ,QAAQH,EAAgBI,CAAW,EAG3C,OAAOF,EAAU,eAAe,EAAE,qBAAqB,CACrD,eAAAF,EACA,YAAAI,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers\";\n\nimport { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\nimport { SignTransactionUseCase } from \"./SignTransactionUseCase\";\n\ndescribe(\"SignTransactionUseCase\", () => {\n  it(\"should call signTransaction on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"m/44'/60'/0'/0/0\";\n    const tx: Transaction = new Transaction();\n    tx.to = \"0x1234567890123456789012345678901234567890\";\n    tx.value = 0n;\n    tx.data = \"0x\";\n    const appBinder: EthAppBinder = {\n      signTransaction: vi.fn(),\n    } as unknown as EthAppBinder;\n    const useCase = new SignTransactionUseCase(appBinder);\n    const transaction = hexaStringToBuffer(tx.unsignedSerialized) as Uint8Array;\n\n    // When\n    useCase.execute(derivationPath, transaction);\n\n    // Then\n    expect(appBinder.signTransaction).toHaveBeenCalledWith({\n      derivationPath,\n      transaction,\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAAmC,2CACnCC,EAA4B,kBAI5BC,EAAuC,oCAEvC,SAAS,yBAA0B,IAAM,CACvC,GAAG,sEAAuE,IAAM,CAE9E,MAAMC,EAAiB,mBACjBC,EAAkB,IAAI,cAC5BA,EAAG,GAAK,6CACRA,EAAG,MAAQ,GACXA,EAAG,KAAO,KACV,MAAMC,EAA0B,CAC9B,gBAAiB,GAAG,GAAG,CACzB,EACMC,EAAU,IAAI,yBAAuBD,CAAS,EAC9CE,KAAc,sBAAmBH,EAAG,kBAAkB,EAG5DE,EAAQ,QAAQH,EAAgBI,CAAW,EAG3C,OAAOF,EAAU,eAAe,EAAE,qBAAqB,CACrD,eAAAF,EACA,YAAAI,CACF,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["import_device_management_kit", "import_ethers", "import_SignTransactionUseCase", "derivationPath", "tx", "appBinder", "useCase", "transaction"]
 }

package/lib/cjs/internal/typed-data/use-case/SignTypedDataUseCase.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var s=require("./SignTypedDataUseCase");describe("SignTypedDataUseCase",()=>{it("should call signTypedData on appBinder with the correct arguments",()=>{const e="m/44'/60'/0'/0/0",a={domain:{},types:{},primaryType:"test",message:{}},t={parse:jest.fn()},p={signTypedData:jest.fn()};new s.SignTypedDataUseCase(p,t).execute(e,a),expect(p.signTypedData).toHaveBeenCalledWith({derivationPath:e,parser:t,data:a})})});
+"use strict";var s=require("./SignTypedDataUseCase");describe("SignTypedDataUseCase",()=>{it("should call signTypedData on appBinder with the correct arguments",()=>{const e="m/44'/60'/0'/0/0",a={domain:{},types:{},primaryType:"test",message:{}},t={parse:vi.fn()},p={signTypedData:vi.fn()};new s.SignTypedDataUseCase(p,t).execute(e,a),expect(p.signTypedData).toHaveBeenCalledWith({derivationPath:e,parser:t,data:a})})});
 //# sourceMappingURL=SignTypedDataUseCase.test.js.map

package/lib/cjs/internal/typed-data/use-case/SignTypedDataUseCase.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/typed-data/use-case/SignTypedDataUseCase.test.ts"],
-  "sourcesContent": ["import { type TypedData } from \"@api/model/TypedData\";\nimport { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\nimport { type TypedDataParserService } from \"@internal/typed-data/service/TypedDataParserService\";\n\nimport { SignTypedDataUseCase } from \"./SignTypedDataUseCase\";\n\ndescribe(\"SignTypedDataUseCase\", () => {\n  it(\"should call signTypedData on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"m/44'/60'/0'/0/0\";\n    const typedData: TypedData = {\n      domain: {},\n      types: {},\n      primaryType: \"test\",\n      message: {},\n    };\n    const parser: TypedDataParserService = {\n      parse: jest.fn(),\n    };\n    const appBinder = {\n      signTypedData: jest.fn(),\n    };\n    const signTypedDataUseCase = new SignTypedDataUseCase(\n      appBinder as unknown as EthAppBinder,\n      parser,\n    );\n\n    // When\n    signTypedDataUseCase.execute(derivationPath, typedData);\n\n    // Then\n    expect(appBinder.signTypedData).toHaveBeenCalledWith({\n      derivationPath,\n      parser,\n      data: typedData,\n    });\n  });\n});\n"],
-  "mappings": "aAIA,IAAAA,EAAqC,kCAErC,SAAS,uBAAwB,IAAM,CACrC,GAAG,oEAAqE,IAAM,CAE5E,MAAMC,EAAiB,mBACjBC,EAAuB,CAC3B,OAAQ,CAAC,EACT,MAAO,CAAC,EACR,YAAa,OACb,QAAS,CAAC,CACZ,EACMC,EAAiC,CACrC,MAAO,KAAK,GAAG,CACjB,EACMC,EAAY,CAChB,cAAe,KAAK,GAAG,CACzB,EAC6B,IAAI,uBAC/BA,EACAD,CACF,EAGqB,QAAQF,EAAgBC,CAAS,EAGtD,OAAOE,EAAU,aAAa,EAAE,qBAAqB,CACnD,eAAAH,EACA,OAAAE,EACA,KAAMD,CACR,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { type TypedData } from \"@api/model/TypedData\";\nimport { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\nimport { type TypedDataParserService } from \"@internal/typed-data/service/TypedDataParserService\";\n\nimport { SignTypedDataUseCase } from \"./SignTypedDataUseCase\";\n\ndescribe(\"SignTypedDataUseCase\", () => {\n  it(\"should call signTypedData on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"m/44'/60'/0'/0/0\";\n    const typedData: TypedData = {\n      domain: {},\n      types: {},\n      primaryType: \"test\",\n      message: {},\n    };\n    const parser: TypedDataParserService = {\n      parse: vi.fn(),\n    };\n    const appBinder = {\n      signTypedData: vi.fn(),\n    };\n    const signTypedDataUseCase = new SignTypedDataUseCase(\n      appBinder as unknown as EthAppBinder,\n      parser,\n    );\n\n    // When\n    signTypedDataUseCase.execute(derivationPath, typedData);\n\n    // Then\n    expect(appBinder.signTypedData).toHaveBeenCalledWith({\n      derivationPath,\n      parser,\n      data: typedData,\n    });\n  });\n});\n"],
+  "mappings": "aAIA,IAAAA,EAAqC,kCAErC,SAAS,uBAAwB,IAAM,CACrC,GAAG,oEAAqE,IAAM,CAE5E,MAAMC,EAAiB,mBACjBC,EAAuB,CAC3B,OAAQ,CAAC,EACT,MAAO,CAAC,EACR,YAAa,OACb,QAAS,CAAC,CACZ,EACMC,EAAiC,CACrC,MAAO,GAAG,GAAG,CACf,EACMC,EAAY,CAChB,cAAe,GAAG,GAAG,CACvB,EAC6B,IAAI,uBAC/BA,EACAD,CACF,EAGqB,QAAQF,EAAgBC,CAAS,EAGtD,OAAOE,EAAU,aAAa,EAAE,qBAAqB,CACnD,eAAAH,EACA,OAAAE,EACA,KAAMD,CACR,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["import_SignTypedDataUseCase", "derivationPath", "typedData", "parser", "appBinder"]
 }

package/lib/cjs/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/device-signer-kit-ethereum",
-  "version": "1.1.0",
+  "version": "1.3.3",
   "private": false,
   "license": "Apache-2.0",
   "exports": {
@@ -30,14 +30,14 @@
     "prettier": "prettier . --check",
     "prettier:fix": "prettier . --write",
     "typecheck": "tsc --noEmit",
-    "test": "jest",
-    "test:watch": "pnpm test -- --watch",
-    "test:coverage": "pnpm test -- --coverage"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "@ledgerhq/signer-utils": "workspace:*",
     "ethers": "6.13.4",
-    "inversify": "^6.2.1",
+    "inversify": "^6.2.2",
     "inversify-logger-middleware": "^3.1.0",
     "purify-ts": "^2.1.0",
     "reflect-metadata": "^0.2.2",
@@ -49,11 +49,11 @@
     "@ledgerhq/device-management-kit": "workspace:*",
     "@ledgerhq/esbuild-tools": "workspace:*",
     "@ledgerhq/eslint-config-dsdk": "workspace:*",
-    "@ledgerhq/jest-config-dsdk": "workspace:*",
     "@ledgerhq/prettier-config-dsdk": "workspace:*",
     "@ledgerhq/tsconfig-dsdk": "workspace:*",
+    "@ledgerhq/vitest-config-dmk": "workspace:*",
     "@types/semver": "^7.5.8",
-    "rxjs": "^7.8.1",
+    "rxjs": "^7.8.2",
     "ts-node": "^10.9.2"
   },
   "peerDependencies": {

package/lib/esm/api/SignerEthBuilder.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{ContextModuleBuilder as i}from"@ledgerhq/context-module";import{DefaultSignerEth as o}from"../internal/DefaultSignerEth";class d{_dmk;_sessionId;_contextModule;constructor({dmk:e,sessionId:t}){this._dmk=e,this._sessionId=t,this._contextModule=new i().build()}withContextModule(e){return this._contextModule=e,this}build(){return new o({dmk:this._dmk,sessionId:this._sessionId,contextModule:this._contextModule})}}export{d as SignerEthBuilder};
+import{ContextModuleBuilder as o}from"@ledgerhq/context-module";import{DefaultSignerEth as n}from"../internal/DefaultSignerEth";class u{_dmk;_sessionId;_customContextModule;_originToken;constructor({dmk:e,sessionId:t,originToken:i}){this._dmk=e,this._sessionId=t,this._originToken=i}withContextModule(e){return this._customContextModule=e,this}build(){const e=this._customContextModule??new o({originToken:this._originToken}).build();return new n({dmk:this._dmk,sessionId:this._sessionId,contextModule:e})}}export{u as SignerEthBuilder};
 //# sourceMappingURL=SignerEthBuilder.js.map

package/lib/esm/api/SignerEthBuilder.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/SignerEthBuilder.ts"],
-  "sourcesContent": ["import {\n  type ContextModule,\n  ContextModuleBuilder,\n} from \"@ledgerhq/context-module\";\nimport {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { DefaultSignerEth } from \"@internal/DefaultSignerEth\";\n\ntype SignerEthBuilderConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n};\n\n/**\n * Builder for the `SignerEth` class.\n *\n * @example\n * ```\n * const dmk = new SignerEthBuilder(dmk)\n *  .build();\n * ```\n */\nexport class SignerEthBuilder {\n  private _dmk: DeviceManagementKit;\n  private _sessionId: DeviceSessionId;\n  private _contextModule: ContextModule;\n\n  constructor({ dmk, sessionId }: SignerEthBuilderConstructorArgs) {\n    this._dmk = dmk;\n    this._sessionId = sessionId;\n    // default context module for ETH\n    this._contextModule = new ContextModuleBuilder().build();\n  }\n\n  /**\n   * Override the default context module\n   *\n   * @param contextModule\n   * @returns this\n   */\n  withContextModule(contextModule: ContextModule) {\n    this._contextModule = contextModule;\n    return this;\n  }\n\n  /**\n   * Build the ethereum signer\n   *\n   * @returns the ethereum signer\n   */\n  public build() {\n    return new DefaultSignerEth({\n      dmk: this._dmk,\n      sessionId: this._sessionId,\n      contextModule: this._contextModule,\n    });\n  }\n}\n"],
-  "mappings": "AAAA,OAEE,wBAAAA,MACK,2BAMP,OAAS,oBAAAC,MAAwB,6BAgB1B,MAAMC,CAAiB,CACpB,KACA,WACA,eAER,YAAY,CAAE,IAAAC,EAAK,UAAAC,CAAU,EAAoC,CAC/D,KAAK,KAAOD,EACZ,KAAK,WAAaC,EAElB,KAAK,eAAiB,IAAIJ,EAAqB,EAAE,MAAM,CACzD,CAQA,kBAAkBK,EAA8B,CAC9C,YAAK,eAAiBA,EACf,IACT,CAOO,OAAQ,CACb,OAAO,IAAIJ,EAAiB,CAC1B,IAAK,KAAK,KACV,UAAW,KAAK,WAChB,cAAe,KAAK,cACtB,CAAC,CACH,CACF",
-  "names": ["ContextModuleBuilder", "DefaultSignerEth", "SignerEthBuilder", "dmk", "sessionId", "contextModule"]
+  "sourcesContent": ["import {\n  type ContextModule,\n  ContextModuleBuilder,\n} from \"@ledgerhq/context-module\";\nimport {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { DefaultSignerEth } from \"@internal/DefaultSignerEth\";\n\ntype SignerEthBuilderConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  originToken?: string;\n};\n\n/**\n * Builder for the `SignerEth` class.\n *\n * @example\n * ```\n * const dmk = new SignerEthBuilder(dmk)\n *  .build();\n * ```\n */\nexport class SignerEthBuilder {\n  private _dmk: DeviceManagementKit;\n  private _sessionId: DeviceSessionId;\n  private _customContextModule: ContextModule | undefined;\n  private _originToken: string | undefined;\n\n  constructor({\n    dmk,\n    sessionId,\n    originToken,\n  }: SignerEthBuilderConstructorArgs) {\n    this._dmk = dmk;\n    this._sessionId = sessionId;\n    this._originToken = originToken;\n  }\n\n  /**\n   * Override the default context module\n   *\n   * @param contextModule\n   * @returns this\n   */\n  withContextModule(contextModule: ContextModule) {\n    this._customContextModule = contextModule;\n    return this;\n  }\n\n  /**\n   * Build the ethereum signer\n   *\n   * @returns the ethereum signer\n   */\n  public build() {\n    const contextModule =\n      this._customContextModule ??\n      new ContextModuleBuilder({ originToken: this._originToken }).build();\n\n    return new DefaultSignerEth({\n      dmk: this._dmk,\n      sessionId: this._sessionId,\n      contextModule,\n    });\n  }\n}\n"],
+  "mappings": "AAAA,OAEE,wBAAAA,MACK,2BAMP,OAAS,oBAAAC,MAAwB,6BAiB1B,MAAMC,CAAiB,CACpB,KACA,WACA,qBACA,aAER,YAAY,CACV,IAAAC,EACA,UAAAC,EACA,YAAAC,CACF,EAAoC,CAClC,KAAK,KAAOF,EACZ,KAAK,WAAaC,EAClB,KAAK,aAAeC,CACtB,CAQA,kBAAkBC,EAA8B,CAC9C,YAAK,qBAAuBA,EACrB,IACT,CAOO,OAAQ,CACb,MAAMA,EACJ,KAAK,sBACL,IAAIN,EAAqB,CAAE,YAAa,KAAK,YAAa,CAAC,EAAE,MAAM,EAErE,OAAO,IAAIC,EAAiB,CAC1B,IAAK,KAAK,KACV,UAAW,KAAK,WAChB,cAAAK,CACF,CAAC,CACH,CACF",
+  "names": ["ContextModuleBuilder", "DefaultSignerEth", "SignerEthBuilder", "dmk", "sessionId", "originToken", "contextModule"]
 }

package/lib/esm/api/SignerEthBuilder.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{SignerEthBuilder as t}from"./SignerEthBuilder";describe("SignerEthBuilder",()=>{const o={};test("should be an instance of SignerEth",()=>{const e=new t({dmk:o,sessionId:""});e.build(),expect(e).toBeInstanceOf(t)}),test("should instanciate with default context module",()=>{const e=new t({dmk:o,sessionId:""});e.build(),expect(e._contextModule).toBeDefined(),expect(e._contextModule._loaders).toHaveLength(5)}),test("should instanciate with custom context module",()=>{const e=new t({dmk:o,sessionId:""}),n={};e.withContextModule(n).build(),expect(e._contextModule).toBe(n)})});
+import{SignerEthBuilder as n}from"./SignerEthBuilder";import{DefaultSignerEth as c}from"../internal/DefaultSignerEth";import{externalTypes as d}from"../internal/externalTypes";describe("SignerEthBuilder",()=>{const i={dmk:{},sessionId:"",originToken:"test"};test("should be an instance of SignerEth",()=>{const t=new n(i);t.build(),expect(t).toBeInstanceOf(n)}),test("should instanciate with default context module",()=>{const o=new n(i).build(),e=o._container.get(d.ContextModule);expect(o).toBeInstanceOf(c),expect(e).toBeDefined(),expect(e._loaders).toHaveLength(6),expect(e._typedDataLoader).toBeDefined(),expect(e._web3CheckLoader).toBeDefined()}),test("should instanciate with custom context module",()=>{const t=new n(i),o={},e=t.withContextModule(o).build();expect(e).toBeInstanceOf(c),expect(e._container.get(d.ContextModule)).toBe(o)})});
 //# sourceMappingURL=SignerEthBuilder.test.js.map

package/lib/esm/api/SignerEthBuilder.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/SignerEthBuilder.test.ts"],
-  "sourcesContent": ["import {\n  type ContextLoader,\n  type ContextModule,\n} from \"@ledgerhq/context-module\";\nimport { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { SignerEthBuilder } from \"@api/SignerEthBuilder\";\n\ndescribe(\"SignerEthBuilder\", () => {\n  const dmk: DeviceManagementKit = {} as DeviceManagementKit;\n\n  test(\"should be an instance of SignerEth\", () => {\n    // GIVEN\n    const builder = new SignerEthBuilder({ dmk, sessionId: \"\" });\n\n    // WHEN\n    builder.build();\n\n    // THEN\n    expect(builder).toBeInstanceOf(SignerEthBuilder);\n  });\n\n  test(\"should instanciate with default context module\", () => {\n    // GIVEN\n    const builder = new SignerEthBuilder({ dmk, sessionId: \"\" });\n\n    // WHEN\n    builder.build();\n\n    // THEN\n    expect(builder[\"_contextModule\"]).toBeDefined();\n    expect(\n      (builder[\"_contextModule\"] as unknown as { _loaders: ContextLoader[] })\n        ._loaders,\n    ).toHaveLength(5);\n  });\n\n  test(\"should instanciate with custom context module\", () => {\n    // GIVEN\n    const builder = new SignerEthBuilder({ dmk, sessionId: \"\" });\n    const contextModule = {} as ContextModule;\n\n    // WHEN\n    builder.withContextModule(contextModule).build();\n\n    // THEN\n    expect(builder[\"_contextModule\"]).toBe(contextModule);\n  });\n});\n"],
-  "mappings": "AAMA,OAAS,oBAAAA,MAAwB,wBAEjC,SAAS,mBAAoB,IAAM,CACjC,MAAMC,EAA2B,CAAC,EAElC,KAAK,qCAAsC,IAAM,CAE/C,MAAMC,EAAU,IAAIF,EAAiB,CAAE,IAAAC,EAAK,UAAW,EAAG,CAAC,EAG3DC,EAAQ,MAAM,EAGd,OAAOA,CAAO,EAAE,eAAeF,CAAgB,CACjD,CAAC,EAED,KAAK,iDAAkD,IAAM,CAE3D,MAAME,EAAU,IAAIF,EAAiB,CAAE,IAAAC,EAAK,UAAW,EAAG,CAAC,EAG3DC,EAAQ,MAAM,EAGd,OAAOA,EAAQ,cAAiB,EAAE,YAAY,EAC9C,OACGA,EAAQ,eACN,QACL,EAAE,aAAa,CAAC,CAClB,CAAC,EAED,KAAK,gDAAiD,IAAM,CAE1D,MAAMA,EAAU,IAAIF,EAAiB,CAAE,IAAAC,EAAK,UAAW,EAAG,CAAC,EACrDE,EAAgB,CAAC,EAGvBD,EAAQ,kBAAkBC,CAAa,EAAE,MAAM,EAG/C,OAAOD,EAAQ,cAAiB,EAAE,KAAKC,CAAa,CACtD,CAAC,CACH,CAAC",
-  "names": ["SignerEthBuilder", "dmk", "builder", "contextModule"]
+  "sourcesContent": ["import { type ContextModule } from \"@ledgerhq/context-module\";\nimport { type DeviceManagementKit } from \"@ledgerhq/device-management-kit\";\n\nimport { SignerEthBuilder } from \"@api/SignerEthBuilder\";\nimport { DefaultSignerEth } from \"@internal/DefaultSignerEth\";\nimport { externalTypes } from \"@internal/externalTypes\";\n\ndescribe(\"SignerEthBuilder\", () => {\n  const dmk: DeviceManagementKit = {} as DeviceManagementKit;\n  const defaultConstructorArgs = { dmk, sessionId: \"\", originToken: \"test\" };\n\n  test(\"should be an instance of SignerEth\", () => {\n    // GIVEN\n    const builder = new SignerEthBuilder(defaultConstructorArgs);\n\n    // WHEN\n    builder.build();\n\n    // THEN\n    expect(builder).toBeInstanceOf(SignerEthBuilder);\n  });\n\n  test(\"should instanciate with default context module\", () => {\n    // GIVEN\n    const builder = new SignerEthBuilder(defaultConstructorArgs);\n\n    // WHEN\n    const signer = builder.build();\n    const contextModule = signer[\"_container\"].get<ContextModule>(\n      externalTypes.ContextModule,\n    );\n\n    // THEN\n    expect(signer).toBeInstanceOf(DefaultSignerEth);\n    expect(contextModule).toBeDefined();\n    // @ts-expect-error - private property\n    expect(contextModule._loaders).toHaveLength(6);\n    // @ts-expect-error - private property\n    expect(contextModule._typedDataLoader).toBeDefined();\n    // @ts-expect-error - private property\n    expect(contextModule._web3CheckLoader).toBeDefined();\n  });\n\n  test(\"should instanciate with custom context module\", () => {\n    // GIVEN\n    const builder = new SignerEthBuilder(defaultConstructorArgs);\n    const contextModule = {} as ContextModule;\n\n    // WHEN\n    const signer = builder.withContextModule(contextModule).build();\n\n    // THEN\n    expect(signer).toBeInstanceOf(DefaultSignerEth);\n    expect(\n      signer[\"_container\"].get<ContextModule>(externalTypes.ContextModule),\n    ).toBe(contextModule);\n  });\n});\n"],
+  "mappings": "AAGA,OAAS,oBAAAA,MAAwB,wBACjC,OAAS,oBAAAC,MAAwB,6BACjC,OAAS,iBAAAC,MAAqB,0BAE9B,SAAS,mBAAoB,IAAM,CAEjC,MAAMC,EAAyB,CAAE,IADA,CAAC,EACI,UAAW,GAAI,YAAa,MAAO,EAEzE,KAAK,qCAAsC,IAAM,CAE/C,MAAMC,EAAU,IAAIJ,EAAiBG,CAAsB,EAG3DC,EAAQ,MAAM,EAGd,OAAOA,CAAO,EAAE,eAAeJ,CAAgB,CACjD,CAAC,EAED,KAAK,iDAAkD,IAAM,CAK3D,MAAMK,EAHU,IAAIL,EAAiBG,CAAsB,EAGpC,MAAM,EACvBG,EAAgBD,EAAO,WAAc,IACzCH,EAAc,aAChB,EAGA,OAAOG,CAAM,EAAE,eAAeJ,CAAgB,EAC9C,OAAOK,CAAa,EAAE,YAAY,EAElC,OAAOA,EAAc,QAAQ,EAAE,aAAa,CAAC,EAE7C,OAAOA,EAAc,gBAAgB,EAAE,YAAY,EAEnD,OAAOA,EAAc,gBAAgB,EAAE,YAAY,CACrD,CAAC,EAED,KAAK,gDAAiD,IAAM,CAE1D,MAAMF,EAAU,IAAIJ,EAAiBG,CAAsB,EACrDG,EAAgB,CAAC,EAGjBD,EAASD,EAAQ,kBAAkBE,CAAa,EAAE,MAAM,EAG9D,OAAOD,CAAM,EAAE,eAAeJ,CAAgB,EAC9C,OACEI,EAAO,WAAc,IAAmBH,EAAc,aAAa,CACrE,EAAE,KAAKI,CAAa,CACtB,CAAC,CACH,CAAC",
+  "names": ["SignerEthBuilder", "DefaultSignerEth", "externalTypes", "defaultConstructorArgs", "builder", "signer", "contextModule"]
 }

package/lib/esm/api/app-binder/GetConfigCommandTypes.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ //# sourceMappingURL=GetConfigCommandTypes.js.map

package/lib/esm/api/app-binder/GetConfigCommandTypes.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/lib/esm/api/app-binder/SignTransactionDeviceActionTypes.js CHANGED Viewed

	@@ -1 +1,2 @@
1	+ var r=(e=>(e.OPEN_APP="signer.eth.steps.openApp",e.GET_APP_CONFIG="signer.eth.steps.getAppConfig",e.WEB3_CHECKS_OPT_IN="signer.eth.steps.web3ChecksOptIn",e.BUILD_CONTEXT="signer.eth.steps.buildContext",e.PROVIDE_CONTEXT="signer.eth.steps.provideContext",e.PROVIDE_GENERIC_CONTEXT="signer.eth.steps.provideGenericContext",e.SIGN_TRANSACTION="signer.eth.steps.signTransaction",e))(r\|\|{});export{r as SignTransactionDAStep};
1 2	//# sourceMappingURL=SignTransactionDeviceActionTypes.js.map

package/lib/esm/api/app-binder/SignTransactionDeviceActionTypes.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
+  "sources": ["../../../../src/api/app-binder/SignTransactionDeviceActionTypes.ts"],
+  "sourcesContent": ["import {\n  type ClearSignContextSuccess,\n  type ClearSignContextType,\n  type ContextModule,\n} from \"@ledgerhq/context-module\";\nimport {\n  type CommandErrorResult,\n  type DeviceActionState,\n  type ExecuteDeviceActionReturnType,\n  type OpenAppDAError,\n  type OpenAppDARequiredInteraction,\n  type UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type GetConfigCommandResponse } from \"@api/app-binder/GetConfigCommandTypes\";\nimport { type Signature } from \"@api/model/Signature\";\nimport { type TransactionOptions } from \"@api/model/TransactionOptions\";\nimport { type TransactionType } from \"@api/model/TransactionType\";\nimport { type EthErrorCodes } from \"@internal/app-binder/command/utils/ethAppErrors\";\nimport { type GenericContext } from \"@internal/app-binder/task/ProvideTransactionGenericContextTask\";\nimport { type TransactionMapperService } from \"@internal/transaction/service/mapper/TransactionMapperService\";\nimport { type TransactionParserService } from \"@internal/transaction/service/parser/TransactionParserService\";\n\nexport enum SignTransactionDAStep {\n  OPEN_APP = \"signer.eth.steps.openApp\",\n  GET_APP_CONFIG = \"signer.eth.steps.getAppConfig\",\n  WEB3_CHECKS_OPT_IN = \"signer.eth.steps.web3ChecksOptIn\",\n  BUILD_CONTEXT = \"signer.eth.steps.buildContext\",\n  PROVIDE_CONTEXT = \"signer.eth.steps.provideContext\",\n  PROVIDE_GENERIC_CONTEXT = \"signer.eth.steps.provideGenericContext\",\n  SIGN_TRANSACTION = \"signer.eth.steps.signTransaction\",\n}\n\nexport type SignTransactionDAOutput = Signature;\n\nexport type SignTransactionDAInput = {\n  readonly derivationPath: string;\n  readonly transaction: Uint8Array;\n  readonly mapper: TransactionMapperService;\n  readonly parser: TransactionParserService;\n  readonly contextModule: ContextModule;\n  readonly options: TransactionOptions;\n};\n\nexport type SignTransactionDAError =\n  | OpenAppDAError\n  | CommandErrorResult<EthErrorCodes>[\"error\"];\n\ntype SignTransactionDARequiredInteraction =\n  | OpenAppDARequiredInteraction\n  | UserInteractionRequired.Web3ChecksOptIn\n  | UserInteractionRequired.SignTransaction;\n\nexport type SignTransactionDAIntermediateValue = {\n  requiredUserInteraction: SignTransactionDARequiredInteraction;\n  step: SignTransactionDAStep;\n};\n\nexport type SignTransactionDAState = DeviceActionState<\n  SignTransactionDAOutput,\n  SignTransactionDAError,\n  SignTransactionDAIntermediateValue\n>;\n\nexport type SignTransactionDAInternalState = {\n  readonly error: SignTransactionDAError | null;\n  readonly appConfig: GetConfigCommandResponse | null;\n  readonly clearSignContexts: ClearSignContextSuccess[] | GenericContext | null;\n  readonly web3Check: ClearSignContextSuccess<ClearSignContextType.WEB3_CHECK> | null;\n  readonly serializedTransaction: Uint8Array | null;\n  readonly chainId: number | null;\n  readonly transactionType: TransactionType | null;\n  readonly isLegacy: boolean;\n  readonly signature: Signature | null;\n};\n\nexport type SignTransactionDAReturnType = ExecuteDeviceActionReturnType<\n  SignTransactionDAOutput,\n  SignTransactionDAError,\n  SignTransactionDAIntermediateValue\n>;\n"],
+  "mappings": "AAuBO,IAAKA,OACVA,EAAA,SAAW,2BACXA,EAAA,eAAiB,gCACjBA,EAAA,mBAAqB,mCACrBA,EAAA,cAAgB,gCAChBA,EAAA,gBAAkB,kCAClBA,EAAA,wBAA0B,yCAC1BA,EAAA,iBAAmB,mCAPTA,OAAA",
+  "names": ["SignTransactionDAStep"]
 }

package/lib/esm/api/app-binder/SignTypedDataDeviceActionTypes.js CHANGED Viewed

	@@ -1 +1,2 @@
1	+ var t=(e=>(e.OPEN_APP="signer.eth.steps.openApp",e.GET_APP_CONFIG="signer.eth.steps.getAppConfig",e.WEB3_CHECKS_OPT_IN="signer.eth.steps.web3ChecksOptIn",e.BUILD_CONTEXT="signer.eth.steps.buildContext",e.PROVIDE_CONTEXT="signer.eth.steps.provideContext",e.PROVIDE_GENERIC_CONTEXT="signer.eth.steps.provideGenericContext",e.SIGN_TYPED_DATA="signer.eth.steps.signTypedData",e.SIGN_TYPED_DATA_LEGACY="signer.eth.steps.signTypedDataLegacy",e))(t\|\|{});export{t as SignTypedDataDAStateStep};
1 2	//# sourceMappingURL=SignTypedDataDeviceActionTypes.js.map

package/lib/esm/api/app-binder/SignTypedDataDeviceActionTypes.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
+  "sources": ["../../../../src/api/app-binder/SignTypedDataDeviceActionTypes.ts"],
+  "sourcesContent": ["import { type ContextModule } from \"@ledgerhq/context-module\";\nimport {\n  type CommandErrorResult,\n  type DeviceActionState,\n  type ExecuteDeviceActionReturnType,\n  type OpenAppDAError,\n  type OpenAppDARequiredInteraction,\n  type UserInteractionRequired,\n} from \"@ledgerhq/device-management-kit\";\n\nimport { type GetConfigCommandResponse } from \"@api/app-binder/GetConfigCommandTypes\";\nimport { type Signature } from \"@api/model/Signature\";\nimport { type TypedData } from \"@api/model/TypedData\";\nimport { type EthErrorCodes } from \"@internal/app-binder/command/utils/ethAppErrors\";\nimport type { ProvideEIP712ContextTaskArgs } from \"@internal/app-binder/task/ProvideEIP712ContextTask\";\nimport { type TypedDataParserService } from \"@internal/typed-data/service/TypedDataParserService\";\n\nexport enum SignTypedDataDAStateStep {\n  OPEN_APP = \"signer.eth.steps.openApp\",\n  GET_APP_CONFIG = \"signer.eth.steps.getAppConfig\",\n  WEB3_CHECKS_OPT_IN = \"signer.eth.steps.web3ChecksOptIn\",\n  BUILD_CONTEXT = \"signer.eth.steps.buildContext\",\n  PROVIDE_CONTEXT = \"signer.eth.steps.provideContext\",\n  PROVIDE_GENERIC_CONTEXT = \"signer.eth.steps.provideGenericContext\",\n  SIGN_TYPED_DATA = \"signer.eth.steps.signTypedData\",\n  SIGN_TYPED_DATA_LEGACY = \"signer.eth.steps.signTypedDataLegacy\",\n}\n\nexport type SignTypedDataDAOutput = Signature;\n\nexport type SignTypedDataDAInput = {\n  readonly derivationPath: string;\n  readonly data: TypedData;\n  readonly parser: TypedDataParserService;\n  readonly contextModule: ContextModule;\n};\n\nexport type SignTypedDataDAError =\n  | OpenAppDAError\n  | CommandErrorResult<EthErrorCodes>[\"error\"];\n\ntype SignTypedDataDARequiredInteraction =\n  | OpenAppDARequiredInteraction\n  | UserInteractionRequired.Web3ChecksOptIn\n  | UserInteractionRequired.SignTypedData;\n\nexport type SignTypedDataDAIntermediateValue = {\n  requiredUserInteraction: SignTypedDataDARequiredInteraction;\n  step: SignTypedDataDAStateStep;\n};\n\nexport type SignTypedDataDAState = DeviceActionState<\n  SignTypedDataDAOutput,\n  SignTypedDataDAError,\n  SignTypedDataDAIntermediateValue\n>;\n\nexport type SignTypedDataDAInternalState = {\n  readonly error: SignTypedDataDAError | null;\n  readonly appConfig: GetConfigCommandResponse | null;\n  readonly typedDataContext: ProvideEIP712ContextTaskArgs | null;\n  readonly signature: Signature | null;\n};\n\nexport type SignTypedDataDAReturnType = ExecuteDeviceActionReturnType<\n  SignTypedDataDAOutput,\n  SignTypedDataDAError,\n  SignTypedDataDAIntermediateValue\n>;\n"],
+  "mappings": "AAiBO,IAAKA,OACVA,EAAA,SAAW,2BACXA,EAAA,eAAiB,gCACjBA,EAAA,mBAAqB,mCACrBA,EAAA,cAAgB,gCAChBA,EAAA,gBAAkB,kCAClBA,EAAA,wBAA0B,yCAC1BA,EAAA,gBAAkB,iCAClBA,EAAA,uBAAyB,uCARfA,OAAA",
+  "names": ["SignTypedDataDAStateStep"]
 }

package/lib/esm/api/index.js CHANGED Viewed

@@ -1,2 +1,2 @@
-export*from"./app-binder/GetAddressDeviceActionTypes";export*from"./model/Address";export*from"./model/AddressOptions";export*from"./model/Signature";export*from"./model/TransactionOptions";export*from"./model/TransactionType";export*from"./model/TypedData";export*from"./SignerEth";export*from"./SignerEthBuilder";
+export*from"./app-binder/GetAddressDeviceActionTypes";import{SignTransactionDAStep as a}from"./app-binder/SignTransactionDeviceActionTypes";import{SignTypedDataDAStateStep as n}from"./app-binder/SignTypedDataDeviceActionTypes";export*from"./model/Address";export*from"./model/AddressOptions";export*from"./model/Signature";export*from"./model/TransactionOptions";export*from"./model/TransactionType";export*from"./model/TypedData";export*from"./SignerEth";export*from"./SignerEthBuilder";export{a as SignTransactionDAStep,n as SignTypedDataDAStateStep};
 //# sourceMappingURL=index.js.map

package/lib/esm/api/index.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/api/index.ts"],
-  "sourcesContent": ["export * from \"@api/app-binder/GetAddressDeviceActionTypes\";\nexport type {\n  SignPersonalMessageDAError,\n  SignPersonalMessageDAInput,\n  SignPersonalMessageDAIntermediateValue,\n  SignPersonalMessageDAOutput,\n  SignPersonalMessageDAState,\n} from \"@api/app-binder/SignPersonalMessageDeviceActionTypes\";\nexport type {\n  SignTransactionDAError,\n  SignTransactionDAInput,\n  SignTransactionDAIntermediateValue,\n  SignTransactionDAOutput,\n  SignTransactionDAState,\n} from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nexport {\n  type SignTypedDataDAError,\n  type SignTypedDataDAInput,\n  type SignTypedDataDAIntermediateValue,\n  type SignTypedDataDAOutput,\n  type SignTypedDataDAState,\n} from \"@api/app-binder/SignTypedDataDeviceActionTypes\";\nexport * from \"@api/model/Address\";\nexport * from \"@api/model/AddressOptions\";\nexport * from \"@api/model/Signature\";\nexport * from \"@api/model/TransactionOptions\";\nexport * from \"@api/model/TransactionType\";\nexport * from \"@api/model/TypedData\";\nexport * from \"@api/SignerEth\";\nexport * from \"@api/SignerEthBuilder\";\n"],
-  "mappings": "AAAA,WAAc,8CAsBd,WAAc,qBACd,WAAc,4BACd,WAAc,uBACd,WAAc,gCACd,WAAc,6BACd,WAAc,uBACd,WAAc,iBACd,WAAc",
-  "names": []
+  "sourcesContent": ["export * from \"@api/app-binder/GetAddressDeviceActionTypes\";\nexport type {\n  SignPersonalMessageDAError,\n  SignPersonalMessageDAIntermediateValue,\n  SignPersonalMessageDAOutput,\n} from \"@api/app-binder/SignPersonalMessageDeviceActionTypes\";\nexport {\n  type SignTransactionDAError,\n  type SignTransactionDAInput,\n  type SignTransactionDAIntermediateValue,\n  type SignTransactionDAOutput,\n  type SignTransactionDAState,\n  SignTransactionDAStep,\n} from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nexport {\n  type SignTypedDataDAError,\n  type SignTypedDataDAInput,\n  type SignTypedDataDAIntermediateValue,\n  type SignTypedDataDAOutput,\n  type SignTypedDataDAState,\n  SignTypedDataDAStateStep,\n} from \"@api/app-binder/SignTypedDataDeviceActionTypes\";\nexport * from \"@api/model/Address\";\nexport * from \"@api/model/AddressOptions\";\nexport * from \"@api/model/Signature\";\nexport * from \"@api/model/TransactionOptions\";\nexport * from \"@api/model/TransactionType\";\nexport * from \"@api/model/TypedData\";\nexport * from \"@api/SignerEth\";\nexport * from \"@api/SignerEthBuilder\";\n"],
+  "mappings": "AAAA,WAAc,8CAMd,OAME,yBAAAA,MACK,mDACP,OAME,4BAAAC,MACK,iDACP,WAAc,qBACd,WAAc,4BACd,WAAc,uBACd,WAAc,gCACd,WAAc,6BACd,WAAc,uBACd,WAAc,iBACd,WAAc",
+  "names": ["SignTransactionDAStep", "SignTypedDataDAStateStep"]
 }

package/lib/esm/internal/DefaultSignerEth.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{addressTypes as i}from"./address/di/addressTypes";import{messageTypes as o}from"./message/di/messageTypes";import{transactionTypes as r}from"./transaction/di/transactionTypes";import{typedDataTypes as d}from"./typed-data/di/typedDataTypes";import{DefaultSignerEth as c}from"./DefaultSignerEth";describe("DefaultSignerEth",()=>{let a;const n={get:jest.fn(e=>({execute:jest.fn(()=>e===r.SignTransactionUseCase?"transaction-result":e===o.SignMessageUseCase?"message-result":e===d.SignTypedDataUseCase?"typed-data-result":e===i.GetAddressUseCase?"address-result":"undefined-result")}))};beforeEach(()=>{jest.clearAllMocks();const e={},s="",t={};a=new c({dmk:e,sessionId:s,contextModule:t}),a._container=n}),describe("signTransaction",()=>{it("should sign a transaction",async()=>{const e="derivationPath",s=new Uint8Array(0),t=await a.signTransaction(e,s);expect(t).toBeDefined(),expect(t).toBe("transaction-result"),expect(n.get).toHaveBeenCalledWith(r.SignTransactionUseCase)})}),describe("signMessage",()=>{it("should sign a message",async()=>{const t=await a.signMessage("derivationPath","message");expect(t).toBeDefined(),expect(t).toBe("message-result"),expect(n.get).toHaveBeenCalledWith(o.SignMessageUseCase)})}),describe("signTypedData",()=>{it("should sign typed data",async()=>{const e="derivationPath",s={},t=await a.signTypedData(e,s);expect(t).toBeDefined(),expect(t).toBe("typed-data-result"),expect(n.get).toHaveBeenCalledWith(d.SignTypedDataUseCase)})}),describe("getAddress",()=>{it("should get an address",async()=>{const s=await a.getAddress("derivationPath");expect(s).toBeDefined(),expect(s).toBe("address-result"),expect(n.get).toHaveBeenCalledWith(i.GetAddressUseCase)})})});
+import{addressTypes as i}from"./address/di/addressTypes";import{messageTypes as o}from"./message/di/messageTypes";import{transactionTypes as r}from"./transaction/di/transactionTypes";import{typedDataTypes as d}from"./typed-data/di/typedDataTypes";import{DefaultSignerEth as c}from"./DefaultSignerEth";describe("DefaultSignerEth",()=>{let a;const n={get:vi.fn(e=>({execute:vi.fn(()=>e===r.SignTransactionUseCase?"transaction-result":e===o.SignMessageUseCase?"message-result":e===d.SignTypedDataUseCase?"typed-data-result":e===i.GetAddressUseCase?"address-result":"undefined-result")}))};beforeEach(()=>{vi.clearAllMocks();const e={},s="",t={};a=new c({dmk:e,sessionId:s,contextModule:t}),a._container=n}),describe("signTransaction",()=>{it("should sign a transaction",async()=>{const e="derivationPath",s=new Uint8Array(0),t=await a.signTransaction(e,s);expect(t).toBeDefined(),expect(t).toBe("transaction-result"),expect(n.get).toHaveBeenCalledWith(r.SignTransactionUseCase)})}),describe("signMessage",()=>{it("should sign a message",async()=>{const t=await a.signMessage("derivationPath","message");expect(t).toBeDefined(),expect(t).toBe("message-result"),expect(n.get).toHaveBeenCalledWith(o.SignMessageUseCase)})}),describe("signTypedData",()=>{it("should sign typed data",async()=>{const e="derivationPath",s={},t=await a.signTypedData(e,s);expect(t).toBeDefined(),expect(t).toBe("typed-data-result"),expect(n.get).toHaveBeenCalledWith(d.SignTypedDataUseCase)})}),describe("getAddress",()=>{it("should get an address",async()=>{const s=await a.getAddress("derivationPath");expect(s).toBeDefined(),expect(s).toBe("address-result"),expect(n.get).toHaveBeenCalledWith(i.GetAddressUseCase)})})});
 //# sourceMappingURL=DefaultSignerEth.test.js.map

package/lib/esm/internal/DefaultSignerEth.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/DefaultSignerEth.test.ts"],
-  "sourcesContent": ["import { type ContextModule } from \"@ledgerhq/context-module\";\nimport {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\n\nimport { addressTypes } from \"./address/di/addressTypes\";\nimport { messageTypes } from \"./message/di/messageTypes\";\nimport { transactionTypes } from \"./transaction/di/transactionTypes\";\nimport { typedDataTypes } from \"./typed-data/di/typedDataTypes\";\nimport { type TypedData } from \"..\";\nimport { DefaultSignerEth } from \"./DefaultSignerEth\";\n\ndescribe(\"DefaultSignerEth\", () => {\n  let signer: DefaultSignerEth;\n  const mock: Container = {\n    get: jest.fn((id: symbol) => ({\n      execute: jest.fn(() => {\n        if (id === transactionTypes.SignTransactionUseCase) {\n          return \"transaction-result\";\n        } else if (id === messageTypes.SignMessageUseCase) {\n          return \"message-result\";\n        } else if (id === typedDataTypes.SignTypedDataUseCase) {\n          return \"typed-data-result\";\n        } else if (id === addressTypes.GetAddressUseCase) {\n          return \"address-result\";\n        }\n\n        return \"undefined-result\";\n      }),\n    })),\n  } as unknown as Container;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n\n    const dmk = {} as DeviceManagementKit;\n    const sessionId = \"\" as DeviceSessionId;\n    const contextModule = {} as ContextModule;\n    signer = new DefaultSignerEth({ dmk, sessionId, contextModule });\n    signer[\"_container\"] = mock as unknown as Container;\n  });\n\n  describe(\"signTransaction\", () => {\n    it(\"should sign a transaction\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const transaction = new Uint8Array(0);\n\n      // WHEN\n      const result = await signer.signTransaction(derivationPath, transaction);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"transaction-result\");\n      expect(mock.get).toHaveBeenCalledWith(\n        transactionTypes.SignTransactionUseCase,\n      );\n    });\n  });\n\n  describe(\"signMessage\", () => {\n    it(\"should sign a message\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const message = \"message\";\n\n      // WHEN\n      const result = await signer.signMessage(derivationPath, message);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"message-result\");\n      expect(mock.get).toHaveBeenCalledWith(messageTypes.SignMessageUseCase);\n    });\n  });\n\n  describe(\"signTypedData\", () => {\n    it(\"should sign typed data\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const typedData = {} as TypedData;\n\n      // WHEN\n      const result = await signer.signTypedData(derivationPath, typedData);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"typed-data-result\");\n      expect(mock.get).toHaveBeenCalledWith(\n        typedDataTypes.SignTypedDataUseCase,\n      );\n    });\n  });\n\n  describe(\"getAddress\", () => {\n    it(\"should get an address\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n\n      // WHEN\n      const result = await signer.getAddress(derivationPath);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"address-result\");\n      expect(mock.get).toHaveBeenCalledWith(addressTypes.GetAddressUseCase);\n    });\n  });\n});\n"],
-  "mappings": "AAOA,OAAS,gBAAAA,MAAoB,4BAC7B,OAAS,gBAAAC,MAAoB,4BAC7B,OAAS,oBAAAC,MAAwB,oCACjC,OAAS,kBAAAC,MAAsB,iCAE/B,OAAS,oBAAAC,MAAwB,qBAEjC,SAAS,mBAAoB,IAAM,CACjC,IAAIC,EACJ,MAAMC,EAAkB,CACtB,IAAK,KAAK,GAAIC,IAAgB,CAC5B,QAAS,KAAK,GAAG,IACXA,IAAOL,EAAiB,uBACnB,qBACEK,IAAON,EAAa,mBACtB,iBACEM,IAAOJ,EAAe,qBACxB,oBACEI,IAAOP,EAAa,kBACtB,iBAGF,kBACR,CACH,EAAE,CACJ,EAEA,WAAW,IAAM,CACf,KAAK,cAAc,EAEnB,MAAMQ,EAAM,CAAC,EACPC,EAAY,GACZC,EAAgB,CAAC,EACvBL,EAAS,IAAID,EAAiB,CAAE,IAAAI,EAAK,UAAAC,EAAW,cAAAC,CAAc,CAAC,EAC/DL,EAAO,WAAgBC,CACzB,CAAC,EAED,SAAS,kBAAmB,IAAM,CAChC,GAAG,4BAA6B,SAAY,CAE1C,MAAMK,EAAiB,iBACjBC,EAAc,IAAI,WAAW,CAAC,EAG9BC,EAAS,MAAMR,EAAO,gBAAgBM,EAAgBC,CAAW,EAGvE,OAAOC,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,oBAAoB,EACxC,OAAOP,EAAK,GAAG,EAAE,qBACfJ,EAAiB,sBACnB,CACF,CAAC,CACH,CAAC,EAED,SAAS,cAAe,IAAM,CAC5B,GAAG,wBAAyB,SAAY,CAMtC,MAAMW,EAAS,MAAMR,EAAO,YAJL,iBACP,SAG+C,EAG/D,OAAOQ,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,gBAAgB,EACpC,OAAOP,EAAK,GAAG,EAAE,qBAAqBL,EAAa,kBAAkB,CACvE,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,yBAA0B,SAAY,CAEvC,MAAMU,EAAiB,iBACjBG,EAAY,CAAC,EAGbD,EAAS,MAAMR,EAAO,cAAcM,EAAgBG,CAAS,EAGnE,OAAOD,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,mBAAmB,EACvC,OAAOP,EAAK,GAAG,EAAE,qBACfH,EAAe,oBACjB,CACF,CAAC,CACH,CAAC,EAED,SAAS,aAAc,IAAM,CAC3B,GAAG,wBAAyB,SAAY,CAKtC,MAAMU,EAAS,MAAMR,EAAO,WAHL,gBAG8B,EAGrD,OAAOQ,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,gBAAgB,EACpC,OAAOP,EAAK,GAAG,EAAE,qBAAqBN,EAAa,iBAAiB,CACtE,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { type ContextModule } from \"@ledgerhq/context-module\";\nimport {\n  type DeviceManagementKit,\n  type DeviceSessionId,\n} from \"@ledgerhq/device-management-kit\";\nimport { type Container } from \"inversify\";\n\nimport { addressTypes } from \"./address/di/addressTypes\";\nimport { messageTypes } from \"./message/di/messageTypes\";\nimport { transactionTypes } from \"./transaction/di/transactionTypes\";\nimport { typedDataTypes } from \"./typed-data/di/typedDataTypes\";\nimport { type TypedData } from \"..\";\nimport { DefaultSignerEth } from \"./DefaultSignerEth\";\n\ndescribe(\"DefaultSignerEth\", () => {\n  let signer: DefaultSignerEth;\n  const mock: Container = {\n    get: vi.fn((id: symbol) => ({\n      execute: vi.fn(() => {\n        if (id === transactionTypes.SignTransactionUseCase) {\n          return \"transaction-result\";\n        } else if (id === messageTypes.SignMessageUseCase) {\n          return \"message-result\";\n        } else if (id === typedDataTypes.SignTypedDataUseCase) {\n          return \"typed-data-result\";\n        } else if (id === addressTypes.GetAddressUseCase) {\n          return \"address-result\";\n        }\n\n        return \"undefined-result\";\n      }),\n    })),\n  } as unknown as Container;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n\n    const dmk = {} as DeviceManagementKit;\n    const sessionId = \"\" as DeviceSessionId;\n    const contextModule = {} as ContextModule;\n    signer = new DefaultSignerEth({ dmk, sessionId, contextModule });\n    signer[\"_container\"] = mock as unknown as Container;\n  });\n\n  describe(\"signTransaction\", () => {\n    it(\"should sign a transaction\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const transaction = new Uint8Array(0);\n\n      // WHEN\n      const result = await signer.signTransaction(derivationPath, transaction);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"transaction-result\");\n      expect(mock.get).toHaveBeenCalledWith(\n        transactionTypes.SignTransactionUseCase,\n      );\n    });\n  });\n\n  describe(\"signMessage\", () => {\n    it(\"should sign a message\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const message = \"message\";\n\n      // WHEN\n      const result = await signer.signMessage(derivationPath, message);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"message-result\");\n      expect(mock.get).toHaveBeenCalledWith(messageTypes.SignMessageUseCase);\n    });\n  });\n\n  describe(\"signTypedData\", () => {\n    it(\"should sign typed data\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const typedData = {} as TypedData;\n\n      // WHEN\n      const result = await signer.signTypedData(derivationPath, typedData);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"typed-data-result\");\n      expect(mock.get).toHaveBeenCalledWith(\n        typedDataTypes.SignTypedDataUseCase,\n      );\n    });\n  });\n\n  describe(\"getAddress\", () => {\n    it(\"should get an address\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n\n      // WHEN\n      const result = await signer.getAddress(derivationPath);\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"address-result\");\n      expect(mock.get).toHaveBeenCalledWith(addressTypes.GetAddressUseCase);\n    });\n  });\n});\n"],
+  "mappings": "AAOA,OAAS,gBAAAA,MAAoB,4BAC7B,OAAS,gBAAAC,MAAoB,4BAC7B,OAAS,oBAAAC,MAAwB,oCACjC,OAAS,kBAAAC,MAAsB,iCAE/B,OAAS,oBAAAC,MAAwB,qBAEjC,SAAS,mBAAoB,IAAM,CACjC,IAAIC,EACJ,MAAMC,EAAkB,CACtB,IAAK,GAAG,GAAIC,IAAgB,CAC1B,QAAS,GAAG,GAAG,IACTA,IAAOL,EAAiB,uBACnB,qBACEK,IAAON,EAAa,mBACtB,iBACEM,IAAOJ,EAAe,qBACxB,oBACEI,IAAOP,EAAa,kBACtB,iBAGF,kBACR,CACH,EAAE,CACJ,EAEA,WAAW,IAAM,CACf,GAAG,cAAc,EAEjB,MAAMQ,EAAM,CAAC,EACPC,EAAY,GACZC,EAAgB,CAAC,EACvBL,EAAS,IAAID,EAAiB,CAAE,IAAAI,EAAK,UAAAC,EAAW,cAAAC,CAAc,CAAC,EAC/DL,EAAO,WAAgBC,CACzB,CAAC,EAED,SAAS,kBAAmB,IAAM,CAChC,GAAG,4BAA6B,SAAY,CAE1C,MAAMK,EAAiB,iBACjBC,EAAc,IAAI,WAAW,CAAC,EAG9BC,EAAS,MAAMR,EAAO,gBAAgBM,EAAgBC,CAAW,EAGvE,OAAOC,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,oBAAoB,EACxC,OAAOP,EAAK,GAAG,EAAE,qBACfJ,EAAiB,sBACnB,CACF,CAAC,CACH,CAAC,EAED,SAAS,cAAe,IAAM,CAC5B,GAAG,wBAAyB,SAAY,CAMtC,MAAMW,EAAS,MAAMR,EAAO,YAJL,iBACP,SAG+C,EAG/D,OAAOQ,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,gBAAgB,EACpC,OAAOP,EAAK,GAAG,EAAE,qBAAqBL,EAAa,kBAAkB,CACvE,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,yBAA0B,SAAY,CAEvC,MAAMU,EAAiB,iBACjBG,EAAY,CAAC,EAGbD,EAAS,MAAMR,EAAO,cAAcM,EAAgBG,CAAS,EAGnE,OAAOD,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,mBAAmB,EACvC,OAAOP,EAAK,GAAG,EAAE,qBACfH,EAAe,oBACjB,CACF,CAAC,CACH,CAAC,EAED,SAAS,aAAc,IAAM,CAC3B,GAAG,wBAAyB,SAAY,CAKtC,MAAMU,EAAS,MAAMR,EAAO,WAHL,gBAG8B,EAGrD,OAAOQ,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,gBAAgB,EACpC,OAAOP,EAAK,GAAG,EAAE,qBAAqBN,EAAa,iBAAiB,CACtE,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["addressTypes", "messageTypes", "transactionTypes", "typedDataTypes", "DefaultSignerEth", "signer", "mock", "id", "dmk", "sessionId", "contextModule", "derivationPath", "transaction", "result", "typedData"]
 }

package/lib/esm/internal/address/use-case/GetAddressUseCase.test.js CHANGED Viewed

@@ -1,2 +1,2 @@
-import{GetAddressUseCase as r}from"./GetAddressUseCase";describe("GetAddressUseCase",()=>{it("should call getAddress on appBinder with the correct arguments",()=>{const e="m/44'/60'/0'/0/0",s={checkOnDevice:!0,returnChainCode:!0},t=jest.fn(),n={getAddress:t};new r(n).execute(e,s),expect(t).toHaveBeenCalledWith({derivationPath:e,checkOnDevice:!0,returnChainCode:!0})})});
+import{GetAddressUseCase as r}from"./GetAddressUseCase";describe("GetAddressUseCase",()=>{it("should call getAddress on appBinder with the correct arguments",()=>{const e="m/44'/60'/0'/0/0",s={checkOnDevice:!0,returnChainCode:!0},t=vi.fn(),n={getAddress:t};new r(n).execute(e,s),expect(t).toHaveBeenCalledWith({derivationPath:e,checkOnDevice:!0,returnChainCode:!0})})});
 //# sourceMappingURL=GetAddressUseCase.test.js.map

package/lib/esm/internal/address/use-case/GetAddressUseCase.test.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/address/use-case/GetAddressUseCase.test.ts"],
-  "sourcesContent": ["import { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\nimport { GetAddressUseCase } from \"./GetAddressUseCase\";\n\ndescribe(\"GetAddressUseCase\", () => {\n  it(\"should call getAddress on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"m/44'/60'/0'/0/0\";\n    const checkOnDevice = true;\n    const returnChainCode = true;\n    const options = {\n      checkOnDevice,\n      returnChainCode,\n    };\n    const getAddress = jest.fn();\n    const appBinder = {\n      getAddress,\n    };\n    const getAddressUseCase = new GetAddressUseCase(\n      appBinder as unknown as EthAppBinder,\n    );\n\n    // When\n    getAddressUseCase.execute(derivationPath, options);\n\n    // Then\n    expect(getAddress).toHaveBeenCalledWith({\n      derivationPath,\n      checkOnDevice,\n      returnChainCode,\n    });\n  });\n});\n"],
-  "mappings": "AAEA,OAAS,qBAAAA,MAAyB,sBAElC,SAAS,oBAAqB,IAAM,CAClC,GAAG,iEAAkE,IAAM,CAEzE,MAAMC,EAAiB,mBAGjBC,EAAU,CACd,iBACA,kBACF,EACMC,EAAa,KAAK,GAAG,EACrBC,EAAY,CAChB,WAAAD,CACF,EAC0B,IAAIH,EAC5BI,CACF,EAGkB,QAAQH,EAAgBC,CAAO,EAGjD,OAAOC,CAAU,EAAE,qBAAqB,CACtC,eAAAF,EACA,iBACA,kBACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { type EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\nimport { GetAddressUseCase } from \"./GetAddressUseCase\";\n\ndescribe(\"GetAddressUseCase\", () => {\n  it(\"should call getAddress on appBinder with the correct arguments\", () => {\n    // Given\n    const derivationPath = \"m/44'/60'/0'/0/0\";\n    const checkOnDevice = true;\n    const returnChainCode = true;\n    const options = {\n      checkOnDevice,\n      returnChainCode,\n    };\n    const getAddress = vi.fn();\n    const appBinder = {\n      getAddress,\n    };\n    const getAddressUseCase = new GetAddressUseCase(\n      appBinder as unknown as EthAppBinder,\n    );\n\n    // When\n    getAddressUseCase.execute(derivationPath, options);\n\n    // Then\n    expect(getAddress).toHaveBeenCalledWith({\n      derivationPath,\n      checkOnDevice,\n      returnChainCode,\n    });\n  });\n});\n"],
+  "mappings": "AAEA,OAAS,qBAAAA,MAAyB,sBAElC,SAAS,oBAAqB,IAAM,CAClC,GAAG,iEAAkE,IAAM,CAEzE,MAAMC,EAAiB,mBAGjBC,EAAU,CACd,iBACA,kBACF,EACMC,EAAa,GAAG,GAAG,EACnBC,EAAY,CAChB,WAAAD,CACF,EAC0B,IAAIH,EAC5BI,CACF,EAGkB,QAAQH,EAAgBC,CAAO,EAGjD,OAAOC,CAAU,EAAE,qBAAqB,CACtC,eAAAF,EACA,iBACA,kBACF,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["GetAddressUseCase", "derivationPath", "options", "getAddress", "appBinder"]
 }

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

@@ -1,2 +1,2 @@
-var D=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var d=(o,e,r,i)=>{for(var t=i>1?void 0:i?T(e,r):e,s=o.length-1,c;s>=0;s--)(c=o[s])&&(t=(i?c(e,r,t):c(t))||t);return i&&t&&D(e,r,t),t},n=(o,e)=>(r,i)=>e(r,i,o);import{SendCommandInAppDeviceAction as y}from"@ledgerhq/device-management-kit";import{UserInteractionRequired as v}from"@ledgerhq/device-management-kit";import{inject as a,injectable as A}from"inversify";import{SignTypedDataDeviceAction as h}from"../app-binder/device-action/SignTypedData/SignTypedDataDeviceAction";import{externalTypes as m}from"../externalTypes";import{transactionTypes as u}from"../transaction/di/transactionTypes";import{GetAddressCommand as f}from"./command/GetAddressCommand";import{ETHEREUM_PLUGINS as S}from"./constant/plugins";import{SignPersonalMessageDeviceAction as g}from"./device-action/SignPersonalMessage/SignPersonalMessageDeviceAction";import{SignTransactionDeviceAction as P}from"./device-action/SignTransaction/SignTransactionDeviceAction";let p=class{constructor(e,r,i,t,s){this.dmk=e;this.contextModule=r;this.mapper=i;this.parser=t;this.sessionId=s}getAddress(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new y({input:{command:new f(e),appName:"Ethereum",compatibleAppNames:S,requiredUserInteraction:e.checkOnDevice?v.VerifyAddress:v.None}})})}signPersonalMessage(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new g({input:{derivationPath:e.derivationPath,message:e.message}})})}signTransaction(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new P({input:{derivationPath:e.derivationPath,transaction:e.transaction,mapper:this.mapper,parser:this.parser,contextModule:this.contextModule,options:e.options??{}}})})}signTypedData(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new h({input:{derivationPath:e.derivationPath,data:e.data,parser:e.parser,contextModule:this.contextModule}})})}};p=d([A(),n(0,a(m.Dmk)),n(1,a(m.ContextModule)),n(2,a(u.TransactionMapperService)),n(3,a(u.TransactionParserService)),n(4,a(m.SessionId))],p);export{p as EthAppBinder};
+var y=Object.defineProperty;var D=Object.getOwnPropertyDescriptor;var v=(o,e,t,r)=>{for(var i=r>1?void 0:r?D(e,t):e,s=o.length-1,c;s>=0;s--)(c=o[s])&&(i=(r?c(e,t,i):c(i))||i);return r&&i&&y(e,t,i),i},n=(o,e)=>(t,r)=>e(t,r,o);import{CallTaskInAppDeviceAction as A,SendCommandInAppDeviceAction as S}from"@ledgerhq/device-management-kit";import{UserInteractionRequired as m}from"@ledgerhq/device-management-kit";import{inject as a,injectable as f}from"inversify";import{SignTypedDataDeviceAction as g}from"../app-binder/device-action/SignTypedData/SignTypedDataDeviceAction";import{SendSignPersonalMessageTask as h}from"../app-binder/task/SendSignPersonalMessageTask";import{externalTypes as d}from"../externalTypes";import{transactionTypes as u}from"../transaction/di/transactionTypes";import{GetAddressCommand as l}from"./command/GetAddressCommand";import{ETHEREUM_PLUGINS as T}from"./constant/plugins";import{SignTransactionDeviceAction as M}from"./device-action/SignTransaction/SignTransactionDeviceAction";let p=class{constructor(e,t,r,i,s){this.dmk=e;this.contextModule=t;this.mapper=r;this.parser=i;this.sessionId=s}getAddress(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new S({input:{command:new l(e),appName:"Ethereum",compatibleAppNames:T,requiredUserInteraction:e.checkOnDevice?m.VerifyAddress:m.None}})})}signPersonalMessage(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new A({input:{task:async t=>new h(t,e).run(),appName:"Ethereum",compatibleAppNames:T,requiredUserInteraction:m.SignPersonalMessage}})})}signTransaction(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new M({input:{derivationPath:e.derivationPath,transaction:e.transaction,mapper:this.mapper,parser:this.parser,contextModule:this.contextModule,options:e.options??{}}})})}signTypedData(e){return this.dmk.executeDeviceAction({sessionId:this.sessionId,deviceAction:new g({input:{derivationPath:e.derivationPath,data:e.data,parser:e.parser,contextModule:this.contextModule}})})}};p=v([f(),n(0,a(d.Dmk)),n(1,a(d.ContextModule)),n(2,a(u.TransactionMapperService)),n(3,a(u.TransactionParserService)),n(4,a(d.SessionId))],p);export{p as EthAppBinder};
 //# sourceMappingURL=EthAppBinder.js.map