npm - @ledgerhq/device-signer-kit-ethereum - Versions diffs - 0.0.0-hid-candidate-4-20250528125313 → 0.0.0-invalidFirmwareMetadataError-20251027134207 - Mend

@ledgerhq/device-signer-kit-ethereum 0.0.0-hid-candidate-4-20250528125313 → 0.0.0-invalidFirmwareMetadataError-20251027134207

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 (517) 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(()=>{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)})})});
+"use strict";var o=require("@ledgerhq/context-module"),c=require("@ledgerhq/device-management-kit"),r=require("./TransactionParserService");describe("TransactionParserService",()=>{const l=new r.TransactionParserService,i=(0,c.hexaStringToBuffer)("0x3f32cF0B1DF94157EE1c3876c49BE3732C92a98f"),s=81818275935222000n,n=new c.ByteArrayBuilder().add256BitUIntToData(81818275935222000n).build();beforeEach(()=>{vi.clearAllMocks()}),describe("Container paths",()=>{it("should extract TO of the container",()=>{const a={chainId:1,data:"0x",selector:"0x",to:(0,c.bufferToHexaString)(i),value:s},e=l.extractValue(a,o.ContainerPath.TO);expect(e.isRight()).toStrictEqual(!0),expect(e.unsafeCoerce()).toStrictEqual([i])}),it("should extract VALUE of the container",()=>{const a={chainId:1,data:"0x",selector:"0x",to:(0,c.bufferToHexaString)(i),value:s},e=l.extractValue(a,o.ContainerPath.VALUE);expect(e.isRight()).toStrictEqual(!0),expect(e.unsafeCoerce()).toStrictEqual([n])}),it("Unavailable container fields",()=>{const a={chainId:1,data:"0x",selector:"0x",to:void 0,from:void 0,value:s},e=l.extractValue(a,o.ContainerPath.FROM),t=l.extractValue(a,o.ContainerPath.TO);expect(e.isRight()).toStrictEqual(!1),expect(t.isRight()).toStrictEqual(!1)}),it("invalid transaction format",()=>{const a=(0,c.hexaStringToBuffer)("0xdeadbeef"),e=l.extractValue(a,o.ContainerPath.FROM);expect(e.isRight()).toStrictEqual(!1)})}),describe("Data paths in a calldata with static elements",()=>{const a={chainId:1,data:"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001",selector:"0xcdcd77c",to:(0,c.bufferToHexaString)(i),value:s};it("Extract the first element",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"}],t=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000045")])}),it("Extract the second element",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"STATIC_LEAF"}],t=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001")])}),it("Slice the static leaf",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"STATIC_LEAF"},{type:"SLICE",start:-4}],t=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x00000045")])}),it("Out of bounds",()=>{const e=[{type:"TUPLE",offset:2},{type:"LEAF",leafType:"STATIC_LEAF"}],t=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!1)})}),describe("Data paths in a calldata with dynamic elements",()=>{const a={to:(0,c.bufferToHexaString)(i),value:s,chainId:1,data:"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000",selector:"0x2289b18c"};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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002"),(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.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=l.extractValue(a,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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x6f6e65"),(0,c.hexaStringToBuffer)("0x74776f"),(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x6f6e65"),(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x74")])}),it("Error no leaf",()=>{const e=[{type:"TUPLE",offset:1}],t=l.extractValue(a,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=l.extractValue(a,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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!1)})}),describe("Array of tuples, with bigger itemSize",()=>{const a={chainId:1,data:"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006",selector:"0xcdcd77c",to:(0,c.bufferToHexaString)(i),value:s};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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000001"),(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000003"),(0,c.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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!0),expect(t.unsafeCoerce()).toStrictEqual([(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000002"),(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000004"),(0,c.hexaStringToBuffer)("0x0000000000000000000000000000000000000000000000000000000000000006")])})}),describe("Malformed calldata",()=>{const a={chainId:1,data:"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002",selector:"0x2289b18c",to:(0,c.bufferToHexaString)(i),value:s};it("Dynamic leaf length overflow",()=>{const e=[{type:"TUPLE",offset:1},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!1)}),it("Calldata smaller than dynamic leaf",()=>{const e=[{type:"TUPLE",offset:0},{type:"LEAF",leafType:"DYNAMIC_LEAF"}],t=l.extractValue(a,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=l.extractValue(a,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=l.extractValue(a,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=l.extractValue(a,e);expect(t.isRight()).toStrictEqual(!1)}),it("Empty array",()=>{const e=[],t=l.extractValue(a,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    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"]
+  "sourcesContent": ["import {\n  ContainerPath,\n  type DataPathElement,\n  type TransactionSubset,\n} from \"@ledgerhq/context-module\";\nimport {\n  bufferToHexaString,\n  ByteArrayBuilder,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\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 subset = {\n        chainId: 1,\n        data: \"0x\",\n        selector: \"0x\",\n        to: bufferToHexaString(TO),\n        value: VALUE,\n      };\n\n      // WHEN\n      const value = parser.extractValue(subset, 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\n      const subset = {\n        chainId: 1,\n        data: \"0x\",\n        selector: \"0x\",\n        to: bufferToHexaString(TO),\n        value: VALUE,\n      };\n\n      // WHEN\n      const value = parser.extractValue(subset, 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 subset = {\n        chainId: 1,\n        data: \"0x\",\n        selector: \"0x\",\n        to: undefined,\n        from: undefined,\n        value: VALUE,\n      };\n\n      // WHEN\n      const from = parser.extractValue(subset, ContainerPath.FROM);\n      const to = parser.extractValue(subset, 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(\n        \"0xdeadbeef\",\n      ) as unknown as TransactionSubset;\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 subset = {\n      chainId: 1,\n      data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001\",\n      selector: \"0xcdcd77c\",\n      to: bufferToHexaString(TO),\n      value: VALUE,\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(subset, 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(subset, 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(subset, 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(subset, 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 subset = {\n      to: bufferToHexaString(TO),\n      value: VALUE,\n      chainId: 1,\n      data: \"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000\",\n      selector: \"0x2289b18c\",\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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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(subset, 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 subset = {\n      chainId: 1,\n      data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006\",\n      selector: \"0xcdcd77c\",\n      to: bufferToHexaString(TO),\n      value: VALUE,\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(subset, 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(subset, 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 subset = {\n      chainId: 1,\n      data: \"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002\",\n      selector: \"0x2289b18c\",\n      to: bufferToHexaString(TO),\n      value: VALUE,\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(subset, 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(subset, 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(subset, 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(subset, 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(subset, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Empty array\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [];\n\n      // WHEN\n      const value = parser.extractValue(subset, 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_TransactionParserService", "parser", "TO", "VALUE", "VALUE_BIN", "subset", "value", "from", "to", "transaction", "path"]
 }

package/lib/cjs/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/device-signer-kit-ethereum",
-  "version": "1.4.0",
+  "version": "1.9.0",
   "private": false,
   "license": "Apache-2.0",
   "exports": {
@@ -35,7 +35,7 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@ledgerhq/signer-utils": "workspace:*",
+    "@ledgerhq/signer-utils": "^1.1.0",
     "ethers": "catalog:",
     "inversify": "catalog:",
     "purify-ts": "catalog:",

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

@@ -1,2 +1,2 @@
-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)})});
+import{SignerEthBuilder as o}from"./SignerEthBuilder";import{DefaultSignerEth as s}from"../internal/DefaultSignerEth";import{externalTypes as c}from"../internal/externalTypes";describe("SignerEthBuilder",()=>{const i={dmk:{},sessionId:"",originToken:"test"};test("should be an instance of SignerEth",()=>{const e=new o(i);e.build(),expect(e).toBeInstanceOf(o)}),test("should instanciate with default context module",()=>{const t=new o(i).build(),n=t._container.get(c.ContextModule);expect(t).toBeInstanceOf(s),expect(n).toBeDefined()}),test("should instanciate with custom context module",()=>{const e=new o(i),t={},n=e.withContextModule(t).build();expect(n).toBeInstanceOf(s),expect(n._container.get(c.ContextModule)).toBe(t)})});
 //# 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 { 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",
+  "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  });\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,CACpC,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/SignDelegationAuthorizationTypes.js ADDED Viewed

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

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

@@ -1,2 +1,2 @@
-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.WEB3_CHECKS_OPT_IN_RESULT="signer.eth.steps.web3ChecksOptInResult",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))(t||{});export{t as SignTransactionDAStep};
+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.WEB3_CHECKS_OPT_IN_RESULT="signer.eth.steps.web3ChecksOptInResult",e.PARSE_TRANSACTION="signer.eth.steps.parseTransaction",e.BUILD_CONTEXTS="signer.eth.steps.buildContexts",e.PROVIDE_CONTEXTS="signer.eth.steps.provideContexts",e.SIGN_TRANSACTION="signer.eth.steps.signTransaction",e.BLIND_SIGN_TRANSACTION_FALLBACK="signer.eth.steps.blindSignTransactionFallback",e))(t||{});export{t as SignTransactionDAStep};
 //# sourceMappingURL=SignTransactionDeviceActionTypes.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "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  WEB3_CHECKS_OPT_IN_RESULT = \"signer.eth.steps.web3ChecksOptInResult\",\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  | {\n      requiredUserInteraction: SignTransactionDARequiredInteraction;\n      step: Exclude<\n        SignTransactionDAStep,\n        SignTransactionDAStep.WEB3_CHECKS_OPT_IN_RESULT\n      >;\n    }\n  | {\n      requiredUserInteraction: UserInteractionRequired.None;\n      step: SignTransactionDAStep.WEB3_CHECKS_OPT_IN_RESULT;\n      result: boolean;\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,0BAA4B,yCAC5BA,EAAA,cAAgB,gCAChBA,EAAA,gBAAkB,kCAClBA,EAAA,wBAA0B,yCAC1BA,EAAA,iBAAmB,mCARTA,OAAA",
