@ledgerhq/device-signer-kit-ethereum 0.0.0-signer-eth-20250122093657 → 0.0.0-transactionInspector-resolutionObj-20250916071327

package/lib/cjs/internal/transaction/service/mapper/EthersTransactionMapperService.test.js

@@ -0,0 +1,2 @@
+"use strict";var i=require("@ledgerhq/device-management-kit"),a=require("ethers"),c=require("./EthersTransactionMapperService");describe("RawTransactionMapper",()=>{const n=new c.EthersTransactionMapperService;it("should return Nothing when empty raw transaction",()=>{const e=new Uint8Array(0),t=n.mapTransactionToSubset(e);expect(t.isLeft()).toBeTruthy()}),it("should return Nothing when invalid raw transaction",()=>{const e=new Uint8Array(1),t=n.mapTransactionToSubset(e);expect(t.isLeft()).toBeTruthy()}),it("should return a TransactionMapperResult",()=>{const e=(0,i.hexaStringToBuffer)(a.Transaction.from({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x1234567890"}).unsignedSerialized),t=n.mapTransactionToSubset(e);expect(t.isRight()).toBeTruthy();const{serializedTransaction:o,subset:s,type:r}=t.unsafeCoerce();expect(o).toEqual((0,a.getBytes)(e)),expect(s).toEqual({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x1234567890",value:0n,selector:"0x12345678"}),expect(r).toEqual(2)}),it("should return a TransactionMapperResult with undefined to",()=>{const e=(0,i.hexaStringToBuffer)(a.Transaction.from({chainId:1,data:"0x1234567890"}).unsignedSerialized),t=n.mapTransactionToSubset(e);expect(t.isRight()).toBeTruthy();const{serializedTransaction:o,subset:s,type:r}=t.unsafeCoerce();expect(o).toEqual((0,a.getBytes)(e)),expect(s).toEqual({chainId:1,to:void 0,data:"0x1234567890",value:0n,selector:"0x12345678"}),expect(r).toEqual(2)}),it("should return a TransactionMapperResult with empty data",()=>{const e=(0,i.hexaStringToBuffer)(a.Transaction.from({chainId:1,to:"0x1234567890123456789012345678901234567890"}).unsignedSerialized),t=n.mapTransactionToSubset(e);expect(t.isRight()).toBeTruthy();const{serializedTransaction:o,subset:s,type:r}=t.unsafeCoerce();expect(o).toEqual((0,a.getBytes)(e)),expect(s).toEqual({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x",value:0n,selector:"0x"}),expect(r).toEqual(2)}),it("should return a TransactionMapperResult with a custom type",()=>{const e=(0,i.hexaStringToBuffer)(a.Transaction.from({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x123456",type:1}).unsignedSerialized),t=n.mapTransactionToSubset(e);expect(t.isRight()).toBeTruthy();const{serializedTransaction:o,subset:s,type:r}=t.unsafeCoerce();expect(o).toEqual((0,a.getBytes)(e)),expect(s).toEqual({chainId:1,to:"0x1234567890123456789012345678901234567890",data:"0x123456",value:0n,selector:"0x123456"}),expect(r).toEqual(1)}),it("should return a Left when the chainId is 0",()=>{const e=(0,i.hexaStringToBuffer)(a.Transaction.from({chainId:0}).unsignedSerialized),t=n.mapTransactionToSubset(e);expect(t.isLeft()).toBeTruthy(),expect(t.extract()).toEqual(new Error("Pre-EIP-155 transactions are not supported"))})});
+//# sourceMappingURL=EthersTransactionMapperService.test.js.map

package/lib/cjs/internal/transaction/service/mapper/EthersTransactionMapperService.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersTransactionMapperService.test.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { getBytes, Transaction } from \"ethers\";\n\nimport { EthersTransactionMapperService } from \"./EthersTransactionMapperService\";\n\ndescribe(\"RawTransactionMapper\", () => {\n  const mapper = new EthersTransactionMapperService();\n\n  it(\"should return Nothing when empty raw transaction\", () => {\n    // GIVEN\n    const transaction = new Uint8Array(0);\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isLeft()).toBeTruthy();\n  });\n\n  it(\"should return Nothing when invalid raw transaction\", () => {\n    // GIVEN\n    const transaction = new Uint8Array(1);\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isLeft()).toBeTruthy();\n  });\n\n  it(\"should return a TransactionMapperResult\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        to: \"0x1234567890123456789012345678901234567890\",\n        data: \"0x1234567890\",\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isRight()).toBeTruthy();\n    const { serializedTransaction, subset, type } = result.unsafeCoerce();\n    expect(serializedTransaction).toEqual(getBytes(transaction));\n    expect(subset).toEqual({\n      chainId: 1,\n      to: \"0x1234567890123456789012345678901234567890\",\n      data: \"0x1234567890\",\n      value: 0n,\n      selector: \"0x12345678\",\n    });\n    expect(type).toEqual(2);\n  });\n\n  it(\"should return a TransactionMapperResult with undefined to\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        data: \"0x1234567890\",\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isRight()).toBeTruthy();\n    const { serializedTransaction, subset, type } = result.unsafeCoerce();\n    expect(serializedTransaction).toEqual(getBytes(transaction));\n    expect(subset).toEqual({\n      chainId: 1,\n      to: undefined,\n      data: \"0x1234567890\",\n      value: 0n,\n      selector: \"0x12345678\",\n    });\n    expect(type).toEqual(2);\n  });\n\n  it(\"should return a TransactionMapperResult with empty data\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        to: \"0x1234567890123456789012345678901234567890\",\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isRight()).toBeTruthy();\n    const { serializedTransaction, subset, type } = result.unsafeCoerce();\n    expect(serializedTransaction).toEqual(getBytes(transaction));\n    expect(subset).toEqual({\n      chainId: 1,\n      to: \"0x1234567890123456789012345678901234567890\",\n      data: \"0x\",\n      value: 0n,\n      selector: \"0x\",\n    });\n    expect(type).toEqual(2);\n  });\n\n  it(\"should return a TransactionMapperResult with a custom type\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 1,\n        to: \"0x1234567890123456789012345678901234567890\",\n        data: \"0x123456\",\n        type: 1,\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isRight()).toBeTruthy();\n    const { serializedTransaction, subset, type } = result.unsafeCoerce();\n    expect(serializedTransaction).toEqual(getBytes(transaction));\n    expect(subset).toEqual({\n      chainId: 1,\n      to: \"0x1234567890123456789012345678901234567890\",\n      data: \"0x123456\",\n      value: 0n,\n      selector: \"0x123456\",\n    });\n    expect(type).toEqual(1);\n  });\n\n  it(\"should return a Left when the chainId is 0\", () => {\n    // GIVEN\n    const transaction = hexaStringToBuffer(\n      Transaction.from({\n        chainId: 0,\n      }).unsignedSerialized,\n    )!;\n\n    // WHEN\n    const result = mapper.mapTransactionToSubset(transaction);\n\n    // THEN\n    expect(result.isLeft()).toBeTruthy();\n    expect(result.extract()).toEqual(\n      new Error(\"Pre-EIP-155 transactions are not supported\"),\n    );\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAAmC,2CACnCC,EAAsC,kBAEtCC,EAA+C,4CAE/C,SAAS,uBAAwB,IAAM,CACrC,MAAMC,EAAS,IAAI,iCAEnB,GAAG,mDAAoD,IAAM,CAE3D,MAAMC,EAAc,IAAI,WAAW,CAAC,EAG9BC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,CACrC,CAAC,EAED,GAAG,qDAAsD,IAAM,CAE7D,MAAMD,EAAc,IAAI,WAAW,CAAC,EAG9BC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,CACrC,CAAC,EAED,GAAG,0CAA2C,IAAM,CAElD,MAAMD,KAAc,sBAClB,cAAY,KAAK,CACf,QAAS,EACT,GAAI,6CACJ,KAAM,cACR,CAAC,EAAE,kBACL,EAGMC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,QAAQ,CAAC,EAAE,WAAW,EACpC,KAAM,CAAE,sBAAAC,EAAuB,OAAAC,EAAQ,KAAAC,CAAK,EAAIH,EAAO,aAAa,EACpE,OAAOC,CAAqB,EAAE,WAAQ,YAASF,CAAW,CAAC,EAC3D,OAAOG,CAAM,EAAE,QAAQ,CACrB,QAAS,EACT,GAAI,6CACJ,KAAM,eACN,MAAO,GACP,SAAU,YACZ,CAAC,EACD,OAAOC,CAAI,EAAE,QAAQ,CAAC,CACxB,CAAC,EAED,GAAG,4DAA6D,IAAM,CAEpE,MAAMJ,KAAc,sBAClB,cAAY,KAAK,CACf,QAAS,EACT,KAAM,cACR,CAAC,EAAE,kBACL,EAGMC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,QAAQ,CAAC,EAAE,WAAW,EACpC,KAAM,CAAE,sBAAAC,EAAuB,OAAAC,EAAQ,KAAAC,CAAK,EAAIH,EAAO,aAAa,EACpE,OAAOC,CAAqB,EAAE,WAAQ,YAASF,CAAW,CAAC,EAC3D,OAAOG,CAAM,EAAE,QAAQ,CACrB,QAAS,EACT,GAAI,OACJ,KAAM,eACN,MAAO,GACP,SAAU,YACZ,CAAC,EACD,OAAOC,CAAI,EAAE,QAAQ,CAAC,CACxB,CAAC,EAED,GAAG,0DAA2D,IAAM,CAElE,MAAMJ,KAAc,sBAClB,cAAY,KAAK,CACf,QAAS,EACT,GAAI,4CACN,CAAC,EAAE,kBACL,EAGMC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,QAAQ,CAAC,EAAE,WAAW,EACpC,KAAM,CAAE,sBAAAC,EAAuB,OAAAC,EAAQ,KAAAC,CAAK,EAAIH,EAAO,aAAa,EACpE,OAAOC,CAAqB,EAAE,WAAQ,YAASF,CAAW,CAAC,EAC3D,OAAOG,CAAM,EAAE,QAAQ,CACrB,QAAS,EACT,GAAI,6CACJ,KAAM,KACN,MAAO,GACP,SAAU,IACZ,CAAC,EACD,OAAOC,CAAI,EAAE,QAAQ,CAAC,CACxB,CAAC,EAED,GAAG,6DAA8D,IAAM,CAErE,MAAMJ,KAAc,sBAClB,cAAY,KAAK,CACf,QAAS,EACT,GAAI,6CACJ,KAAM,WACN,KAAM,CACR,CAAC,EAAE,kBACL,EAGMC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,QAAQ,CAAC,EAAE,WAAW,EACpC,KAAM,CAAE,sBAAAC,EAAuB,OAAAC,EAAQ,KAAAC,CAAK,EAAIH,EAAO,aAAa,EACpE,OAAOC,CAAqB,EAAE,WAAQ,YAASF,CAAW,CAAC,EAC3D,OAAOG,CAAM,EAAE,QAAQ,CACrB,QAAS,EACT,GAAI,6CACJ,KAAM,WACN,MAAO,GACP,SAAU,UACZ,CAAC,EACD,OAAOC,CAAI,EAAE,QAAQ,CAAC,CACxB,CAAC,EAED,GAAG,6CAA8C,IAAM,CAErD,MAAMJ,KAAc,sBAClB,cAAY,KAAK,CACf,QAAS,CACX,CAAC,EAAE,kBACL,EAGMC,EAASF,EAAO,uBAAuBC,CAAW,EAGxD,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,EACnC,OAAOA,EAAO,QAAQ,CAAC,EAAE,QACvB,IAAI,MAAM,4CAA4C,CACxD,CACF,CAAC,CACH,CAAC",
+  "names": ["import_device_management_kit", "import_ethers", "import_EthersTransactionMapperService", "mapper", "transaction", "result", "serializedTransaction", "subset", "type"]
+}

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

