npm - @ledgerhq/device-signer-kit-ethereum - Versions diffs - 1.1.0 → 1.2.0 - Mend

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

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

Files changed (487) hide show

package/lib/cjs/internal/transaction/service/mapper/TransactionMapper.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var e=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var c=(r,a,n,p)=>{if(a&&typeof a=="object"||typeof a=="function")for(let t of i(a))!s.call(r,t)&&t!==n&&e(r,t,{get:()=>a[t],enumerable:!(p=o(a,t))||p.enumerable});return r};var m=r=>c(e({},"__esModule",{value:!0}),r);var y={};module.exports=m(y);
+"use strict";var p=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var c=(r,a,n,e)=>{if(a&&typeof a=="object"||typeof a=="function")for(let t of i(a))!s.call(r,t)&&t!==n&&p(r,t,{get:()=>a[t],enumerable:!(e=o(a,t))||e.enumerable});return r};var m=r=>c(p({},"__esModule",{value:!0}),r);var y={};module.exports=m(y);
 //# sourceMappingURL=TransactionMapper.js.map

package/lib/cjs/internal/transaction/service/mapper/TransactionMapper.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapper.ts"],
-  "sourcesContent": ["import { type Maybe } from \"purify-ts\";\n\nimport { type Transaction } from \"@api/index\";\n\nimport { type TransactionMapperResult } from \"./model/TransactionMapperResult\";\n\nexport interface TransactionMapper {\n  map(transaction: Transaction): Maybe<TransactionMapperResult>;\n}\n"],
+  "sourcesContent": ["import { type Maybe } from \"purify-ts\";\n\nimport { type TransactionMapperResult } from \"./model/TransactionMapperResult\";\n\nexport interface TransactionMapper {\n  map(transaction: Uint8Array): Maybe<TransactionMapperResult>;\n}\n"],
   "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
   "names": ["TransactionMapper_exports", "__toCommonJS"]
 }

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

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

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

@@ -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 { Transaction } from \"@api/index\";\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: Transaction,\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,qBAGpCC,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",
+  "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"]
 }