+  "sourcesContent": ["import {\n  type ContextModule,\n  type TransactionSubset,\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 ClearSigningType } from \"@api/model/ClearSigningType\";\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 ContextWithSubContexts } from \"@internal/app-binder/task/BuildFullContextsTask\";\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  WEB3_CHECKS_OPT_IN_RESULT = \"signer.eth.steps.web3ChecksOptInResult\",\n  PARSE_TRANSACTION = \"signer.eth.steps.parseTransaction\",\n  BUILD_CONTEXTS = \"signer.eth.steps.buildContexts\",\n  PROVIDE_CONTEXTS = \"signer.eth.steps.provideContexts\",\n  SIGN_TRANSACTION = \"signer.eth.steps.signTransaction\",\n  BLIND_SIGN_TRANSACTION_FALLBACK = \"signer.eth.steps.blindSignTransactionFallback\",\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  | {\n      requiredUserInteraction: SignTransactionDARequiredInteraction;\n      step: Exclude<\n        SignTransactionDAStep,\n        SignTransactionDAStep.WEB3_CHECKS_OPT_IN_RESULT\n      >;\n    }\n  | {\n      requiredUserInteraction: UserInteractionRequired.None;\n      step: SignTransactionDAStep.WEB3_CHECKS_OPT_IN_RESULT;\n      result: boolean;\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 subset: TransactionSubset | null;\n  readonly contexts: ContextWithSubContexts[];\n  readonly clearSigningType: ClearSigningType | null;\n  readonly transactionType: TransactionType | null;\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,0BAA4B,yCAC5BA,EAAA,kBAAoB,oCACpBA,EAAA,eAAiB,iCACjBA,EAAA,iBAAmB,mCACnBA,EAAA,iBAAmB,mCACnBA,EAAA,gCAAkC,gDATxBA,OAAA",
   "names": ["SignTransactionDAStep"]
 }

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