@@ -1,2 +1,2 @@
-"use strict";var n=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var h=Object.getOwnPropertyNames;var E=Object.prototype.hasOwnProperty;var y=(t,r)=>{for(var p in r)n(t,p,{get:r[p],enumerable:!0})},M=(t,r,p,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of h(r))!E.call(t,o)&&o!==p&&n(t,o,{get:()=>r[o],enumerable:!(a=u(r,o))||a.enumerable});return t};var R=t=>M(n({},"__esModule",{value:!0}),t),f=(t,r,p,a)=>{for(var o=a>1?void 0:a?u(r,p):r,m=t.length-1,c;m>=0;m--)(c=t[m])&&(o=(a?c(r,p,o):c(o))||o);return a&&o&&n(r,p,o),o},l=(t,r)=>(p,a)=>r(p,a,t);var _={};y(_,{TransactionMapperService:()=>s});module.exports=R(_);var e=require("inversify"),i=require("purify-ts"),T=require("../../../transaction/di/transactionTypes");let s=class{_mappers;constructor(r){this._mappers=r}mapTransactionToSubset(r){for(const p of this._mappers){const a=p.map(r);if(a.isJust())return(0,i.Right)(a.extract())}return(0,i.Left)(new Error("Unsupported transaction type"))}};s=f([(0,e.injectable)(),l(0,(0,e.multiInject)(T.transactionTypes.TransactionMappers))],s);0&&(module.exports={TransactionMapperService});
+"use strict";var i=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var c=(t,r,n,e)=>{if(r&&typeof r=="object"||typeof r=="function")for(let a of p(r))!s.call(t,a)&&a!==n&&i(t,a,{get:()=>r[a],enumerable:!(e=o(r,a))||e.enumerable});return t};var m=t=>c(i({},"__esModule",{value:!0}),t);var T={};module.exports=m(T);
 //# sourceMappingURL=TransactionMapperService.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.ts"],
-  "sourcesContent": ["import { injectable, multiInject } from \"inversify\";\nimport { Either, Left, Right } from \"purify-ts\";\n\nimport { transactionTypes } from \"@internal/transaction/di/transactionTypes\";\n\nimport { TransactionMapperResult } from \"./model/TransactionMapperResult\";\nimport { TransactionMapper } from \"./TransactionMapper\";\n\n@injectable()\nexport class TransactionMapperService {\n  private _mappers: TransactionMapper[];\n\n  constructor(\n    @multiInject(transactionTypes.TransactionMappers)\n    mappers: TransactionMapper[],\n  ) {\n    this._mappers = mappers;\n  }\n\n  mapTransactionToSubset(\n    transaction: Uint8Array,\n  ): Either<Error, TransactionMapperResult> {\n    for (const mapper of this._mappers) {\n      const result = mapper.map(transaction);\n      if (result.isJust()) {\n        return Right(result.extract());\n      }\n    }\n\n    // TODO: handle correctly with the future error type\n    return Left(new Error(\"Unsupported transaction type\"));\n  }\n}\n"],
-  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAwC,qBACxCC,EAAoC,qBAEpCC,EAAiC,qDAM1B,IAAMC,EAAN,KAA+B,CAC5B,SAER,YAEEC,EACA,CACA,KAAK,SAAWA,CAClB,CAEA,uBACEC,EACwC,CACxC,UAAWC,KAAU,KAAK,SAAU,CAClC,MAAMC,EAASD,EAAO,IAAID,CAAW,EACrC,GAAIE,EAAO,OAAO,EAChB,SAAO,SAAMA,EAAO,QAAQ,CAAC,CAEjC,CAGA,SAAO,QAAK,IAAI,MAAM,8BAA8B,CAAC,CACvD,CACF,EAvBaJ,EAANK,EAAA,IADN,cAAW,EAKPC,EAAA,oBAAY,mBAAiB,kBAAkB,IAJvCN",
-  "names": ["TransactionMapperService_exports", "__export", "TransactionMapperService", "__toCommonJS", "import_inversify", "import_purify_ts", "import_transactionTypes", "TransactionMapperService", "mappers", "transaction", "mapper", "result", "__decorateClass", "__decorateParam"]
+  "sourcesContent": ["import { type Either } from \"purify-ts\";\n\nimport { type TransactionMapperResult } from \"./model/TransactionMapperResult\";\n\nexport interface TransactionMapperService {\n  mapTransactionToSubset: (\n    transaction: Uint8Array,\n  ) => Either<Error, TransactionMapperResult>;\n}\n"],
+  "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
+  "names": ["TransactionMapperService_exports", "__toCommonJS"]
 }

package/lib/cjs/internal/transaction/service/parser/TransactionParserService.js

@@ -1,2 +1,2 @@
-"use strict";var y=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var P=(u,t)=>{for(var r in t)y(u,r,{get:t[r],enumerable:!0})},I=(u,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of x(t))!C.call(u,e)&&e!==r&&y(u,e,{get:()=>t[e],enumerable:!(n=g(t,e))||n.enumerable});return u};var N=u=>I(y({},"__esModule",{value:!0}),u),p=(u,t,r,n)=>{for(var e=n>1?void 0:n?g(t,r):t,c=u.length-1,E;c>=0;c--)(E=u[c])&&(e=(n?E(t,r,e):E(e))||e);return n&&e&&y(t,r,e),e};var D={};P(D,{TransactionParserService:()=>d});module.exports=N(D);var i=require("@ledgerhq/context-module"),s=require("@ledgerhq/device-management-kit"),w=require("ethers"),L=require("inversify"),a=require("purify-ts");const F=4,m=32;let d=class{extractValue(t,r){return a.Either.encase(()=>w.Transaction.from((0,s.bufferToHexaString)(t))).chain(n=>r===i.ContainerPath.FROM?(0,a.Left)(new Error("Cannot get 'FROM' field of an unsigned transaction")):r===i.ContainerPath.TO?a.Maybe.fromNullable(n.to).map(e=>(0,s.hexaStringToBuffer)(e)).filter(e=>e!==null).map(e=>[e]).toEither(new Error("Faild to extract TO field of transaction")):r===i.ContainerPath.VALUE?a.Maybe.fromNullable(n.value).map(e=>new s.ByteArrayBuilder().add256BitUIntToData(e).build()).map(e=>[e]).toEither(new Error("Faild to extract VALUE field of transaction")):a.Maybe.fromNullable(n.data).toEither(new Error("Transaction calldata is empty")).chain(e=>a.Maybe.fromNullable((0,s.hexaStringToBuffer)(e)).toEither(new Error(`Invalid hex string calldata: ${e}`))).chain(e=>this.extractCalldataValue(e,r)))}extractCalldataValue(t,r){return t=t.slice(F),r.length===0?(0,a.Left)(new Error("Path is empty")):this.extractCalldataValueAt(t,r,0,0)}extractCalldataValueAt(t,r,n,e){const c=r[r.length-1],E=c.type===i.DataPathElementType.SLICE?c:null;for(;r.length>0;){const l=r[0];switch(r=r.slice(1),l.type){case i.DataPathElementType.TUPLE:e=n,n+=l.offset*m;break;case i.DataPathElementType.ARRAY:return this.getU256(t.slice(n)).toEither(new Error(`Invalid array length at offset ${n}`)).chain(o=>{n+=m,e=n;const h=l.start===void 0?0:l.start<0?o+l.start:l.start,b=l.end===void 0?o:l.end<0?o+l.end:l.end;return h<0||h>=o||b>o||h>=b?(0,a.Left)(new Error(`Array slice out of bounds, start=${l.start}, end=${l.end}`)):Array.from({length:b-h},(A,U)=>U).map(A=>n+(A+h)*l.itemSize*m).reduce((A,U)=>A.chain(f=>this.extractCalldataValueAt(t,r,U,e).map(T=>[...f,...T])),(0,a.Right)([]))});case i.DataPathElementType.REF:if(this.getU256(t.slice(n)).ifJust(o=>n=e+o).isNothing())return(0,a.Left)(new Error(`Invalid ref at offset ${n}`));break;case i.DataPathElementType.LEAF:switch(l.leafType){case i.DataPathLeafType.ARRAY_LEAF:return(0,a.Left)(new Error("Array leaf is not supported in v1 of protocol"));case i.DataPathLeafType.TUPLE_LEAF:return(0,a.Left)(new Error("Tuple leaf is not supported in v1 of protocol"));case i.DataPathLeafType.STATIC_LEAF:return this.getSlice(t,n,m).chain(o=>E===null?(0,a.Right)([o]):this.sliceLeaf(o,E));case i.DataPathLeafType.DYNAMIC_LEAF:return this.getU256(t.slice(n)).toEither(new Error(`Invalid leaf length at offset ${n}`)).chain(o=>(n+=m,this.getSlice(t,n,o).chain(h=>E===null?(0,a.Right)([h]):this.sliceLeaf(h,E))))}break;case i.DataPathElementType.SLICE:return(0,a.Left)(new Error("Slice can only be used as last element of the path"))}}return(0,a.Left)(new Error("Path did not resolve to a leaf element"))}sliceLeaf(t,r){const n=t.length,e=r.start===void 0?0:r.start<0?n+r.start:r.start,c=r.end===void 0?n:r.end<0?n+r.end:r.end;return e>=c?(0,a.Left)(new Error(`invalid leaf slice: start ${e}, end ${c}`)):this.getSlice(t,e,c-e).map(E=>[E])}getSlice(t,r,n){return r<0||t.length<r+n?(0,a.Left)(new Error(`calldata too small to slice at offset ${r} of length ${n}`)):(0,a.Right)(t.slice(r,r+n))}getU256(t){return a.Maybe.fromNullable(new s.ByteArrayParser(t).extract256BitUInt(!0)).filter(r=>r<=Number.MAX_SAFE_INTEGER).map(r=>Number(r))}};d=p([(0,L.injectable)()],d);0&&(module.exports={TransactionParserService});
+"use strict";var y=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var P=(c,t)=>{for(var r in t)y(c,r,{get:t[r],enumerable:!0})},f=(c,t,r,e)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of x(t))!C.call(c,n)&&n!==r&&y(c,n,{get:()=>t[n],enumerable:!(e=g(t,n))||e.enumerable});return c};var I=c=>f(y({},"__esModule",{value:!0}),c),p=(c,t,r,e)=>{for(var n=e>1?void 0:e?g(t,r):t,u=c.length-1,a;u>=0;u--)(a=c[u])&&(n=(e?a(t,r,n):a(n))||n);return e&&n&&y(t,r,n),n};var F={};P(F,{TransactionParserService:()=>d});module.exports=I(F);var l=require("@ledgerhq/context-module"),h=require("@ledgerhq/device-management-kit"),w=require("inversify"),i=require("purify-ts");const N=4,m=32;let d=class{extractValue(t,r){const{to:e,data:n,value:u}=t;return r===l.ContainerPath.FROM?(0,i.Left)(new Error("Cannot get 'FROM' field of an unsigned transaction")):r===l.ContainerPath.TO?i.Maybe.fromNullable(e).map(a=>(0,h.hexaStringToBuffer)(a)).filter(a=>a!==null).map(a=>[a]).toEither(new Error("Faild to extract TO field of transaction")):r===l.ContainerPath.VALUE?i.Maybe.fromNullable(u).map(a=>new h.ByteArrayBuilder().add256BitUIntToData(a).build()).map(a=>[a]).toEither(new Error("Faild to extract VALUE field of transaction")):i.Maybe.fromNullable(n).toEither(new Error("Transaction calldata is empty")).chain(a=>i.Maybe.fromNullable((0,h.hexaStringToBuffer)(a)).toEither(new Error(`Invalid hex string calldata: ${a}`))).chain(a=>this.extractCalldataValue(a,r))}extractCalldataValue(t,r){return t=t.slice(N),r.length===0?(0,i.Left)(new Error("Path is empty")):this.extractCalldataValueAt(t,r,0,0)}extractCalldataValueAt(t,r,e,n){const u=r[r.length-1],a=u.type===l.DataPathElementType.SLICE?u:null;for(;r.length>0;){const o=r[0];switch(r=r.slice(1),o.type){case l.DataPathElementType.TUPLE:n=e,e+=o.offset*m;break;case l.DataPathElementType.ARRAY:return this.getU256(t.slice(e)).toEither(new Error(`Invalid array length at offset ${e}`)).chain(s=>{e+=m,n=e;const E=o.start===void 0?0:o.start<0?s+o.start:o.start,b=o.end===void 0?s:o.end<0?s+o.end:o.end;return E<0||E>=s||b>s||E>=b?(0,i.Left)(new Error(`Array slice out of bounds, start=${o.start}, end=${o.end}`)):Array.from({length:b-E},(A,U)=>U).map(A=>e+(A+E)*o.itemSize*m).reduce((A,U)=>A.chain(L=>this.extractCalldataValueAt(t,r,U,n).map(T=>[...L,...T])),(0,i.Right)([]))});case l.DataPathElementType.REF:if(this.getU256(t.slice(e)).ifJust(s=>e=n+s).isNothing())return(0,i.Left)(new Error(`Invalid ref at offset ${e}`));break;case l.DataPathElementType.LEAF:switch(o.leafType){case l.DataPathLeafType.ARRAY_LEAF:return(0,i.Left)(new Error("Array leaf is not supported in v1 of protocol"));case l.DataPathLeafType.TUPLE_LEAF:return(0,i.Left)(new Error("Tuple leaf is not supported in v1 of protocol"));case l.DataPathLeafType.STATIC_LEAF:return this.getSlice(t,e,m).chain(s=>a===null?(0,i.Right)([s]):this.sliceLeaf(s,a));case l.DataPathLeafType.DYNAMIC_LEAF:return this.getU256(t.slice(e)).toEither(new Error(`Invalid leaf length at offset ${e}`)).chain(s=>(e+=m,this.getSlice(t,e,s).chain(E=>a===null?(0,i.Right)([E]):this.sliceLeaf(E,a))))}break;case l.DataPathElementType.SLICE:return(0,i.Left)(new Error("Slice can only be used as last element of the path"))}}return(0,i.Left)(new Error("Path did not resolve to a leaf element"))}sliceLeaf(t,r){const e=t.length,n=r.start===void 0?0:r.start<0?e+r.start:r.start,u=r.end===void 0?e:r.end<0?e+r.end:r.end;return n>=u?(0,i.Left)(new Error(`invalid leaf slice: start ${n}, end ${u}`)):this.getSlice(t,n,u-n).map(a=>[a])}getSlice(t,r,e){return r<0||t.length<r+e?(0,i.Left)(new Error(`calldata too small to slice at offset ${r} of length ${e}`)):(0,i.Right)(t.slice(r,r+e))}getU256(t){return i.Maybe.fromNullable(new h.ByteArrayParser(t).extract256BitUInt(!0)).filter(r=>r<=Number.MAX_SAFE_INTEGER).map(r=>Number(r))}};d=p([(0,w.injectable)()],d);0&&(module.exports={TransactionParserService});
 //# sourceMappingURL=TransactionParserService.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/parser/TransactionParserService.ts"],