package/lib/cjs/internal/transaction/service/mapper/TransactionMapperService.test.js CHANGED Viewed

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

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.test.ts"],
-  "sourcesContent": ["import { type TransactionSubset } from \"@ledgerhq/context-module\";\nimport { Just, type Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { type Transaction } from \"@api/index\";\n\nimport { TransactionMapperService } from \"./TransactionMapperService\";\n\nconst transactionMapperBuilder = (value?: Maybe<TransactionSubset>) => {\n  const map = jest.fn().mockReturnValue(value);\n  return { map };\n};\n\ndescribe(\"TransactionMapperService\", () => {\n  let service: TransactionMapperService;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  it(\"should return a TransactionSubset\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Just({ data: \"data\" } as TransactionSubset)),\n      transactionMapperBuilder(Nothing),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset({} as Transaction);\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).not.toHaveBeenCalled();\n    expect(result).toEqual(Right({ data: \"data\" }));\n  });\n\n  it(\"should return a TransactionSubset for the second mapper\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Nothing),\n      transactionMapperBuilder(Just({ data: \"data-2\" } as TransactionSubset)),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset({} as Transaction);\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).toHaveBeenCalled();\n    expect(result).toEqual(Right({ data: \"data-2\" }));\n  });\n\n  it(\"should return an error\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Nothing),\n      transactionMapperBuilder(Nothing),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset({} as Transaction);\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).toHaveBeenCalled();\n    expect(result.isLeft()).toBeTruthy();\n  });\n});\n"],
-  "mappings": "aACA,IAAAA,EAAiD,qBAIjDC,EAAyC,sCAEzC,MAAMC,EAA4BC,IAEzB,CAAE,IADG,KAAK,GAAG,EAAE,gBAAgBA,CAAK,CAC9B,GAGf,SAAS,2BAA4B,IAAM,CACzC,IAAIC,EAEJ,WAAW,IAAM,CACf,KAAK,cAAc,CACrB,CAAC,EAED,GAAG,oCAAqC,IAAM,CAE5C,MAAMC,EAAU,CACdH,KAAyB,QAAK,CAAE,KAAM,MAAO,CAAsB,CAAC,EACpEA,EAAyB,SAAO,CAClC,EACAE,EAAU,IAAI,2BAAyBC,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,CAAC,CAAgB,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,IAAI,iBAAiB,EAC7C,OAAOC,CAAM,EAAE,WAAQ,SAAM,CAAE,KAAM,MAAO,CAAC,CAAC,CAChD,CAAC,EAED,GAAG,0DAA2D,IAAM,CAElE,MAAMD,EAAU,CACdH,EAAyB,SAAO,EAChCA,KAAyB,QAAK,CAAE,KAAM,QAAS,CAAsB,CAAC,CACxE,EACAE,EAAU,IAAI,2BAAyBC,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,CAAC,CAAgB,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,CAAM,EAAE,WAAQ,SAAM,CAAE,KAAM,QAAS,CAAC,CAAC,CAClD,CAAC,EAED,GAAG,yBAA0B,IAAM,CAEjC,MAAMD,EAAU,CACdH,EAAyB,SAAO,EAChCA,EAAyB,SAAO,CAClC,EACAE,EAAU,IAAI,2BAAyBC,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,CAAC,CAAgB,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,CACrC,CAAC,CACH,CAAC",
+  "sourcesContent": ["import { type TransactionSubset } from \"@ledgerhq/context-module\";\nimport { Just, type Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { TransactionMapperService } from \"./TransactionMapperService\";\n\nconst transactionMapperBuilder = (value?: Maybe<TransactionSubset>) => {\n  const map = vi.fn().mockReturnValue(value);\n  return { map };\n};\n\ndescribe(\"TransactionMapperService\", () => {\n  let service: TransactionMapperService;\n\n  beforeEach(() => {\n    vi.clearAllMocks();\n  });\n\n  it(\"should return a TransactionSubset\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Just({ data: \"data\" } as TransactionSubset)),\n      transactionMapperBuilder(Nothing),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset(new Uint8Array(0));\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).not.toHaveBeenCalled();\n    expect(result).toEqual(Right({ data: \"data\" }));\n  });\n\n  it(\"should return a TransactionSubset for the second mapper\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Nothing),\n      transactionMapperBuilder(Just({ data: \"data-2\" } as TransactionSubset)),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset(new Uint8Array(0));\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).toHaveBeenCalled();\n    expect(result).toEqual(Right({ data: \"data-2\" }));\n  });\n\n  it(\"should return an error\", () => {\n    // GIVEN\n    const mappers = [\n      transactionMapperBuilder(Nothing),\n      transactionMapperBuilder(Nothing),\n    ];\n    service = new TransactionMapperService(mappers);\n\n    // WHEN\n    const result = service.mapTransactionToSubset(new Uint8Array(0));\n\n    // THEN\n    expect(mappers[0]!.map).toHaveBeenCalled();\n    expect(mappers[1]!.map).toHaveBeenCalled();\n    expect(result.isLeft()).toBeTruthy();\n  });\n});\n"],
+  "mappings": "aACA,IAAAA,EAAiD,qBAEjDC,EAAyC,sCAEzC,MAAMC,EAA4BC,IAEzB,CAAE,IADG,GAAG,GAAG,EAAE,gBAAgBA,CAAK,CAC5B,GAGf,SAAS,2BAA4B,IAAM,CACzC,IAAIC,EAEJ,WAAW,IAAM,CACf,GAAG,cAAc,CACnB,CAAC,EAED,GAAG,oCAAqC,IAAM,CAE5C,MAAMC,EAAU,CACdH,KAAyB,QAAK,CAAE,KAAM,MAAO,CAAsB,CAAC,EACpEA,EAAyB,SAAO,CAClC,EACAE,EAAU,IAAI,2BAAyBC,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,IAAI,WAAW,CAAC,CAAC,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,IAAI,iBAAiB,EAC7C,OAAOC,CAAM,EAAE,WAAQ,SAAM,CAAE,KAAM,MAAO,CAAC,CAAC,CAChD,CAAC,EAED,GAAG,0DAA2D,IAAM,CAElE,MAAMD,EAAU,CACdH,EAAyB,SAAO,EAChCA,KAAyB,QAAK,CAAE,KAAM,QAAS,CAAsB,CAAC,CACxE,EACAE,EAAU,IAAI,2BAAyBC,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,IAAI,WAAW,CAAC,CAAC,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,CAAM,EAAE,WAAQ,SAAM,CAAE,KAAM,QAAS,CAAC,CAAC,CAClD,CAAC,EAED,GAAG,yBAA0B,IAAM,CAEjC,MAAMD,EAAU,CACdH,EAAyB,SAAO,EAChCA,EAAyB,SAAO,CAClC,EACAE,EAAU,IAAI,2BAAyBC,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,IAAI,WAAW,CAAC,CAAC,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,EAAO,OAAO,CAAC,EAAE,WAAW,CACrC,CAAC,CACH,CAAC",
   "names": ["import_purify_ts", "import_TransactionMapperService", "transactionMapperBuilder", "value", "service", "mappers", "result"]
 }