@@ -1,2 +1,2 @@
-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.WEB3_CHECKS_OPT_IN_RESULT="signer.eth.steps.web3ChecksOptInResult",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};
+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.WEB3_CHECKS_OPT_IN_RESULT="signer.eth.steps.web3ChecksOptInResult",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))(r||{});export{r as SignTypedDataDAStateStep};
 //# sourceMappingURL=SignTypedDataDeviceActionTypes.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "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  WEB3_CHECKS_OPT_IN_RESULT = \"signer.eth.steps.web3ChecksOptInResult\",\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  readonly skipOpenApp: boolean;\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  | {\n      requiredUserInteraction: SignTypedDataDARequiredInteraction;\n      step: Exclude<\n        SignTypedDataDAStateStep,\n        SignTypedDataDAStateStep.WEB3_CHECKS_OPT_IN_RESULT\n      >;\n    }\n  | {\n      requiredUserInteraction: UserInteractionRequired.None;\n      step: SignTypedDataDAStateStep.WEB3_CHECKS_OPT_IN_RESULT;\n      result: boolean;\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,0BAA4B,yCAC5BA,EAAA,cAAgB,gCAChBA,EAAA,gBAAkB,kCAClBA,EAAA,wBAA0B,yCAC1BA,EAAA,gBAAkB,iCAClBA,EAAA,uBAAyB,uCATfA,OAAA",
+  "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 TransactionMapperService } from \"@internal/transaction/service/mapper/TransactionMapperService\";\nimport { type TransactionParserService } from \"@internal/transaction/service/parser/TransactionParserService\";\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  WEB3_CHECKS_OPT_IN_RESULT = \"signer.eth.steps.web3ChecksOptInResult\",\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 transactionMapper: TransactionMapperService;\n  readonly transactionParser: TransactionParserService;\n  readonly contextModule: ContextModule;\n  readonly skipOpenApp: boolean;\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  | {\n      requiredUserInteraction: SignTypedDataDARequiredInteraction;\n      step: Exclude<\n        SignTypedDataDAStateStep,\n        SignTypedDataDAStateStep.WEB3_CHECKS_OPT_IN_RESULT\n      >;\n    }\n  | {\n      requiredUserInteraction: UserInteractionRequired.None;\n      step: SignTypedDataDAStateStep.WEB3_CHECKS_OPT_IN_RESULT;\n      result: boolean;\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": "AAmBO,IAAKA,OACVA,EAAA,SAAW,2BACXA,EAAA,eAAiB,gCACjBA,EAAA,mBAAqB,mCACrBA,EAAA,0BAA4B,yCAC5BA,EAAA,cAAgB,gCAChBA,EAAA,gBAAkB,kCAClBA,EAAA,wBAA0B,yCAC1BA,EAAA,gBAAkB,iCAClBA,EAAA,uBAAyB,uCATfA,OAAA",
   "names": ["SignTypedDataDAStateStep"]
 }

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

	@@ -0,0 +1,2 @@