-  "sourcesContent": ["import type {\n  DataPathElement,\n  DataPathElementSlice,\n  GenericPath,\n} from \"@ledgerhq/context-module\";\nimport {\n  ContainerPath,\n  DataPathElementType,\n  DataPathLeafType,\n} from \"@ledgerhq/context-module\";\nimport {\n  bufferToHexaString,\n  ByteArrayBuilder,\n  ByteArrayParser,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers\";\nimport { injectable } from \"inversify\";\nimport { Either, Left, Maybe, Right } from \"purify-ts\";\n\n/**\n * The goal of this service it to implement the GenericPath parser in the context\n * of an ethereum transaction.\n *\n * The abi of an ethereum transaction calldata is specified here:\n * https://docs.soliditylang.org/en/latest/abi-spec.html\n *\n * To be noted:\n *  - calldata is composed of:\n *    - the selector on 4 bytes\n *    - chunks of 32 bytes, whatever the size of the item contained in that chunk\n *    - static elements (fixed size) are encoded \"in-place\", always in 1 chunk padded with zeros\n *      (even a bool is on 32 bytes)\n *    - dynamic elements (variable size) are behind references (pointers) and then encoded with length+value\n *\n * Examples extracted from the abi specification:\n *  - example for a function with static elements:\n *    signature: baz(uint32 x, bool y)\n *    parameters: x = 69\n *                y = true\n *    - Encoding:\n *      0xcdcd77c0: the selector\n *      [0] 0x0000000000000000000000000000000000000000000000000000000000000045: value = 69\n *      [1] 0x0000000000000000000000000000000000000000000000000000000000000001: value = true\n *\n *  - example for a function with dynamic elements:\n *    signature: g(uint256[][] x, string[] x)\n *    parameters: x = [[1, 2], [3]]\n *                y = [\"one\", \"two\", \"three\"]\n *    - Encoding:\n *      0x2289b18c: the selector\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 */\nconst SELECTOR_LENGTH = 4;\nconst CHUNK_SIZE = 32;\n\n@injectable()\nexport class TransactionParserService {\n  public extractValue(\n    serializedTransaction: Uint8Array,\n    path: GenericPath,\n  ): Either<Error, Uint8Array[]> {\n    return Either.encase(() =>\n      Transaction.from(bufferToHexaString(serializedTransaction)),\n    ).chain((transaction) => {\n      /**\n       * We can first check container paths, which are in the transaction envelop\n       */\n      if (path === ContainerPath.FROM) {\n        // 'from' is not part of the unsigned ethereum transaction, and can\n        // only by recovered from the transaction signature later on.\n        // Therefore we cannot extract it from a transaction before signing it.\n        // It is not an issue since that field will typically be displayed as an\n        // address on the device and therefore don't require additional descriptors.\n        return Left(\n          new Error(\"Cannot get 'FROM' field of an unsigned transaction\"),\n        );\n      } else if (path === ContainerPath.TO) {\n        return Maybe.fromNullable(transaction.to)\n          .map((str) => hexaStringToBuffer(str))\n          .filter((bytes) => bytes !== null)\n          .map((bytes) => [bytes])\n          .toEither(new Error(\"Faild to extract TO field of transaction\"));\n      } else if (path === ContainerPath.VALUE) {\n        return Maybe.fromNullable(transaction.value)\n          .map((num) => new ByteArrayBuilder().add256BitUIntToData(num).build())\n          .map((bytes) => [bytes])\n          .toEither(new Error(\"Faild to extract VALUE field of transaction\"));\n      }\n\n      /**\n       * If it was not a path in the container, it means it's a path in the calldata\n       */\n      return Maybe.fromNullable(transaction.data)\n        .toEither(new Error(\"Transaction calldata is empty\"))\n        .chain((calldata) =>\n          Maybe.fromNullable(hexaStringToBuffer(calldata)).toEither(\n            new Error(`Invalid hex string calldata: ${calldata}`),\n          ),\n        )\n        .chain((calldata) => this.extractCalldataValue(calldata, path));\n    });\n  }\n\n  private extractCalldataValue(\n    data: Uint8Array,\n    path: DataPathElement[],\n  ): Either<Error, Uint8Array[]> {\n    data = data.slice(SELECTOR_LENGTH); // Remove the selector from the calldata\n    if (path.length === 0) {\n      return Left(new Error(\"Path is empty\"));\n    }\n    return this.extractCalldataValueAt(data, path, 0, 0);\n  }\n\n  private extractCalldataValueAt(\n    data: Uint8Array,\n    path: DataPathElement[],\n    offset: number,\n    parentOffset: number,\n  ): Either<Error, Uint8Array[]> {\n    // If the path ends with a slice, store it now as it is only allowed at the end of a binary path.\n    const lastElement = path[path.length - 1]!;\n    const leafSlice: DataPathElementSlice | null =\n      lastElement.type === DataPathElementType.SLICE ? lastElement : null;\n\n    while (path.length > 0) {\n      const element = path[0]!;\n      path = path.slice(1);\n      switch (element.type) {\n        case DataPathElementType.TUPLE:\n          // A tuple contain 1 element per chunk\n          parentOffset = offset;\n          offset += element.offset * CHUNK_SIZE;\n          break;\n        case DataPathElementType.ARRAY:\n          // An array contains a length, followed by the list of elements.\n          // See the examples with dynamic types at the top of this file for more informations.\n          return this.getU256(data.slice(offset))\n            .toEither(new Error(`Invalid array length at offset ${offset}`))\n            .chain((length) => {\n              // Skip the array length\n              offset += CHUNK_SIZE;\n              parentOffset = offset;\n              // Select the array slice to iterate on\n              const start =\n                element.start === undefined\n                  ? 0\n                  : element.start < 0\n                    ? length + element.start\n                    : element.start;\n              const end =\n                element.end === undefined\n                  ? length\n                  : element.end < 0\n                    ? length + element.end\n                    : element.end;\n              if (\n                start < 0 ||\n                start >= length ||\n                end > length ||\n                start >= end\n              ) {\n                return Left(\n                  new Error(\n                    `Array slice out of bounds, start=${element.start}, end=${element.end}`,\n                  ),\n                );\n              }\n              // Iterate on the array slice\n              return Array.from({ length: end - start }, (_, i) => i)\n                .map(\n                  (i) => offset + (i + start) * element.itemSize * CHUNK_SIZE,\n                )\n                .reduce(\n                  (acc: Either<Error, Uint8Array[]>, arrayOffset) =>\n                    acc.chain((values) =>\n                      this.extractCalldataValueAt(\n                        data,\n                        path,\n                        arrayOffset,\n                        parentOffset,\n                      ).map((newValues) => [...values, ...newValues]),\n                    ),\n                  Right([]),\n                );\n            });\n        case DataPathElementType.REF:\n          // A reference means the current slot points to a new offset in the calldata (a kind of pointer).\n          // That offset is relative to its 'parent' element, here named parentOffset.\n          // See the examples with dynamic types at the top of this file for more informations.\n          if (\n            this.getU256(data.slice(offset))\n              .ifJust((reference) => (offset = parentOffset + reference))\n              .isNothing()\n          ) {\n            return Left(new Error(`Invalid ref at offset ${offset}`));\n          }\n          break;\n        case DataPathElementType.LEAF:\n          // A leaf means we reached the end of the path.\n          // We have to check the leaf type to know how to extract the data.\n          switch (element.leafType) {\n            case DataPathLeafType.ARRAY_LEAF:\n              return Left(\n                new Error(\"Array leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.TUPLE_LEAF:\n              return Left(\n                new Error(\"Tuple leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.STATIC_LEAF:\n              // A static leaf is the chunk of current offset (data of static size)\n              return this.getSlice(data, offset, CHUNK_SIZE).chain((leaf) => {\n                if (leafSlice === null) {\n                  return Right([leaf]);\n                } else {\n                  return this.sliceLeaf(leaf, leafSlice);\n                }\n              });\n            case DataPathLeafType.DYNAMIC_LEAF:\n              // A dynamic leaf is composed of a length followed by the actual value\n              // (data of variable size such as a string).\n              // See the examples with dynamic types at the top of this file for more informations.\n              return this.getU256(data.slice(offset))\n                .toEither(new Error(`Invalid leaf length at offset ${offset}`))\n                .chain((length) => {\n                  // Skip dynamic leaf length\n                  offset += CHUNK_SIZE;\n                  return this.getSlice(data, offset, length).chain((leaf) => {\n                    if (leafSlice === null) {\n                      return Right([leaf]);\n                    } else {\n                      return this.sliceLeaf(leaf, leafSlice);\n                    }\n                  });\n                });\n          }\n          break;\n        case DataPathElementType.SLICE:\n          // If the last element was a slice, it was already popped at the beginning of this function\n          return Left(\n            new Error(\"Slice can only be used as last element of the path\"),\n          );\n      }\n    }\n    // We should have early-returned on a leaf\n    return Left(new Error(\"Path did not resolve to a leaf element\"));\n  }\n\n  private sliceLeaf(\n    data: Uint8Array,\n    leafSlice: DataPathElementSlice,\n  ): Either<Error, Uint8Array[]> {\n    const length = data.length;\n    const start =\n      leafSlice.start === undefined\n        ? 0\n        : leafSlice.start < 0\n          ? length + leafSlice.start\n          : leafSlice.start;\n    const end =\n      leafSlice.end === undefined\n        ? length\n        : leafSlice.end < 0\n          ? length + leafSlice.end\n          : leafSlice.end;\n    if (start >= end) {\n      return Left(new Error(`invalid leaf slice: start ${start}, end ${end}`));\n    }\n    return this.getSlice(data, start, end - start).map((leaf) => [leaf]);\n  }\n\n  getSlice(\n    data: Uint8Array,\n    offset: number,\n    size: number,\n  ): Either<Error, Uint8Array> {\n    return offset < 0 || data.length < offset + size\n      ? Left(\n          new Error(\n            `calldata too small to slice at offset ${offset} of length ${size}`,\n          ),\n        )\n      : Right(data.slice(offset, offset + size));\n  }\n\n  getU256(data: Uint8Array): Maybe<number> {\n    // https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding\n    return Maybe.fromNullable(new ByteArrayParser(data).extract256BitUInt(true))\n      .filter((res) => res <= Number.MAX_SAFE_INTEGER)\n      .map((res) => Number(res));\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["TransactionParserService_exports", "__export", "TransactionParserService", "__toCommonJS", "import_context_module", "import_device_management_kit", "import_ethers", "import_inversify", "import_purify_ts", "SELECTOR_LENGTH", "CHUNK_SIZE", "TransactionParserService", "serializedTransaction", "path", "transaction", "str", "bytes", "num", "calldata", "data", "offset", "parentOffset", "lastElement", "leafSlice", "element", "length", "start", "end", "_", "i", "acc", "arrayOffset", "values", "newValues", "reference", "leaf", "size", "res", "__decorateClass"]
+  "sourcesContent": ["import type {\n  DataPathElement,\n  DataPathElementSlice,\n  GenericPath,\n  TransactionSubset,\n} from \"@ledgerhq/context-module\";\nimport {\n  ContainerPath,\n  DataPathElementType,\n  DataPathLeafType,\n} from \"@ledgerhq/context-module\";\nimport {\n  ByteArrayBuilder,\n  ByteArrayParser,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { injectable } from \"inversify\";\nimport { Either, Left, Maybe, Right } from \"purify-ts\";\n\n/**\n * The goal of this service it to implement the GenericPath parser in the context\n * of an ethereum transaction.\n *\n * The abi of an ethereum transaction calldata is specified here:\n * https://docs.soliditylang.org/en/latest/abi-spec.html\n *\n * To be noted:\n *  - calldata is composed of:\n *    - the selector on 4 bytes\n *    - chunks of 32 bytes, whatever the size of the item contained in that chunk\n *    - static elements (fixed size) are encoded \"in-place\", always in 1 chunk padded with zeros\n *      (even a bool is on 32 bytes)\n *    - dynamic elements (variable size) are behind references (pointers) and then encoded with length+value\n *\n * Examples extracted from the abi specification:\n *  - example for a function with static elements:\n *    signature: baz(uint32 x, bool y)\n *    parameters: x = 69\n *                y = true\n *    - Encoding:\n *      0xcdcd77c0: the selector\n *      [0] 0x0000000000000000000000000000000000000000000000000000000000000045: value = 69\n *      [1] 0x0000000000000000000000000000000000000000000000000000000000000001: value = true\n *\n *  - example for a function with dynamic elements:\n *    signature: g(uint256[][] x, string[] x)\n *    parameters: x = [[1, 2], [3]]\n *                y = [\"one\", \"two\", \"three\"]\n *    - Encoding:\n *      0x2289b18c: the selector\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 */\nconst SELECTOR_LENGTH = 4;\nconst CHUNK_SIZE = 32;\n\n@injectable()\nexport class TransactionParserService {\n  public extractValue(\n    subset: TransactionSubset,\n    path: GenericPath,\n  ): Either<Error, Uint8Array[]> {\n    const { to, data, value } = subset;\n    /**\n     * We can first check container paths, which are in the transaction envelop\n     */\n    if (path === ContainerPath.FROM) {\n      // 'from' is not part of the unsigned ethereum transaction, and can\n      // only by recovered from the transaction signature later on.\n      // Therefore we cannot extract it from a transaction before signing it.\n      // It is not an issue since that field will typically be displayed as an\n      // address on the device and therefore don't require additional descriptors.\n      return Left(\n        new Error(\"Cannot get 'FROM' field of an unsigned transaction\"),\n      );\n    } else if (path === ContainerPath.TO) {\n      return Maybe.fromNullable(to)\n        .map((str) => hexaStringToBuffer(str))\n        .filter((bytes) => bytes !== null)\n        .map((bytes) => [bytes])\n        .toEither(new Error(\"Faild to extract TO field of transaction\"));\n    } else if (path === ContainerPath.VALUE) {\n      return Maybe.fromNullable(value)\n        .map((num) => new ByteArrayBuilder().add256BitUIntToData(num).build())\n        .map((bytes) => [bytes])\n        .toEither(new Error(\"Faild to extract VALUE field of transaction\"));\n    }\n\n    /**\n     * If it was not a path in the container, it means it's a path in the calldata\n     */\n    return Maybe.fromNullable(data)\n      .toEither(new Error(\"Transaction calldata is empty\"))\n      .chain((calldata) =>\n        Maybe.fromNullable(hexaStringToBuffer(calldata)).toEither(\n          new Error(`Invalid hex string calldata: ${calldata}`),\n        ),\n      )\n      .chain((calldata) => this.extractCalldataValue(calldata, path));\n  }\n\n  private extractCalldataValue(\n    data: Uint8Array,\n    path: DataPathElement[],\n  ): Either<Error, Uint8Array[]> {\n    data = data.slice(SELECTOR_LENGTH); // Remove the selector from the calldata\n    if (path.length === 0) {\n      return Left(new Error(\"Path is empty\"));\n    }\n    return this.extractCalldataValueAt(data, path, 0, 0);\n  }\n\n  private extractCalldataValueAt(\n    data: Uint8Array,\n    path: DataPathElement[],\n    offset: number,\n    parentOffset: number,\n  ): Either<Error, Uint8Array[]> {\n    // If the path ends with a slice, store it now as it is only allowed at the end of a binary path.\n    const lastElement = path[path.length - 1]!;\n    const leafSlice: DataPathElementSlice | null =\n      lastElement.type === DataPathElementType.SLICE ? lastElement : null;\n\n    while (path.length > 0) {\n      const element = path[0]!;\n      path = path.slice(1);\n      switch (element.type) {\n        case DataPathElementType.TUPLE:\n          // A tuple contain 1 element per chunk\n          parentOffset = offset;\n          offset += element.offset * CHUNK_SIZE;\n          break;\n        case DataPathElementType.ARRAY:\n          // An array contains a length, followed by the list of elements.\n          // See the examples with dynamic types at the top of this file for more informations.\n          return this.getU256(data.slice(offset))\n            .toEither(new Error(`Invalid array length at offset ${offset}`))\n            .chain((length) => {\n              // Skip the array length\n              offset += CHUNK_SIZE;\n              parentOffset = offset;\n              // Select the array slice to iterate on\n              const start =\n                element.start === undefined\n                  ? 0\n                  : element.start < 0\n                    ? length + element.start\n                    : element.start;\n              const end =\n                element.end === undefined\n                  ? length\n                  : element.end < 0\n                    ? length + element.end\n                    : element.end;\n              if (\n                start < 0 ||\n                start >= length ||\n                end > length ||\n                start >= end\n              ) {\n                return Left(\n                  new Error(\n                    `Array slice out of bounds, start=${element.start}, end=${element.end}`,\n                  ),\n                );\n              }\n              // Iterate on the array slice\n              return Array.from({ length: end - start }, (_, i) => i)\n                .map(\n                  (i) => offset + (i + start) * element.itemSize * CHUNK_SIZE,\n                )\n                .reduce(\n                  (acc: Either<Error, Uint8Array[]>, arrayOffset) =>\n                    acc.chain((values) =>\n                      this.extractCalldataValueAt(\n                        data,\n                        path,\n                        arrayOffset,\n                        parentOffset,\n                      ).map((newValues) => [...values, ...newValues]),\n                    ),\n                  Right([]),\n                );\n            });\n        case DataPathElementType.REF:\n          // A reference means the current slot points to a new offset in the calldata (a kind of pointer).\n          // That offset is relative to its 'parent' element, here named parentOffset.\n          // See the examples with dynamic types at the top of this file for more informations.\n          if (\n            this.getU256(data.slice(offset))\n              .ifJust((reference) => (offset = parentOffset + reference))\n              .isNothing()\n          ) {\n            return Left(new Error(`Invalid ref at offset ${offset}`));\n          }\n          break;\n        case DataPathElementType.LEAF:\n          // A leaf means we reached the end of the path.\n          // We have to check the leaf type to know how to extract the data.\n          switch (element.leafType) {\n            case DataPathLeafType.ARRAY_LEAF:\n              return Left(\n                new Error(\"Array leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.TUPLE_LEAF:\n              return Left(\n                new Error(\"Tuple leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.STATIC_LEAF:\n              // A static leaf is the chunk of current offset (data of static size)\n              return this.getSlice(data, offset, CHUNK_SIZE).chain((leaf) => {\n                if (leafSlice === null) {\n                  return Right([leaf]);\n                } else {\n                  return this.sliceLeaf(leaf, leafSlice);\n                }\n              });\n            case DataPathLeafType.DYNAMIC_LEAF:\n              // A dynamic leaf is composed of a length followed by the actual value\n              // (data of variable size such as a string).\n              // See the examples with dynamic types at the top of this file for more informations.\n              return this.getU256(data.slice(offset))\n                .toEither(new Error(`Invalid leaf length at offset ${offset}`))\n                .chain((length) => {\n                  // Skip dynamic leaf length\n                  offset += CHUNK_SIZE;\n                  return this.getSlice(data, offset, length).chain((leaf) => {\n                    if (leafSlice === null) {\n                      return Right([leaf]);\n                    } else {\n                      return this.sliceLeaf(leaf, leafSlice);\n                    }\n                  });\n                });\n          }\n          break;\n        case DataPathElementType.SLICE:\n          // If the last element was a slice, it was already popped at the beginning of this function\n          return Left(\n            new Error(\"Slice can only be used as last element of the path\"),\n          );\n      }\n    }\n    // We should have early-returned on a leaf\n    return Left(new Error(\"Path did not resolve to a leaf element\"));\n  }\n\n  private sliceLeaf(\n    data: Uint8Array,\n    leafSlice: DataPathElementSlice,\n  ): Either<Error, Uint8Array[]> {\n    const length = data.length;\n    const start =\n      leafSlice.start === undefined\n        ? 0\n        : leafSlice.start < 0\n          ? length + leafSlice.start\n          : leafSlice.start;\n    const end =\n      leafSlice.end === undefined\n        ? length\n        : leafSlice.end < 0\n          ? length + leafSlice.end\n          : leafSlice.end;\n    if (start >= end) {\n      return Left(new Error(`invalid leaf slice: start ${start}, end ${end}`));\n    }\n    return this.getSlice(data, start, end - start).map((leaf) => [leaf]);\n  }\n\n  getSlice(\n    data: Uint8Array,\n    offset: number,\n    size: number,\n  ): Either<Error, Uint8Array> {\n    return offset < 0 || data.length < offset + size\n      ? Left(\n          new Error(\n            `calldata too small to slice at offset ${offset} of length ${size}`,\n          ),\n        )\n      : Right(data.slice(offset, offset + size));\n  }\n\n  getU256(data: Uint8Array): Maybe<number> {\n    // https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding\n    return Maybe.fromNullable(new ByteArrayParser(data).extract256BitUInt(true))\n      .filter((res) => res <= Number.MAX_SAFE_INTEGER)\n      .map((res) => Number(res));\n  }\n}\n"],
+  "mappings": "2iBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,8BAAAE,IAAA,eAAAC,EAAAH,GAMA,IAAAI,EAIO,oCACPC,EAIO,2CACPC,EAA2B,qBAC3BC,EAA2C,qBAsD3C,MAAMC,EAAkB,EAClBC,EAAa,GAGZ,IAAMC,EAAN,KAA+B,CAC7B,aACLC,EACAC,EAC6B,CAC7B,KAAM,CAAE,GAAAC,EAAI,KAAAC,EAAM,MAAAC,CAAM,EAAIJ,EAI5B,OAAIC,IAAS,gBAAc,QAMlB,QACL,IAAI,MAAM,oDAAoD,CAChE,EACSA,IAAS,gBAAc,GACzB,QAAM,aAAaC,CAAE,EACzB,IAAKG,MAAQ,sBAAmBA,CAAG,CAAC,EACpC,OAAQC,GAAUA,IAAU,IAAI,EAChC,IAAKA,GAAU,CAACA,CAAK,CAAC,EACtB,SAAS,IAAI,MAAM,0CAA0C,CAAC,EACxDL,IAAS,gBAAc,MACzB,QAAM,aAAaG,CAAK,EAC5B,IAAKG,GAAQ,IAAI,mBAAiB,EAAE,oBAAoBA,CAAG,EAAE,MAAM,CAAC,EACpE,IAAKD,GAAU,CAACA,CAAK,CAAC,EACtB,SAAS,IAAI,MAAM,6CAA6C,CAAC,EAM/D,QAAM,aAAaH,CAAI,EAC3B,SAAS,IAAI,MAAM,+BAA+B,CAAC,EACnD,MAAOK,GACN,QAAM,gBAAa,sBAAmBA,CAAQ,CAAC,EAAE,SAC/C,IAAI,MAAM,gCAAgCA,CAAQ,EAAE,CACtD,CACF,EACC,MAAOA,GAAa,KAAK,qBAAqBA,EAAUP,CAAI,CAAC,CAClE,CAEQ,qBACNE,EACAF,EAC6B,CAE7B,OADAE,EAAOA,EAAK,MAAMN,CAAe,EAC7BI,EAAK,SAAW,KACX,QAAK,IAAI,MAAM,eAAe,CAAC,EAEjC,KAAK,uBAAuBE,EAAMF,EAAM,EAAG,CAAC,CACrD,CAEQ,uBACNE,EACAF,EACAQ,EACAC,EAC6B,CAE7B,MAAMC,EAAcV,EAAKA,EAAK,OAAS,CAAC,EAClCW,EACJD,EAAY,OAAS,sBAAoB,MAAQA,EAAc,KAEjE,KAAOV,EAAK,OAAS,GAAG,CACtB,MAAMY,EAAUZ,EAAK,CAAC,EAEtB,OADAA,EAAOA,EAAK,MAAM,CAAC,EACXY,EAAQ,KAAM,CACpB,KAAK,sBAAoB,MAEvBH,EAAeD,EACfA,GAAUI,EAAQ,OAASf,EAC3B,MACF,KAAK,sBAAoB,MAGvB,OAAO,KAAK,QAAQK,EAAK,MAAMM,CAAM,CAAC,EACnC,SAAS,IAAI,MAAM,kCAAkCA,CAAM,EAAE,CAAC,EAC9D,MAAOK,GAAW,CAEjBL,GAAUX,EACVY,EAAeD,EAEf,MAAMM,EACJF,EAAQ,QAAU,OACd,EACAA,EAAQ,MAAQ,EACdC,EAASD,EAAQ,MACjBA,EAAQ,MACVG,EACJH,EAAQ,MAAQ,OACZC,EACAD,EAAQ,IAAM,EACZC,EAASD,EAAQ,IACjBA,EAAQ,IAChB,OACEE,EAAQ,GACRA,GAASD,GACTE,EAAMF,GACNC,GAASC,KAEF,QACL,IAAI,MACF,oCAAoCH,EAAQ,KAAK,SAASA,EAAQ,GAAG,EACvE,CACF,EAGK,MAAM,KAAK,CAAE,OAAQG,EAAMD,CAAM,EAAG,CAACE,EAAGC,IAAMA,CAAC,EACnD,IACEA,GAAMT,GAAUS,EAAIH,GAASF,EAAQ,SAAWf,CACnD,EACC,OACC,CAACqB,EAAkCC,IACjCD,EAAI,MAAOE,GACT,KAAK,uBACHlB,EACAF,EACAmB,EACAV,CACF,EAAE,IAAKY,GAAc,CAAC,GAAGD,EAAQ,GAAGC,CAAS,CAAC,CAChD,KACF,SAAM,CAAC,CAAC,CACV,CACJ,CAAC,EACL,KAAK,sBAAoB,IAIvB,GACE,KAAK,QAAQnB,EAAK,MAAMM,CAAM,CAAC,EAC5B,OAAQc,GAAed,EAASC,EAAea,CAAU,EACzD,UAAU,EAEb,SAAO,QAAK,IAAI,MAAM,yBAAyBd,CAAM,EAAE,CAAC,EAE1D,MACF,KAAK,sBAAoB,KAGvB,OAAQI,EAAQ,SAAU,CACxB,KAAK,mBAAiB,WACpB,SAAO,QACL,IAAI,MAAM,+CAA+C,CAC3D,EACF,KAAK,mBAAiB,WACpB,SAAO,QACL,IAAI,MAAM,+CAA+C,CAC3D,EACF,KAAK,mBAAiB,YAEpB,OAAO,KAAK,SAASV,EAAMM,EAAQX,CAAU,EAAE,MAAO0B,GAChDZ,IAAc,QACT,SAAM,CAACY,CAAI,CAAC,EAEZ,KAAK,UAAUA,EAAMZ,CAAS,CAExC,EACH,KAAK,mBAAiB,aAIpB,OAAO,KAAK,QAAQT,EAAK,MAAMM,CAAM,CAAC,EACnC,SAAS,IAAI,MAAM,iCAAiCA,CAAM,EAAE,CAAC,EAC7D,MAAOK,IAENL,GAAUX,EACH,KAAK,SAASK,EAAMM,EAAQK,CAAM,EAAE,MAAOU,GAC5CZ,IAAc,QACT,SAAM,CAACY,CAAI,CAAC,EAEZ,KAAK,UAAUA,EAAMZ,CAAS,CAExC,EACF,CACP,CACA,MACF,KAAK,sBAAoB,MAEvB,SAAO,QACL,IAAI,MAAM,oDAAoD,CAChE,CACJ,CACF,CAEA,SAAO,QAAK,IAAI,MAAM,wCAAwC,CAAC,CACjE,CAEQ,UACNT,EACAS,EAC6B,CAC7B,MAAME,EAASX,EAAK,OACdY,EACJH,EAAU,QAAU,OAChB,EACAA,EAAU,MAAQ,EAChBE,EAASF,EAAU,MACnBA,EAAU,MACZI,EACJJ,EAAU,MAAQ,OACdE,EACAF,EAAU,IAAM,EACdE,EAASF,EAAU,IACnBA,EAAU,IAClB,OAAIG,GAASC,KACJ,QAAK,IAAI,MAAM,6BAA6BD,CAAK,SAASC,CAAG,EAAE,CAAC,EAElE,KAAK,SAASb,EAAMY,EAAOC,EAAMD,CAAK,EAAE,IAAKS,GAAS,CAACA,CAAI,CAAC,CACrE,CAEA,SACErB,EACAM,EACAgB,EAC2B,CAC3B,OAAOhB,EAAS,GAAKN,EAAK,OAASM,EAASgB,KACxC,QACE,IAAI,MACF,yCAAyChB,CAAM,cAAcgB,CAAI,EACnE,CACF,KACA,SAAMtB,EAAK,MAAMM,EAAQA,EAASgB,CAAI,CAAC,CAC7C,CAEA,QAAQtB,EAAiC,CAEvC,OAAO,QAAM,aAAa,IAAI,kBAAgBA,CAAI,EAAE,kBAAkB,EAAI,CAAC,EACxE,OAAQuB,GAAQA,GAAO,OAAO,gBAAgB,EAC9C,IAAKA,GAAQ,OAAOA,CAAG,CAAC,CAC7B,CACF,EAzOa3B,EAAN4B,EAAA,IADN,cAAW,GACC5B",
+  "names": ["TransactionParserService_exports", "__export", "TransactionParserService", "__toCommonJS", "import_context_module", "import_device_management_kit", "import_inversify", "import_purify_ts", "SELECTOR_LENGTH", "CHUNK_SIZE", "TransactionParserService", "subset", "path", "to", "data", "value", "str", "bytes", "num", "calldata", "offset", "parentOffset", "lastElement", "leafSlice", "element", "length", "start", "end", "_", "i", "acc", "arrayOffset", "values", "newValues", "reference", "leaf", "size", "res", "__decorateClass"]
 }

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

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

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/parser/TransactionParserService.test.ts"],
-  "sourcesContent": ["import { ContainerPath, type DataPathElement } from \"@ledgerhq/context-module\";\nimport {\n  bufferToHexaString,\n  ByteArrayBuilder,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { Transaction } from \"ethers\";\n\nimport { TransactionParserService } from \"./TransactionParserService\";\n\ndescribe(\"TransactionParserService\", () => {\n  const parser = new TransactionParserService();\n\n  const TO = hexaStringToBuffer(\"0x3f32cF0B1DF94157EE1c3876c49BE3732C92a98f\")!;\n  const VALUE = 81818275935222000n;\n  const VALUE_BIN = new ByteArrayBuilder()\n    .add256BitUIntToData(81818275935222000n)\n    .build();\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  describe(\"Container paths\", () => {\n    it(\"should extract TO of the container\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          to: bufferToHexaString(TO),\n          value: VALUE,\n          data: \"0x\",\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const value = parser.extractValue(transaction, ContainerPath.TO);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([TO]);\n    });\n\n    it(\"should extract VALUE of the container\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          to: bufferToHexaString(TO),\n          value: VALUE,\n          data: \"0x\",\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const value = parser.extractValue(transaction, ContainerPath.VALUE);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([VALUE_BIN]);\n    });\n\n    it(\"Unavailable container fields\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\n        Transaction.from({\n          data: \"0x\",\n          signature: {\n            r: \"0x73b969418389828a6328fdb96e747296226832894b8bb46d60f231a9960ec3b5\",\n            s: \"0x4806aaccc52354f4a42ef9efe0d89dd8cf95210829443ad7f4a9017d6b02de07\",\n            v: 1,\n          },\n        }).unsignedSerialized,\n      )!;\n\n      // WHEN\n      const from = parser.extractValue(transaction, ContainerPath.FROM);\n      const to = parser.extractValue(transaction, ContainerPath.TO);\n\n      // THEN\n      expect(from.isRight()).toStrictEqual(false);\n      expect(to.isRight()).toStrictEqual(false);\n    });\n\n    it(\"invalid transaction format\", () => {\n      // GIVEN\n      const transaction = hexaStringToBuffer(\"0xdeadbeef\")!;\n\n      // WHEN\n      const from = parser.extractValue(transaction, ContainerPath.FROM);\n\n      // THEN\n      expect(from.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Data paths in a calldata with static elements\", () => {\n    // Example from abi specification:\n    // https://docs.soliditylang.org/en/latest/abi-spec.html\n    //\n    // function baz(uint32 x, bool y)\n    // parameters: x = 69\n    //             y = true\n    // calldata:\n    //   0xcdcd77c0\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000045\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000001\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract the first element\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000045\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract the second element\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n      ]);\n    });\n\n    it(\"Slice the static leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: -4,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x00000045\")!,\n      ]);\n    });\n\n    it(\"Out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 2,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Data paths in a calldata with dynamic elements\", () => {\n    // Example from abi specification:\n    // https://docs.soliditylang.org/en/latest/abi-spec.html\n    //\n    // function g(uint256[][] x, string[] x)\n    // parameters: x = [[1, 2], [3]]\n    //             y = [\"one\", \"two\", \"three\"]\n    // calldata:\n    //   0x2289b18c\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000140: offset of y\n    //   [2] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x\n    //   [3] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x[0]\n    //   [4] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of x[1]\n    //   [5] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x[0]\n    //   [6] 0x0000000000000000000000000000000000000000000000000000000000000001: value of x[0][0] = 1\n    //   [7] 0x0000000000000000000000000000000000000000000000000000000000000002: value of x[0][1] = 2\n    //   [8] 0x0000000000000000000000000000000000000000000000000000000000000001: length of x[1]\n    //   [9] 0x0000000000000000000000000000000000000000000000000000000000000003: value of x[1][0] = 3\n    //   [10] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y\n    //   [11] 0x0000000000000000000000000000000000000000000000000000000000000060: offset of y[0]\n    //   [12] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of y[1]\n    //   [13] 0x00000000000000000000000000000000000000000000000000000000000000e0: offset of y[2]\n    //   [14] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[0]\n    //   [15] 0x6f6e650000000000000000000000000000000000000000000000000000000000: value of y[0] = \"one\"\n    //   [16] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[1]\n    //   [17] 0x74776f0000000000000000000000000000000000000000000000000000000000: value of y[1] = \"two\"\n    //   [18] 0x0000000000000000000000000000000000000000000000000000000000000005: length of y[2]\n    //   [19] 0x7468726565000000000000000000000000000000000000000000000000000000: value of y[2] = \"three\"\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0x2289b18c000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000036f6e650000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000374776f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000057468726565000000000000000000000000000000000000000000000000000000\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract all the elements of x, concatenated together\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000003\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[0]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[0:-1][-1:]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: -1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: -1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n      ]);\n    });\n\n    it(\"Array out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Extract all the elements of x[1]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6f6e65\")!,\n        hexaStringToBuffer(\"0x74776f\")!,\n        hexaStringToBuffer(\"0x7468726565\")!,\n      ]);\n    });\n\n    it(\"Extract all the elements of x[1][:2]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          end: 2,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6f6e65\")!,\n        hexaStringToBuffer(\"0x74776f\")!,\n      ]);\n    });\n\n    it(\"Slice the dynamic leaf with [1:-2]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: 1,\n          end: -2,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\"0x6872\")!,\n      ]);\n    });\n\n    it(\"Slice the dynamic leaf with [-1:]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: -1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([hexaStringToBuffer(\"0x65\")!]);\n    });\n\n    it(\"Slice the dynamic leaf with [:1]\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n          start: 2,\n          end: 3,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          end: 1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([hexaStringToBuffer(\"0x74\")!]);\n    });\n\n    it(\"Error no leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Error slice not at the end\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"SLICE\",\n          start: 0,\n          end: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Error empty slice\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n        {\n          type: \"SLICE\",\n          start: 0,\n          end: 0,\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n\n  describe(\"Array of tuples, with bigger itemSize\", () => {\n    // Example constructed with an array of tuples just for the tests\n    //\n    // function baz((uint32, uint32) myTuple[])\n    // parameters: myTuple = [ (1, 2), (3, 4), (5, 6) ]\n    // calldata:\n    //   0xcdcd77c0\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000020\n    //   [1] 0x0000000000000000000000000000000000000000000000000000000000000003\n    //   [2] 0x0000000000000000000000000000000000000000000000000000000000000001\n    //   [3] 0x0000000000000000000000000000000000000000000000000000000000000002\n    //   [4] 0x0000000000000000000000000000000000000000000000000000000000000003\n    //   [5] 0x0000000000000000000000000000000000000000000000000000000000000004\n    //   [6] 0x0000000000000000000000000000000000000000000000000000000000000005\n    //   [7] 0x0000000000000000000000000000000000000000000000000000000000000006\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0xcdcd77c000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Extract the first tuple element of all array elements\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 2,\n        },\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000001\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000003\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000005\",\n        )!,\n      ]);\n    });\n\n    it(\"Extract the second tuple element of all array elements\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 2,\n        },\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(true);\n      expect(value.unsafeCoerce()).toStrictEqual([\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000002\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000004\",\n        )!,\n        hexaStringToBuffer(\n          \"0x0000000000000000000000000000000000000000000000000000000000000006\",\n        )!,\n      ]);\n    });\n  });\n\n  describe(\"Malformed calldata\", () => {\n    // Example constructed with invalid data just for the tests\n    //\n    // calldata:\n    //   0x2289b18c\n    //   [0] 0x0000000000000000000000000000000000000000000000000000000000000080\n    //   [1] 0xf000000000000000000000000000000000000000000000000000000000000140\n    //   [2] 0xf000000000000000000000000000000000000000000000000000000000000002\n    const TX = hexaStringToBuffer(\n      Transaction.from({\n        to: bufferToHexaString(TO),\n        value: VALUE,\n        data: \"0x2289b18c0000000000000000000000000000000000000000000000000000000000000080f000000000000000000000000000000000000000000000000000000000000140f000000000000000000000000000000000000000000000000000000000000002\",\n      }).unsignedSerialized,\n    )!;\n\n    it(\"Dynamic leaf length overflow\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Calldata smaller than dynamic leaf\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"DYNAMIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Array length overflow\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Calldata smaller than array length\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 0,\n        },\n        {\n          type: \"ARRAY\",\n          itemSize: 1,\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n\n    it(\"Ref out of bounds\", () => {\n      // GIVEN\n      const path: DataPathElement[] = [\n        {\n          type: \"TUPLE\",\n          offset: 1,\n        },\n        {\n          type: \"REF\",\n        },\n        {\n          type: \"LEAF\",\n          leafType: \"STATIC_LEAF\",\n        },\n      ];\n\n      // WHEN\n      const value = parser.extractValue(TX, path);\n\n      // THEN\n      expect(value.isRight()).toStrictEqual(false);\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAAoD,oCACpDC,EAIO,2CACPC,EAA4B,kBAE5BC,EAAyC,sCAEzC,SAAS,2BAA4B,IAAM,CACzC,MAAMC,EAAS,IAAI,2BAEbC,KAAK,sBAAmB,4CAA4C,EACpEC,EAAQ,mBACRC,EAAY,IAAI,mBAAiB,EACpC,oBAAoB,kBAAkB,EACtC,MAAM,EAET,WAAW,IAAM,CACf,KAAK,cAAc,CACrB,CAAC,EAED,SAAS,kBAAmB,IAAM,CAChC,GAAG,qCAAsC,IAAM,CAE7C,MAAMC,KAAc,sBAClB,cAAY,KAAK,CACf,MAAI,sBAAmBH,CAAE,EACzB,MAAOC,EACP,KAAM,IACR,CAAC,EAAE,kBACL,EAGMG,EAAQL,EAAO,aAAaI,EAAa,gBAAc,EAAE,EAG/D,OAAOC,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,CAACJ,CAAE,CAAC,CACjD,CAAC,EAED,GAAG,wCAAyC,IAAM,CAEhD,MAAMG,KAAc,sBAClB,cAAY,KAAK,CACf,MAAI,sBAAmBH,CAAE,EACzB,MAAOC,EACP,KAAM,IACR,CAAC,EAAE,kBACL,EAGMG,EAAQL,EAAO,aAAaI,EAAa,gBAAc,KAAK,EAGlE,OAAOC,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,CAACF,CAAS,CAAC,CACxD,CAAC,EAED,GAAG,+BAAgC,IAAM,CAEvC,MAAMC,KAAc,sBAClB,cAAY,KAAK,CACf,KAAM,KACN,UAAW,CACT,EAAG,qEACH,EAAG,qEACH,EAAG,CACL,CACF,CAAC,EAAE,kBACL,EAGME,EAAON,EAAO,aAAaI,EAAa,gBAAc,IAAI,EAC1DG,EAAKP,EAAO,aAAaI,EAAa,gBAAc,EAAE,EAG5D,OAAOE,EAAK,QAAQ,CAAC,EAAE,cAAc,EAAK,EAC1C,OAAOC,EAAG,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC1C,CAAC,EAED,GAAG,6BAA8B,IAAM,CAErC,MAAMH,KAAc,sBAAmB,YAAY,EAG7CE,EAAON,EAAO,aAAaI,EAAa,gBAAc,IAAI,EAGhE,OAAOE,EAAK,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC5C,CAAC,CACH,CAAC,EAED,SAAS,gDAAiD,IAAM,CAW9D,MAAME,KAAK,sBACT,cAAY,KAAK,CACf,MAAI,sBAAmBP,CAAE,EACzB,MAAOC,EACP,KAAM,4IACR,CAAC,EAAE,kBACL,EAEA,GAAG,4BAA6B,IAAM,CAEpC,MAAMO,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,CACF,CAAC,CACH,CAAC,EAED,GAAG,6BAA8B,IAAM,CAErC,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,CACF,CAAC,CACH,CAAC,EAED,GAAG,wBAAyB,IAAM,CAEhC,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,aACZ,EACA,CACE,KAAM,QACN,MAAO,EACT,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBAAmB,YAAY,CACjC,CAAC,CACH,CAAC,EAED,GAAG,gBAAiB,IAAM,CAExB,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAEMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,CACH,CAAC,EAED,SAAS,iDAAkD,IAAM,CA6B/D,MAAMG,KAAK,sBACT,cAAY,KAAK,CACf,MAAI,sBAAmBP,CAAE,EACzB,MAAOC,EACP,KAAM,4wCACR,CAAC,EAAE,kBACL,EAEA,GAAG,uDAAwD,IAAM,CAE/D,MAAMO,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,KACA,sBACE,oEACF,KACA,sBACE,oEACF,CACF,CAAC,CACH,CAAC,EAED,GAAG,mCAAoC,IAAM,CAE3C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,KACA,sBACE,oEACF,CACF,CAAC,CACH,CAAC,EAED,GAAG,2CAA4C,IAAM,CAEnD,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,EACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACT,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,CACF,CAAC,CACH,CAAC,EAED,GAAG,sBAAuB,IAAM,CAE9B,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,mCAAoC,IAAM,CAE3C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,OACN,SAAU,cACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBAAmB,UAAU,KAC7B,sBAAmB,UAAU,KAC7B,sBAAmB,cAAc,CACnC,CAAC,CACH,CAAC,EAED,GAAG,uCAAwC,IAAM,CAE/C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,IAAK,CACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,OACN,SAAU,cACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBAAmB,UAAU,KAC7B,sBAAmB,UAAU,CAC/B,CAAC,CACH,CAAC,EAED,GAAG,qCAAsC,IAAM,CAE7C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,OACN,SAAU,cACZ,EACA,CACE,KAAM,QACN,MAAO,EACP,IAAK,EACP,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBAAmB,QAAQ,CAC7B,CAAC,CACH,CAAC,EAED,GAAG,oCAAqC,IAAM,CAE5C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,OACN,SAAU,cACZ,EACA,CACE,KAAM,QACN,MAAO,EACT,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IAAC,sBAAmB,MAAM,CAAE,CAAC,CAC1E,CAAC,EAED,GAAG,mCAAoC,IAAM,CAE3C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,EACV,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,OACN,SAAU,cACZ,EACA,CACE,KAAM,QACN,IAAK,CACP,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IAAC,sBAAmB,MAAM,CAAE,CAAC,CAC1E,CAAC,EAED,GAAG,gBAAiB,IAAM,CAExB,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,6BAA8B,IAAM,CAErC,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,QACN,MAAO,EACP,IAAK,CACP,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,oBAAqB,IAAM,CAE5B,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,cACZ,EACA,CACE,KAAM,QACN,MAAO,EACP,IAAK,CACP,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,CACH,CAAC,EAED,SAAS,wCAAyC,IAAM,CAetD,MAAMG,KAAK,sBACT,cAAY,KAAK,CACf,MAAI,sBAAmBP,CAAE,EACzB,MAAOC,EACP,KAAM,4gBACR,CAAC,EAAE,kBACL,EAEA,GAAG,wDAAyD,IAAM,CAEhE,MAAMO,EAA0B,CAC9B,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,KACA,sBACE,oEACF,KACA,sBACE,oEACF,CACF,CAAC,CACH,CAAC,EAED,GAAG,yDAA0D,IAAM,CAEjE,MAAMI,EAA0B,CAC9B,CACE,KAAM,KACR,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAI,EAC1C,OAAOA,EAAM,aAAa,CAAC,EAAE,cAAc,IACzC,sBACE,oEACF,KACA,sBACE,oEACF,KACA,sBACE,oEACF,CACF,CAAC,CACH,CAAC,CACH,CAAC,EAED,SAAS,qBAAsB,IAAM,CAQnC,MAAMG,KAAK,sBACT,cAAY,KAAK,CACf,MAAI,sBAAmBP,CAAE,EACzB,MAAOC,EACP,KAAM,4MACR,CAAC,EAAE,kBACL,EAEA,GAAG,+BAAgC,IAAM,CAEvC,MAAMO,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,cACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,qCAAsC,IAAM,CAE7C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,OACN,SAAU,cACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,wBAAyB,IAAM,CAEhC,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,qCAAsC,IAAM,CAE7C,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,QACN,SAAU,CACZ,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,EAED,GAAG,oBAAqB,IAAM,CAE5B,MAAMI,EAA0B,CAC9B,CACE,KAAM,QACN,OAAQ,CACV,EACA,CACE,KAAM,KACR,EACA,CACE,KAAM,OACN,SAAU,aACZ,CACF,EAGMJ,EAAQL,EAAO,aAAaQ,EAAIC,CAAI,EAG1C,OAAOJ,EAAM,QAAQ,CAAC,EAAE,cAAc,EAAK,CAC7C,CAAC,CACH,CAAC,CACH,CAAC",
-  "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});\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/internal/transaction/use-case/SignTransactionUseCase.test.js

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

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

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

package/lib/cjs/internal/typed-data/di/typedDataModule.js

@@ -1,2 +1,2 @@
-"use strict";var i=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var D=Object.prototype.hasOwnProperty;var c=(e,t)=>{for(var o in t)i(e,o,{get:t[o],enumerable:!0})},u=(e,t,o,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of m(t))!D.call(e,a)&&a!==o&&i(e,a,{get:()=>t[a],enumerable:!(r=y(t,a))||r.enumerable});return e};var _=e=>u(i({},"__esModule",{value:!0}),e);var T={};c(T,{typedDataModuleFactory:()=>f});module.exports=_(T);var p=require("inversify"),n=require("../../typed-data/di/typedDataTypes"),d=require("../../typed-data/service/DefaultTypedDataParserService"),s=require("../../typed-data/use-case/SignTypedDataUseCase");const f=()=>new p.ContainerModule((e,t,o,r,a,v,S)=>{e(n.typedDataTypes.SignTypedDataUseCase).to(s.SignTypedDataUseCase),e(n.typedDataTypes.TypedDataParserService).to(d.DefaultTypedDataParserService)});0&&(module.exports={typedDataModuleFactory});
+"use strict";var o=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var D=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var n=(e,a)=>{for(var r in a)o(e,r,{get:a[r],enumerable:!0})},T=(e,a,r,i)=>{if(a&&typeof a=="object"||typeof a=="function")for(let t of D(a))!f.call(e,t)&&t!==r&&o(e,t,{get:()=>a[t],enumerable:!(i=d(a,t))||i.enumerable});return e};var c=e=>T(o({},"__esModule",{value:!0}),e);var l={};n(l,{typedDataModuleFactory:()=>S});module.exports=c(l);var m=require("inversify"),p=require("../../typed-data/di/typedDataTypes"),s=require("../../typed-data/service/DefaultTypedDataParserService"),y=require("../../typed-data/use-case/SignTypedDataUseCase");const S=()=>new m.ContainerModule(({bind:e})=>{e(p.typedDataTypes.SignTypedDataUseCase).to(y.SignTypedDataUseCase),e(p.typedDataTypes.TypedDataParserService).to(s.DefaultTypedDataParserService)});0&&(module.exports={typedDataModuleFactory});
 //# sourceMappingURL=typedDataModule.js.map