package/lib/cjs/internal/transaction/service/mapper/model/TransactionMapperResult.js CHANGED Viewed

@@ -1,2 +1,2 @@
-"use strict";var n=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var T=(a,t,i,e)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of s(t))!p.call(a,r)&&r!==i&&n(a,r,{get:()=>t[r],enumerable:!(e=o(t,r))||e.enumerable});return a};var c=a=>T(n({},"__esModule",{value:!0}),a);var y={};module.exports=c(y);
+"use strict";var n=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var T=(a,t,i,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of p(t))!s.call(a,e)&&e!==i&&n(a,e,{get:()=>t[e],enumerable:!(r=o(t,e))||r.enumerable});return a};var y=a=>T(n({},"__esModule",{value:!0}),a);var c={};module.exports=y(c);
 //# sourceMappingURL=TransactionMapperResult.js.map

package/lib/cjs/internal/transaction/service/mapper/model/TransactionMapperResult.js.map CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../../src/internal/transaction/service/mapper/model/TransactionMapperResult.ts"],
-  "sourcesContent": ["import { type TransactionSubset } from \"@ledgerhq/context-module\";\n\nimport type { TransactionType } from \"@api/model/Transaction\";\n\nexport type TransactionMapperResult = {\n  /**\n   * transaction attributes used for clear signing\n   */\n  subset: TransactionSubset;\n\n  /**\n   * serializedTransaction transaction in Uint8Array format\n   */\n  serializedTransaction: Uint8Array;\n\n  /**\n   * The ethereum transaction type as according to eip-2718 transactions\n   * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2718.md\n   */\n  type: TransactionType;\n};\n"],
+  "sourcesContent": ["import { type TransactionSubset } from \"@ledgerhq/context-module\";\n\nimport type { TransactionType } from \"@api/model/TransactionType\";\n\nexport type TransactionMapperResult = {\n  /**\n   * transaction attributes used for clear signing\n   */\n  subset: TransactionSubset;\n\n  /**\n   * serializedTransaction transaction in Uint8Array format\n   */\n  serializedTransaction: Uint8Array;\n\n  /**\n   * The ethereum transaction type as according to eip-2718 transactions\n   * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2718.md\n   */\n  type: TransactionType;\n};\n"],
   "mappings": "+WAAA,IAAAA,EAAA,kBAAAC,EAAAD",
   "names": ["TransactionMapperResult_exports", "__toCommonJS"]
 }

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