1	+ var r=(e=>(e.OPEN_APP="signer.eth.steps.openApp",e.BUILD_CONTEXTS="signer.eth.steps.buildContexts",e.PROVIDE_CONTEXTS="signer.eth.steps.provideContexts",e.VERIFY_SAFE_ADDRESS="signer.eth.steps.verifySafeAddress",e))(r\|\|{});export{r as VerifySafeAddressDAStep};
2	+ //# sourceMappingURL=VerifySafeAddressDeviceActionTypes.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/app-binder/VerifySafeAddressDeviceActionTypes.ts"],
+  "sourcesContent": ["import {\n  type ClearSignContextSuccess,\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 SafeAddressOptions } from \"@api/model/SafeAddressOptions\";\nimport { type EthErrorCodes } from \"@internal/app-binder/command/utils/ethAppErrors\";\n\nexport enum VerifySafeAddressDAStep {\n  OPEN_APP = \"signer.eth.steps.openApp\",\n  BUILD_CONTEXTS = \"signer.eth.steps.buildContexts\",\n  PROVIDE_CONTEXTS = \"signer.eth.steps.provideContexts\",\n  VERIFY_SAFE_ADDRESS = \"signer.eth.steps.verifySafeAddress\",\n}\n\nexport type VerifySafeAddressDAOutput = void;\n\nexport type VerifySafeAddressDAInput = {\n  readonly safeContractAddress: string;\n  readonly contextModule: ContextModule;\n  readonly options: SafeAddressOptions;\n};\n\nexport type VerifySafeAddressDAError =\n  | OpenAppDAError\n  | CommandErrorResult<EthErrorCodes>[\"error\"];\n\ntype VerifySafeAddressDARequiredInteraction =\n  | OpenAppDARequiredInteraction\n  | UserInteractionRequired.VerifySafeAddress;\n\nexport type VerifySafeAddressDAIntermediateValue = {\n  requiredUserInteraction: VerifySafeAddressDARequiredInteraction;\n  step: VerifySafeAddressDAStep;\n};\n\nexport type VerifySafeAddressDAState = DeviceActionState<\n  VerifySafeAddressDAOutput,\n  VerifySafeAddressDAError,\n  VerifySafeAddressDAIntermediateValue\n>;\n\nexport type VerifySafeAddressDAInternalState = {\n  readonly error: VerifySafeAddressDAError | null;\n  readonly contexts: ClearSignContextSuccess[];\n};\n\nexport type VerifySafeAddressDAReturnType = ExecuteDeviceActionReturnType<\n  VerifySafeAddressDAOutput,\n  VerifySafeAddressDAError,\n  VerifySafeAddressDAIntermediateValue\n>;\n"],
+  "mappings": "AAgBO,IAAKA,OACVA,EAAA,SAAW,2BACXA,EAAA,eAAiB,iCACjBA,EAAA,iBAAmB,mCACnBA,EAAA,oBAAsB,qCAJZA,OAAA",
+  "names": ["VerifySafeAddressDAStep"]
+}

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

@@ -1,2 +1,2 @@
-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};
+import{SignTransactionDAStep as n}from"./app-binder/SignTransactionDeviceActionTypes";import{SignTypedDataDAStateStep as a}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{n as SignTransactionDAStep,a 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  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",
+  "sourcesContent": ["export {\n  type GetAddressDAError,\n  type GetAddressDAIntermediateValue,\n  type GetAddressDAOutput,\n  type GetAddressDAReturnType,\n} from \"@api/app-binder/GetAddressDeviceActionTypes\";\nexport {\n  type SignDelegationAuthorizationDAError,\n  type SignDelegationAuthorizationDAInput,\n  type SignDelegationAuthorizationDAIntermediateValue,\n  type SignDelegationAuthorizationDAOutput,\n  type SignDelegationAuthorizationDAReturnType,\n  type SignDelegationAuthorizationDAState,\n} from \"@api/app-binder/SignDelegationAuthorizationTypes\";\nexport {\n  type SignPersonalMessageDAError,\n  type SignPersonalMessageDAIntermediateValue,\n  type SignPersonalMessageDAOutput,\n  type SignPersonalMessageDAReturnType,\n} from \"@api/app-binder/SignPersonalMessageDeviceActionTypes\";\nexport {\n  type SignTransactionDAError,\n  type SignTransactionDAInput,\n  type SignTransactionDAIntermediateValue,\n  type SignTransactionDAInternalState,\n  type SignTransactionDAOutput,\n  type SignTransactionDAReturnType,\n  type SignTransactionDAState,\n  SignTransactionDAStep,\n} from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nexport {\n  type SignTypedDataDAError,\n  type SignTypedDataDAInput,\n  type SignTypedDataDAIntermediateValue,\n  type SignTypedDataDAInternalState,\n  type SignTypedDataDAOutput,\n  type SignTypedDataDAReturnType,\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": "AAoBA,OAQE,yBAAAA,MACK,mDACP,OAQE,4BAAAC,MACK,iDACP,WAAc,qBACd,WAAc,4BACd,WAAc,uBACd,WAAc,gCACd,WAAc,6BACd,WAAc,uBACd,WAAc,iBACd,WAAc",
   "names": ["SignTransactionDAStep", "SignTypedDataDAStateStep"]
 }

package/lib/esm/api/model/ClearSigningType.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ var b=(I=>(I.BASIC="basic",I.EIP7730="eip7730",I))(b\|\|{});export{b as ClearSigningType};
2	+ //# sourceMappingURL=ClearSigningType.js.map

package/lib/esm/api/model/ClearSigningType.js.map ADDED Viewed

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/api/model/ClearSigningType.ts"],
+  "sourcesContent": ["export enum ClearSigningType {\n  BASIC = \"basic\",\n  EIP7730 = \"eip7730\",\n}\n"],
+  "mappings": "AAAO,IAAKA,OACVA,EAAA,MAAQ,QACRA,EAAA,QAAU,UAFAA,OAAA",
+  "names": ["ClearSigningType"]
+}