package/lib/cjs/internal/typed-data/di/typedDataModule.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/typed-data/di/typedDataModule.ts"],
-  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { typedDataTypes } from \"@internal/typed-data/di/typedDataTypes\";\nimport { DefaultTypedDataParserService } from \"@internal/typed-data/service/DefaultTypedDataParserService\";\nimport { SignTypedDataUseCase } from \"@internal/typed-data/use-case/SignTypedDataUseCase\";\n\nexport const typedDataModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(typedDataTypes.SignTypedDataUseCase).to(SignTypedDataUseCase);\n      bind(typedDataTypes.TypedDataParserService).to(\n        DefaultTypedDataParserService,\n      );\n    },\n  );\n"],
-  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAA+B,kDAC/BC,EAA8C,sEAC9CC,EAAqC,8DAE9B,MAAML,EAAyB,IACpC,IAAI,kBACF,CACEM,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAK,iBAAe,oBAAoB,EAAE,GAAG,sBAAoB,EACjEA,EAAK,iBAAe,sBAAsB,EAAE,GAC1C,+BACF,CACF,CACF",
-  "names": ["typedDataModule_exports", "__export", "typedDataModuleFactory", "__toCommonJS", "import_inversify", "import_typedDataTypes", "import_DefaultTypedDataParserService", "import_SignTypedDataUseCase", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { typedDataTypes } from \"@internal/typed-data/di/typedDataTypes\";\nimport { DefaultTypedDataParserService } from \"@internal/typed-data/service/DefaultTypedDataParserService\";\nimport { SignTypedDataUseCase } from \"@internal/typed-data/use-case/SignTypedDataUseCase\";\n\nexport const typedDataModuleFactory = () =>\n  new ContainerModule(({ bind }) => {\n    bind(typedDataTypes.SignTypedDataUseCase).to(SignTypedDataUseCase);\n    bind(typedDataTypes.TypedDataParserService).to(\n      DefaultTypedDataParserService,\n    );\n  });\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAgC,qBAEhCC,EAA+B,kDAC/BC,EAA8C,sEAC9CC,EAAqC,8DAE9B,MAAML,EAAyB,IACpC,IAAI,kBAAgB,CAAC,CAAE,KAAAM,CAAK,IAAM,CAChCA,EAAK,iBAAe,oBAAoB,EAAE,GAAG,sBAAoB,EACjEA,EAAK,iBAAe,sBAAsB,EAAE,GAC1C,+BACF,CACF,CAAC",
+  "names": ["typedDataModule_exports", "__export", "typedDataModuleFactory", "__toCommonJS", "import_inversify", "import_typedDataTypes", "import_DefaultTypedDataParserService", "import_SignTypedDataUseCase", "bind"]
 }