@@ -1,2 +1,2 @@
-"use strict";var y=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var C=Object.prototype.hasOwnProperty;var P=(o,e)=>{for(var r in e)y(o,r,{get:e[r],enumerable:!0})},I=(o,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of x(e))!C.call(o,t)&&t!==r&&y(o,t,{get:()=>e[t],enumerable:!(n=p(e,t))||n.enumerable});return o};var N=o=>I(y({},"__esModule",{value:!0}),o),U=(o,e,r,n)=>{for(var t=n>1?void 0:n?p(e,r):e,u=o.length-1,h;u>=0;u--)(h=o[u])&&(t=(n?h(e,r,t):h(t))||t);return n&&t&&y(e,r,t),t};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-v6"),L=require("inversify"),a=require("purify-ts");const F=4,m=32;let d=class{extractValue(e,r){return a.Either.encase(()=>w.Transaction.from((0,s.bufferToHexaString)(e))).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(t=>(0,s.hexaStringToBuffer)(t)).filter(t=>t!==null).map(t=>[t]).toEither(new Error("Faild to extract TO field of transaction")):r===i.ContainerPath.VALUE?a.Maybe.fromNullable(n.value).map(t=>new s.ByteArrayBuilder().add256BitUIntToData(t).build()).map(t=>[t]).toEither(new Error("Faild to extract VALUE field of transaction")):a.Maybe.fromNullable(n.data).toEither(new Error("Transaction calldata is empty")).chain(t=>a.Maybe.fromNullable((0,s.hexaStringToBuffer)(t)).toEither(new Error(`Invalid hex string calldata: ${t}`))).chain(t=>this.extractCalldataValue(t,r)))}extractCalldataValue(e,r){return e=e.slice(F),r.length===0?(0,a.Left)(new Error("Path is empty")):this.extractCalldataValueAt(e,r,0,0)}extractCalldataValueAt(e,r,n,t){const u=r[r.length-1],h=u.type===i.DataPathElementType.SLICE?u:null;for(;r.length>0;){const l=r[0];switch(r=r.slice(1),l.type){case i.DataPathElementType.TUPLE:t=n,n+=l.offset*m;break;case i.DataPathElementType.ARRAY:return this.getU256(e.slice(n)).toEither(new Error(`Invalid array length at offset ${n}`)).chain(E=>{n+=m,t=n;const c=l.start===void 0?0:l.start<0?E+l.start:l.start,g=l.length===void 0?E:c+l.length;return c<0||c>=E||g>E||c===g?(0,a.Left)(new Error(`Array slice out of bounds, start=${l.start}, length=${l.length}`)):Array.from({length:g-c},(A,b)=>b).map(A=>n+(A+c)*l.itemSize*m).reduce((A,b)=>A.chain(f=>this.extractCalldataValueAt(e,r,b,t).map(T=>[...f,...T])),(0,a.Right)([]))});case i.DataPathElementType.REF:if(this.getU256(e.slice(n)).ifJust(E=>n=t+E).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(e,n,m).map(E=>[E]);case i.DataPathLeafType.DYNAMIC_LEAF:return this.getU256(e.slice(n)).toEither(new Error(`Invalid leaf length at offset ${n}`)).chain(E=>(n+=m,this.getSlice(e,n,E).chain(c=>h===null?(0,a.Right)([c]):this.sliceLeaf(c,h))))}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(e,r){const n=e.length,t=r.start===void 0?0:r.start<0?n+r.start:r.start,u=r.end===void 0?n:r.end<0?n+r.end:r.end;return t>=u?(0,a.Left)(new Error(`invalid leaf slice: start ${t}, end ${u}`)):this.getSlice(e,t,u-t).map(h=>[h])}getSlice(e,r,n){return r<0||e.length<r+n?(0,a.Left)(new Error(`calldata too small to slice at offset ${r} of length ${n}`)):(0,a.Right)(e.slice(r,r+n))}getU256(e){return a.Maybe.fromNullable(new s.ByteArrayParser(e).extract256BitUInt(!0)).filter(r=>r<=Number.MAX_SAFE_INTEGER).map(r=>Number(r))}};d=U([(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=(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});
 //# sourceMappingURL=TransactionParserService.js.map

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

@@ -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-v6\";\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.length === undefined ? length : start + element.length;\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}, length=${element.length}`,\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).map((leaf) => [\n                leaf,\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_v6", "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} 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"]
 }

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

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

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

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

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