package/lib/esm/api/model/SafeAddressOptions.js ADDED Viewed

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

package/lib/esm/api/model/SafeAddressOptions.js.map ADDED Viewed

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

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

@@ -1,2 +1,2 @@
-import{addressTypes as s}from"./address/di/addressTypes";import{makeContainer as n}from"./di";import{messageTypes as i}from"./message/di/messageTypes";import{transactionTypes as o}from"./transaction/di/transactionTypes";import{typedDataTypes as a}from"./typed-data/di/typedDataTypes";class c{_container;constructor({dmk:e,sessionId:t,contextModule:r}){this._container=n({dmk:e,sessionId:t,contextModule:r})}signTransaction(e,t,r){return this._container.get(o.SignTransactionUseCase).execute(e,t,r)}signMessage(e,t,r){return this._container.get(i.SignMessageUseCase).execute(e,t,r)}signTypedData(e,t,r){return this._container.get(a.SignTypedDataUseCase).execute(e,t,r)}getAddress(e,t){return this._container.get(s.GetAddressUseCase).execute(e,t)}}export{c as DefaultSignerEth};
+import{addressTypes as i}from"./address/di/addressTypes";import{makeContainer as n}from"./di";import{messageTypes as o}from"./message/di/messageTypes";import{safeTypes as a}from"./safe/di/safeTypes";import{transactionTypes as p}from"./transaction/di/transactionTypes";import{typedDataTypes as m}from"./typed-data/di/typedDataTypes";import{eip7702Types as g}from"./eip7702/di/eip7702Types";class c{_container;constructor({dmk:e,sessionId:t,contextModule:r}){this._container=n({dmk:e,sessionId:t,contextModule:r})}signTransaction(e,t,r){return this._container.get(p.SignTransactionUseCase).execute(e,t,r)}signMessage(e,t,r){return this._container.get(o.SignMessageUseCase).execute(e,t,r)}signTypedData(e,t,r){return this._container.get(m.SignTypedDataUseCase).execute(e,t,r)}getAddress(e,t){return this._container.get(i.GetAddressUseCase).execute(e,t)}verifySafeAddress(e,t){return this._container.get(a.VerifySafeAddressUseCase).execute(e,t)}signDelegationAuthorization(e,t,r,s){return this._container.get(g.SignDelegationAuthorizationUseCase).execute(e,s,r,t)}}export{c as DefaultSignerEth};
 //# sourceMappingURL=DefaultSignerEth.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/internal/DefaultSignerEth.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 { type GetAddressDAReturnType } from \"@api/app-binder/GetAddressDeviceActionTypes\";\nimport { type SignPersonalMessageDAReturnType } from \"@api/app-binder/SignPersonalMessageDeviceActionTypes\";\nimport { type SignTransactionDAReturnType } from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nimport { type SignTypedDataDAReturnType } from \"@api/app-binder/SignTypedDataDeviceActionTypes\";\nimport { type AddressOptions } from \"@api/model/AddressOptions\";\nimport { type MessageOptions } from \"@api/model/MessageOptions\";\nimport { type TransactionOptions } from \"@api/model/TransactionOptions\";\nimport { type TypedData } from \"@api/model/TypedData\";\nimport { type TypedDataOptions } from \"@api/model/TypedDataOptions\";\nimport { type SignerEth } from \"@api/SignerEth\";\nimport { addressTypes } from \"@internal/address/di/addressTypes\";\nimport { type GetAddressUseCase } from \"@internal/address/use-case/GetAddressUseCase\";\nimport { makeContainer } from \"@internal/di\";\nimport { messageTypes } from \"@internal/message/di/messageTypes\";\nimport { type SignMessageUseCase } from \"@internal/message/use-case/SignMessageUseCase\";\nimport { transactionTypes } from \"@internal/transaction/di/transactionTypes\";\nimport { type SignTransactionUseCase } from \"@internal/transaction/use-case/SignTransactionUseCase\";\nimport { typedDataTypes } from \"@internal/typed-data/di/typedDataTypes\";\nimport { type SignTypedDataUseCase } from \"@internal/typed-data/use-case/SignTypedDataUseCase\";\n\ntype DefaultSignerConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  contextModule: ContextModule;\n};\n\nexport class DefaultSignerEth implements SignerEth {\n  private _container: Container;\n\n  constructor({ dmk, sessionId, contextModule }: DefaultSignerConstructorArgs) {\n    this._container = makeContainer({ dmk, sessionId, contextModule });\n  }\n\n  signTransaction(\n    derivationPath: string,\n    transaction: Uint8Array,\n    options?: TransactionOptions,\n  ): SignTransactionDAReturnType {\n    return this._container\n      .get<SignTransactionUseCase>(transactionTypes.SignTransactionUseCase)\n      .execute(derivationPath, transaction, options);\n  }\n\n  signMessage(\n    derivationPath: string,\n    message: string | Uint8Array,\n    options?: MessageOptions,\n  ): SignPersonalMessageDAReturnType {\n    return this._container\n      .get<SignMessageUseCase>(messageTypes.SignMessageUseCase)\n      .execute(derivationPath, message, options);\n  }\n\n  signTypedData(\n    derivationPath: string,\n    typedData: TypedData,\n    options?: TypedDataOptions,\n  ): SignTypedDataDAReturnType {\n    return this._container\n      .get<SignTypedDataUseCase>(typedDataTypes.SignTypedDataUseCase)\n      .execute(derivationPath, typedData, options);\n  }\n\n  getAddress(\n    derivationPath: string,\n    options?: AddressOptions,\n  ): GetAddressDAReturnType {\n    return this._container\n      .get<GetAddressUseCase>(addressTypes.GetAddressUseCase)\n      .execute(derivationPath, options);\n  }\n}\n"],