package/lib/cjs/internal/typed-data/di/typedDataModule.test.js

@@ -1,2 +1,2 @@
-"use strict";var o=require("inversify"),a=require("./typedDataModule");describe("TypedDataModuleFactory",()=>{describe("Default",()=>{let t,e;beforeEach(()=>{e=(0,a.typedDataModuleFactory)(),t=new o.Container,t.load(e)}),it("should return the typed data module",()=>{expect(e).toBeDefined()})})});
+"use strict";var o=require("inversify"),a=require("./typedDataModule");describe("TypedDataModuleFactory",()=>{describe("Default",()=>{let t,e;beforeEach(()=>{e=(0,a.typedDataModuleFactory)(),t=new o.Container,t.loadSync(e)}),it("should return the typed data module",()=>{expect(e).toBeDefined()})})});
 //# sourceMappingURL=typedDataModule.test.js.map

package/lib/cjs/internal/typed-data/di/typedDataModule.test.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/typed-data/di/typedDataModule.test.ts"],
-  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { typedDataModuleFactory } from \"./typedDataModule\";\n\ndescribe(\"TypedDataModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof typedDataModuleFactory>;\n    beforeEach(() => {\n      mod = typedDataModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the typed data module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
-  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAuC,6BAEvC,SAAS,yBAA0B,IAAM,CACvC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,0BAAuB,EAC7BD,EAAY,IAAI,YAChBA,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,sCAAuC,IAAM,CAC9C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { typedDataModuleFactory } from \"./typedDataModule\";\n\ndescribe(\"TypedDataModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof typedDataModuleFactory>;\n    beforeEach(() => {\n      mod = typedDataModuleFactory();\n      container = new Container();\n      container.loadSync(mod);\n    });\n\n    it(\"should return the typed data module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
+  "mappings": "aAAA,IAAAA,EAA0B,qBAE1BC,EAAuC,6BAEvC,SAAS,yBAA0B,IAAM,CACvC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,KAAM,0BAAuB,EAC7BD,EAAY,IAAI,YAChBA,EAAU,SAASC,CAAG,CACxB,CAAC,EAED,GAAG,sCAAuC,IAAM,CAC9C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
   "names": ["import_inversify", "import_typedDataModule", "container", "mod"]
 }