@@ -1,2 +1,2 @@
-"use strict";var a=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var g=(n,i)=>{for(var r in i)a(n,r,{get:i[r],enumerable:!0})},h=(n,i,r,t)=>{if(i&&typeof i=="object"||typeof i=="function")for(let p of f(i))!A.call(n,p)&&p!==r&&a(n,p,{get:()=>i[p],enumerable:!(t=d(i,p))||t.enumerable});return n};var u=n=>h(a({},"__esModule",{value:!0}),n),s=(n,i,r,t)=>{for(var p=t>1?void 0:t?d(i,r):i,m=n.length-1,c;m>=0;m--)(c=n[m])&&(p=(t?c(i,r,p):c(p))||p);return t&&p&&a(i,r,p),p},B=(n,i)=>(r,t)=>i(r,t,n);var y={};g(y,{SignTransactionUseCase:()=>o});module.exports=u(y);var e=require("inversify"),T=require("../../app-binder/di/appBinderTypes");let o=class{_appBinding;constructor(i){this._appBinding=i}execute(i,r,t){return this._appBinding.signTransaction({derivationPath:i,transaction:r,options:t})}};o=s([(0,e.injectable)(),B(0,(0,e.inject)(T.appBinderTypes.AppBinding))],o);0&&(module.exports={SignTransactionUseCase});
+"use strict";var e=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var f=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var h=(p,i)=>{for(var n in i)e(p,n,{get:i[n],enumerable:!0})},u=(p,i,n,t)=>{if(i&&typeof i=="object"||typeof i=="function")for(let r of f(i))!g.call(p,r)&&r!==n&&e(p,r,{get:()=>i[r],enumerable:!(t=d(i,r))||t.enumerable});return p};var T=p=>u(e({},"__esModule",{value:!0}),p),B=(p,i,n,t)=>{for(var r=t>1?void 0:t?d(i,n):i,a=p.length-1,c;a>=0;a--)(c=p[a])&&(r=(t?c(i,n,r):c(r))||r);return t&&r&&e(i,n,r),r},A=(p,i)=>(n,t)=>i(n,t,p);var y={};h(y,{SignTransactionUseCase:()=>o});module.exports=T(y);var m=require("inversify"),s=require("../../app-binder/di/appBinderTypes");let o=class{_appBinding;constructor(i){this._appBinding=i}execute(i,n,t){return this._appBinding.signTransaction({derivationPath:i,transaction:n,options:t})}};o=B([(0,m.injectable)(),A(0,(0,m.inject)(s.appBinderTypes.AppBinding))],o);0&&(module.exports={SignTransactionUseCase});
 //# sourceMappingURL=SignTransactionUseCase.js.map

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/internal/transaction/use-case/SignTransactionUseCase.ts"],
-  "sourcesContent": ["import { inject, injectable } from \"inversify\";\n\nimport { SignTransactionDAReturnType } from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nimport { Transaction } from \"@api/model/Transaction\";\nimport { TransactionOptions } from \"@api/model/TransactionOptions\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\n@injectable()\nexport class SignTransactionUseCase {\n  private _appBinding: EthAppBinder;\n\n  constructor(\n    @inject(appBinderTypes.AppBinding)\n    appBinding: EthAppBinder,\n  ) {\n    this._appBinding = appBinding;\n  }\n\n  execute(\n    derivationPath: string,\n    transaction: Transaction,\n    options?: TransactionOptions,\n  ): SignTransactionDAReturnType {\n    return this._appBinding.signTransaction({\n      derivationPath,\n      transaction,\n      options,\n    });\n  }\n}\n"],
-  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,qBAKnCC,EAA+B,kDAIxB,IAAMC,EAAN,KAA6B,CAC1B,YAER,YAEEC,EACA,CACA,KAAK,YAAcA,CACrB,CAEA,QACEC,EACAC,EACAC,EAC6B,CAC7B,OAAO,KAAK,YAAY,gBAAgB,CACtC,eAAAF,EACA,YAAAC,EACA,QAAAC,CACF,CAAC,CACH,CACF,EArBaJ,EAANK,EAAA,IADN,cAAW,EAKPC,EAAA,eAAO,iBAAe,UAAU,IAJxBN",
+  "sourcesContent": ["import { inject, injectable } from \"inversify\";\n\nimport { SignTransactionDAReturnType } from \"@api/app-binder/SignTransactionDeviceActionTypes\";\nimport { TransactionOptions } from \"@api/model/TransactionOptions\";\nimport { appBinderTypes } from \"@internal/app-binder/di/appBinderTypes\";\nimport { EthAppBinder } from \"@internal/app-binder/EthAppBinder\";\n\n@injectable()\nexport class SignTransactionUseCase {\n  private _appBinding: EthAppBinder;\n\n  constructor(\n    @inject(appBinderTypes.AppBinding)\n    appBinding: EthAppBinder,\n  ) {\n    this._appBinding = appBinding;\n  }\n\n  execute(\n    derivationPath: string,\n    transaction: Uint8Array,\n    options?: TransactionOptions,\n  ): SignTransactionDAReturnType {\n    return this._appBinding.signTransaction({\n      derivationPath,\n      transaction,\n      options,\n    });\n  }\n}\n"],
+  "mappings": "okBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,qBAInCC,EAA+B,kDAIxB,IAAMC,EAAN,KAA6B,CAC1B,YAER,YAEEC,EACA,CACA,KAAK,YAAcA,CACrB,CAEA,QACEC,EACAC,EACAC,EAC6B,CAC7B,OAAO,KAAK,YAAY,gBAAgB,CACtC,eAAAF,EACA,YAAAC,EACA,QAAAC,CACF,CAAC,CACH,CACF,EArBaJ,EAANK,EAAA,IADN,cAAW,EAKPC,EAAA,eAAO,iBAAe,UAAU,IAJxBN",
   "names": ["SignTransactionUseCase_exports", "__export", "SignTransactionUseCase", "__toCommonJS", "import_inversify", "import_appBinderTypes", "SignTransactionUseCase", "appBinding", "derivationPath", "transaction", "options", "__decorateClass", "__decorateParam"]
 }

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

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

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

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

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

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

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

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