-  "mappings": "AAiBA,OAAS,gBAAAA,MAAoB,oCAE7B,OAAS,iBAAAC,MAAqB,eAC9B,OAAS,gBAAAC,MAAoB,oCAE7B,OAAS,oBAAAC,MAAwB,4CAEjC,OAAS,kBAAAC,MAAsB,yCASxB,MAAMC,CAAsC,CACzC,WAER,YAAY,CAAE,IAAAC,EAAK,UAAAC,EAAW,cAAAC,CAAc,EAAiC,CAC3E,KAAK,WAAaP,EAAc,CAAE,IAAAK,EAAK,UAAAC,EAAW,cAAAC,CAAc,CAAC,CACnE,CAEA,gBACEC,EACAC,EACAC,EAC6B,CAC7B,OAAO,KAAK,WACT,IAA4BR,EAAiB,sBAAsB,EACnE,QAAQM,EAAgBC,EAAaC,CAAO,CACjD,CAEA,YACEF,EACAG,EACAD,EACiC,CACjC,OAAO,KAAK,WACT,IAAwBT,EAAa,kBAAkB,EACvD,QAAQO,EAAgBG,EAASD,CAAO,CAC7C,CAEA,cACEF,EACAI,EACAF,EAC2B,CAC3B,OAAO,KAAK,WACT,IAA0BP,EAAe,oBAAoB,EAC7D,QAAQK,EAAgBI,EAAWF,CAAO,CAC/C,CAEA,WACEF,EACAE,EACwB,CACxB,OAAO,KAAK,WACT,IAAuBX,EAAa,iBAAiB,EACrD,QAAQS,EAAgBE,CAAO,CACpC,CACF",
-  "names": ["addressTypes", "makeContainer", "messageTypes", "transactionTypes", "typedDataTypes", "DefaultSignerEth", "dmk", "sessionId", "contextModule", "derivationPath", "transaction", "options", "message", "typedData"]
+  "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 { type GetAddressDAReturnType } from \"@api/app-binder/GetAddressDeviceActionTypes\";\nimport { type SignDelegationAuthorizationDAReturnType } from \"@api/app-binder/SignDelegationAuthorizationTypes\";\nimport { type SignPersonalMessageDAReturnType } from \"@api/app-binder/SignPersonalMessageDeviceActionTypes\";\nimport { type SignTransactionDAReturnType } from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nimport { type SignTypedDataDAReturnType } from \"@api/app-binder/SignTypedDataDeviceActionTypes\";\nimport { type VerifySafeAddressDAReturnType } from \"@api/app-binder/VerifySafeAddressDeviceActionTypes\";\nimport { type AddressOptions } from \"@api/model/AddressOptions\";\nimport { type MessageOptions } from \"@api/model/MessageOptions\";\nimport { type SafeAddressOptions } from \"@api/model/SafeAddressOptions\";\nimport { type TransactionOptions } from \"@api/model/TransactionOptions\";\nimport { type TypedData } from \"@api/model/TypedData\";\nimport { type TypedDataOptions } from \"@api/model/TypedDataOptions\";\nimport { type SignerEth } from \"@api/SignerEth\";\nimport { addressTypes } from \"@internal/address/di/addressTypes\";\nimport { type GetAddressUseCase } from \"@internal/address/use-case/GetAddressUseCase\";\nimport { makeContainer } from \"@internal/di\";\nimport { messageTypes } from \"@internal/message/di/messageTypes\";\nimport { type SignMessageUseCase } from \"@internal/message/use-case/SignMessageUseCase\";\nimport { safeTypes } from \"@internal/safe/di/safeTypes\";\nimport { type VerifySafeAddressUseCase } from \"@internal/safe/use-case/VerifySafeAddressUseCase\";\nimport { transactionTypes } from \"@internal/transaction/di/transactionTypes\";\nimport { type SignTransactionUseCase } from \"@internal/transaction/use-case/SignTransactionUseCase\";\nimport { typedDataTypes } from \"@internal/typed-data/di/typedDataTypes\";\nimport { type SignTypedDataUseCase } from \"@internal/typed-data/use-case/SignTypedDataUseCase\";\n\nimport { eip7702Types } from \"./eip7702/di/eip7702Types\";\nimport { type SignDelegationAuthorizationUseCase } from \"./eip7702/use-case/SignDelegationAuthorizationUseCase\";\n\ntype DefaultSignerConstructorArgs = {\n  dmk: DeviceManagementKit;\n  sessionId: DeviceSessionId;\n  contextModule: ContextModule;\n};\n\nexport class DefaultSignerEth implements SignerEth {\n  private _container: Container;\n\n  constructor({ dmk, sessionId, contextModule }: DefaultSignerConstructorArgs) {\n    this._container = makeContainer({ dmk, sessionId, contextModule });\n  }\n\n  signTransaction(\n    derivationPath: string,\n    transaction: Uint8Array,\n    options?: TransactionOptions,\n  ): SignTransactionDAReturnType {\n    return this._container\n      .get<SignTransactionUseCase>(transactionTypes.SignTransactionUseCase)\n      .execute(derivationPath, transaction, options);\n  }\n\n  signMessage(\n    derivationPath: string,\n    message: string | Uint8Array,\n    options?: MessageOptions,\n  ): SignPersonalMessageDAReturnType {\n    return this._container\n      .get<SignMessageUseCase>(messageTypes.SignMessageUseCase)\n      .execute(derivationPath, message, options);\n  }\n\n  signTypedData(\n    derivationPath: string,\n    typedData: TypedData,\n    options?: TypedDataOptions,\n  ): SignTypedDataDAReturnType {\n    return this._container\n      .get<SignTypedDataUseCase>(typedDataTypes.SignTypedDataUseCase)\n      .execute(derivationPath, typedData, options);\n  }\n\n  getAddress(\n    derivationPath: string,\n    options?: AddressOptions,\n  ): GetAddressDAReturnType {\n    return this._container\n      .get<GetAddressUseCase>(addressTypes.GetAddressUseCase)\n      .execute(derivationPath, options);\n  }\n\n  verifySafeAddress(\n    safeContractAddress: string,\n    options?: SafeAddressOptions,\n  ): VerifySafeAddressDAReturnType {\n    return this._container\n      .get<VerifySafeAddressUseCase>(safeTypes.VerifySafeAddressUseCase)\n      .execute(safeContractAddress, options);\n  }\n\n  signDelegationAuthorization(\n    derivationPath: string,\n    chainId: number,\n    contractAddress: string,\n    nonce: number,\n  ): SignDelegationAuthorizationDAReturnType {\n    return this._container\n      .get<SignDelegationAuthorizationUseCase>(\n        eip7702Types.SignDelegationAuthorizationUseCase,\n      )\n      .execute(derivationPath, nonce, contractAddress, chainId);\n  }\n}\n"],
+  "mappings": "AAoBA,OAAS,gBAAAA,MAAoB,oCAE7B,OAAS,iBAAAC,MAAqB,eAC9B,OAAS,gBAAAC,MAAoB,oCAE7B,OAAS,aAAAC,MAAiB,8BAE1B,OAAS,oBAAAC,MAAwB,4CAEjC,OAAS,kBAAAC,MAAsB,yCAG/B,OAAS,gBAAAC,MAAoB,4BAStB,MAAMC,CAAsC,CACzC,WAER,YAAY,CAAE,IAAAC,EAAK,UAAAC,EAAW,cAAAC,CAAc,EAAiC,CAC3E,KAAK,WAAaT,EAAc,CAAE,IAAAO,EAAK,UAAAC,EAAW,cAAAC,CAAc,CAAC,CACnE,CAEA,gBACEC,EACAC,EACAC,EAC6B,CAC7B,OAAO,KAAK,WACT,IAA4BT,EAAiB,sBAAsB,EACnE,QAAQO,EAAgBC,EAAaC,CAAO,CACjD,CAEA,YACEF,EACAG,EACAD,EACiC,CACjC,OAAO,KAAK,WACT,IAAwBX,EAAa,kBAAkB,EACvD,QAAQS,EAAgBG,EAASD,CAAO,CAC7C,CAEA,cACEF,EACAI,EACAF,EAC2B,CAC3B,OAAO,KAAK,WACT,IAA0BR,EAAe,oBAAoB,EAC7D,QAAQM,EAAgBI,EAAWF,CAAO,CAC/C,CAEA,WACEF,EACAE,EACwB,CACxB,OAAO,KAAK,WACT,IAAuBb,EAAa,iBAAiB,EACrD,QAAQW,EAAgBE,CAAO,CACpC,CAEA,kBACEG,EACAH,EAC+B,CAC/B,OAAO,KAAK,WACT,IAA8BV,EAAU,wBAAwB,EAChE,QAAQa,EAAqBH,CAAO,CACzC,CAEA,4BACEF,EACAM,EACAC,EACAC,EACyC,CACzC,OAAO,KAAK,WACT,IACCb,EAAa,kCACf,EACC,QAAQK,EAAgBQ,EAAOD,EAAiBD,CAAO,CAC5D,CACF",
+  "names": ["addressTypes", "makeContainer", "messageTypes", "safeTypes", "transactionTypes", "typedDataTypes", "eip7702Types", "DefaultSignerEth", "dmk", "sessionId", "contextModule", "derivationPath", "transaction", "options", "message", "typedData", "safeContractAddress", "chainId", "contractAddress", "nonce"]
 }

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: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)})})});
+import{addressTypes as o}from"./address/di/addressTypes";import{eip7702Types as r}from"./eip7702/di/eip7702Types";import{messageTypes as d}from"./message/di/messageTypes";import{transactionTypes as c}from"./transaction/di/transactionTypes";import{typedDataTypes as g}from"./typed-data/di/typedDataTypes";import{DefaultSignerEth as l}from"./DefaultSignerEth";describe("DefaultSignerEth",()=>{let a;const n={get:vi.fn(e=>({execute:vi.fn(()=>e===c.SignTransactionUseCase?"transaction-result":e===r.SignDelegationAuthorizationUseCase?"delegation-result":e===d.SignMessageUseCase?"message-result":e===g.SignTypedDataUseCase?"typed-data-result":e===o.GetAddressUseCase?"address-result":"undefined-result")}))};beforeEach(()=>{vi.clearAllMocks();const e={},s="",t={};a=new l({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(c.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(d.SignMessageUseCase)})}),describe("signDelegationAuthorization",()=>{it("should sign a delegation authorization",async()=>{const i=await a.signDelegationAuthorization("derivationPath",2,"0xaddress",42);expect(i).toBeDefined(),expect(i).toBe("delegation-result"),expect(n.get).toHaveBeenCalledWith(r.SignDelegationAuthorizationUseCase)})}),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(g.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(o.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: 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"]
+  "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 { eip7702Types } from \"./eip7702/di/eip7702Types\";\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 === eip7702Types.SignDelegationAuthorizationUseCase) {\n          return \"delegation-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(\"signDelegationAuthorization\", () => {\n    it(\"should sign a delegation authorization\", async () => {\n      // GIVEN\n      const derivationPath = \"derivationPath\";\n      const chainId = 2;\n      const nonce = 42;\n      const address = \"0xaddress\";\n\n      // WHEN\n      const result = await signer.signDelegationAuthorization(\n        derivationPath,\n        chainId,\n        address,\n        nonce,\n      );\n\n      // THEN\n      expect(result).toBeDefined();\n      expect(result).toBe(\"delegation-result\");\n      expect(mock.get).toHaveBeenCalledWith(\n        eip7702Types.SignDelegationAuthorizationUseCase,\n      );\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,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,IAAOP,EAAa,mCACtB,oBACEO,IAAON,EAAa,mBACtB,iBACEM,IAAOJ,EAAe,qBACxB,oBACEI,IAAOR,EAAa,kBACtB,iBAGF,kBACR,CACH,EAAE,CACJ,EAEA,WAAW,IAAM,CACf,GAAG,cAAc,EAEjB,MAAMS,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,8BAA+B,IAAM,CAC5C,GAAG,yCAA0C,SAAY,CAQvD,MAAMY,EAAS,MAAMR,EAAO,4BANL,iBAQrB,EALc,YAOd,EACF,EAGA,OAAOQ,CAAM,EAAE,YAAY,EAC3B,OAAOA,CAAM,EAAE,KAAK,mBAAmB,EACvC,OAAOP,EAAK,GAAG,EAAE,qBACfN,EAAa,kCACf,CACF,CAAC,CACH,CAAC,EAED,SAAS,gBAAiB,IAAM,CAC9B,GAAG,yBAA0B,SAAY,CAEvC,MAAMW,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,qBAAqBP,EAAa,iBAAiB,CACtE,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["addressTypes", "eip7702Types", "messageTypes", "transactionTypes", "typedDataTypes", "DefaultSignerEth", "signer", "mock", "id", "dmk", "sessionId", "contextModule", "derivationPath", "transaction", "result", "typedData"]
 }

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

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