package/lib/cjs/internal/typed-data/service/DefaultTypedDataParserService.js

@@ -1,2 +1,2 @@
-"use strict";var i=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var E=Object.prototype.hasOwnProperty;var f=(o,r)=>{for(var s in r)i(o,s,{get:r[s],enumerable:!0})},h=(o,r,s,t)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of g(r))!E.call(o,e)&&e!==s&&i(o,e,{get:()=>r[e],enumerable:!(t=a(r,e))||t.enumerable});return o};var D=o=>h(i({},"__esModule",{value:!0}),o),c=(o,r,s,t)=>{for(var e=t>1?void 0:t?a(r,s):r,p=o.length-1,m;p>=0;p--)(m=o[p])&&(e=(t?m(r,s,e):m(e))||e);return t&&e&&i(r,s,e),e};var P={};f(P,{DefaultTypedDataParserService:()=>n});module.exports=D(P);var y=require("inversify"),d=require("./TypedDataParser");let n=class{parse(r){const s=new d.TypedDataParser(r.types),t=s.getStructDefinitions(),e=s.parse("EIP712Domain",r.domain),p=s.parse(r.primaryType,r.message);return e.chain(m=>p.map(T=>({types:t,domain:m,message:T})))}};n=c([(0,y.injectable)()],n);0&&(module.exports={DefaultTypedDataParserService});
+"use strict";var i=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var E=Object.prototype.hasOwnProperty;var f=(o,r)=>{for(var s in r)i(o,s,{get:r[s],enumerable:!0})},h=(o,r,s,t)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of g(r))!E.call(o,e)&&e!==s&&i(o,e,{get:()=>r[e],enumerable:!(t=a(r,e))||t.enumerable});return o};var D=o=>h(i({},"__esModule",{value:!0}),o),c=(o,r,s,t)=>{for(var e=t>1?void 0:t?a(r,s):r,m=o.length-1,p;m>=0;m--)(p=o[m])&&(e=(t?p(r,s,e):p(e))||e);return t&&e&&i(r,s,e),e};var P={};f(P,{DefaultTypedDataParserService:()=>n});module.exports=D(P);var y=require("inversify"),d=require("./TypedDataParser");let n=class{parse(r){const s=new d.TypedDataParser(r.types,r.domain),t=s.getStructDefinitions(),e=s.parse("EIP712Domain",r.domain),m=s.parse(r.primaryType,r.message);return e.chain(p=>m.map(T=>({types:t,domain:p,message:T})))}};n=c([(0,y.injectable)()],n);0&&(module.exports={DefaultTypedDataParserService});
 //# sourceMappingURL=DefaultTypedDataParserService.js.map

package/lib/cjs/internal/typed-data/service/DefaultTypedDataParserService.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/typed-data/service/DefaultTypedDataParserService.ts"],
-  "sourcesContent": ["import { injectable } from \"inversify\";\nimport { Either } from \"purify-ts\";\n\nimport { TypedData } from \"@api/model/TypedData\";\n\nimport { TypedDataParser } from \"./TypedDataParser\";\nimport {\n  ParsedTypedData,\n  TypedDataParserService,\n} from \"./TypedDataParserService\";\n\n@injectable()\nexport class DefaultTypedDataParserService implements TypedDataParserService {\n  parse(data: TypedData): Either<Error, ParsedTypedData> {\n    const parser = new TypedDataParser(data.types);\n    const types = parser.getStructDefinitions();\n    const domainResult = parser.parse(\n      \"EIP712Domain\",\n      data.domain as Record<string, unknown>,\n    );\n    const messageResult = parser.parse(data.primaryType, data.message);\n    return domainResult.chain((domain) =>\n      messageResult.map((message) => ({\n        types,\n        domain,\n        message,\n      })),\n    );\n  }\n}\n"],
-  "mappings": "2iBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAA2B,qBAK3BC,EAAgC,6BAOzB,IAAMC,EAAN,KAAsE,CAC3E,MAAMC,EAAiD,CACrD,MAAMC,EAAS,IAAI,kBAAgBD,EAAK,KAAK,EACvCE,EAAQD,EAAO,qBAAqB,EACpCE,EAAeF,EAAO,MAC1B,eACAD,EAAK,MACP,EACMI,EAAgBH,EAAO,MAAMD,EAAK,YAAaA,EAAK,OAAO,EACjE,OAAOG,EAAa,MAAOE,GACzBD,EAAc,IAAKE,IAAa,CAC9B,MAAAJ,EACA,OAAAG,EACA,QAAAC,CACF,EAAE,CACJ,CACF,CACF,EAjBaP,EAANQ,EAAA,IADN,cAAW,GACCR",
+  "sourcesContent": ["import { injectable } from \"inversify\";\nimport { Either } from \"purify-ts\";\n\nimport { TypedData } from \"@api/model/TypedData\";\n\nimport { TypedDataParser } from \"./TypedDataParser\";\nimport {\n  ParsedTypedData,\n  TypedDataParserService,\n} from \"./TypedDataParserService\";\n\n@injectable()\nexport class DefaultTypedDataParserService implements TypedDataParserService {\n  parse(data: TypedData): Either<Error, ParsedTypedData> {\n    const parser = new TypedDataParser(data.types, data.domain);\n    const types = parser.getStructDefinitions();\n    const domainResult = parser.parse(\n      \"EIP712Domain\",\n      data.domain as Record<string, unknown>,\n    );\n    const messageResult = parser.parse(data.primaryType, data.message);\n    return domainResult.chain((domain) =>\n      messageResult.map((message) => ({\n        types,\n        domain,\n        message,\n      })),\n    );\n  }\n}\n"],
+  "mappings": "2iBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAA2B,qBAK3BC,EAAgC,6BAOzB,IAAMC,EAAN,KAAsE,CAC3E,MAAMC,EAAiD,CACrD,MAAMC,EAAS,IAAI,kBAAgBD,EAAK,MAAOA,EAAK,MAAM,EACpDE,EAAQD,EAAO,qBAAqB,EACpCE,EAAeF,EAAO,MAC1B,eACAD,EAAK,MACP,EACMI,EAAgBH,EAAO,MAAMD,EAAK,YAAaA,EAAK,OAAO,EACjE,OAAOG,EAAa,MAAOE,GACzBD,EAAc,IAAKE,IAAa,CAC9B,MAAAJ,EACA,OAAAG,EACA,QAAAC,CACF,EAAE,CACJ,CACF,CACF,EAjBaP,EAANQ,EAAA,IADN,cAAW,GACCR",
   "names": ["DefaultTypedDataParserService_exports", "__export", "DefaultTypedDataParserService", "__toCommonJS", "import_inversify", "import_TypedDataParser", "DefaultTypedDataParserService", "data", "parser", "types", "domainResult", "messageResult", "domain", "message", "__decorateClass"]
 }