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

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

@@ -1 +1,7 @@
-{"version":3,"file":"EthersV6TransactionMapper.js","sourceRoot":"","sources":["../../../../../../src/internal/transaction/service/mapper/EthersV6TransactionMapper.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,IAAI,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,IAAI,EAAS,OAAO,EAAE,MAAM,WAAW,CAAC;AAQ1C,IAAM,yBAAyB,GAA/B,MAAM,yBAAyB;IACpC,GAAG,CAAC,WAAwB;QAC1B,IAAI,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC5C,MAAM,qBAAqB,GAAG,QAAQ,CAAC,WAAW,CAAC,kBAAkB,CAAC,CAAC;YACvE,OAAO,IAAI,CAAC;gBACV,MAAM,EAAE;oBACN,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAC/C,EAAE,EAAE,WAAW,CAAC,EAAE,IAAI,SAAS;oBAC/B,IAAI,EAAE,WAAW,CAAC,IAAI;iBACvB;gBACD,qBAAqB;aACtB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,qBAAqB,CAC3B,WAAwB;QAExB,OAAO,WAAW,YAAY,mBAAmB,CAAC;IACpD,CAAC;CACF,CAAA;AAtBY,yBAAyB;IADrC,UAAU,EAAE;GACA,yBAAyB,CAsBrC"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersV6TransactionMapper.ts"],
+  "sourcesContent": ["import {\n  BigNumberish,\n  getBytes,\n  Transaction as EthersV6Transaction,\n} from \"ethers-v6\";\nimport { injectable } from \"inversify\";\nimport { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport { Transaction } from \"@api/model/Transaction\";\n\nimport { TransactionMapperResult } from \"./model/TransactionMapperResult\";\nimport { TransactionMapper } from \"./TransactionMapper\";\n\n@injectable()\nexport class EthersV6TransactionMapper implements TransactionMapper {\n  map(transaction: Transaction): Maybe<TransactionMapperResult> {\n    if (this.isEthersV6Transaction(transaction)) {\n      const serializedTransaction = getBytes(transaction.unsignedSerialized);\n      return Just({\n        subset: {\n          chainId: Number(transaction.chainId.toString()),\n          to: transaction.to ?? undefined,\n          data: transaction.data,\n        },\n        serializedTransaction,\n        type: transaction.type || 0,\n      });\n    }\n\n    return Nothing;\n  }\n\n  private isEthersV6Transaction(\n    transaction: Transaction,\n  ): transaction is EthersV6Transaction {\n    return (\n      typeof transaction === \"object\" &&\n      (transaction.hash === null || typeof transaction.hash === \"string\") &&\n      (transaction.to === null || typeof transaction.to === \"string\") &&\n      (transaction.gasLimit == null || isBigNumberish(transaction.gasLimit)) &&\n      (transaction.gasPrice === null || isBigNumberish(transaction.gasPrice)) &&\n      (transaction.value === null || isBigNumberish(transaction.value)) &&\n      (transaction.chainId === null ||\n        isBigNumberish(typeof transaction.chainId)) &&\n      (transaction.type === null || typeof transaction.type === \"number\")\n    );\n  }\n}\n\nconst isBigNumberish = (number: unknown): number is BigNumberish =>\n  typeof number === \"string\" ||\n  typeof number === \"number\" ||\n  typeof number === \"bigint\";\n"],
+  "mappings": "wMAAA,OAEE,YAAAA,MAEK,YACP,OAAS,cAAAC,MAAkB,YAC3B,OAAS,QAAAC,EAAa,WAAAC,MAAe,YAQ9B,IAAMC,EAAN,KAA6D,CAClE,IAAIC,EAA0D,CAC5D,GAAI,KAAK,sBAAsBA,CAAW,EAAG,CAC3C,MAAMC,EAAwBC,EAASF,EAAY,kBAAkB,EACrE,OAAOG,EAAK,CACV,OAAQ,CACN,QAAS,OAAOH,EAAY,QAAQ,SAAS,CAAC,EAC9C,GAAIA,EAAY,IAAM,OACtB,KAAMA,EAAY,IACpB,EACA,sBAAAC,EACA,KAAMD,EAAY,MAAQ,CAC5B,CAAC,CACH,CAEA,OAAOI,CACT,CAEQ,sBACNJ,EACoC,CACpC,OACE,OAAOA,GAAgB,WACtBA,EAAY,OAAS,MAAQ,OAAOA,EAAY,MAAS,YACzDA,EAAY,KAAO,MAAQ,OAAOA,EAAY,IAAO,YACrDA,EAAY,UAAY,MAAQK,EAAeL,EAAY,QAAQ,KACnEA,EAAY,WAAa,MAAQK,EAAeL,EAAY,QAAQ,KACpEA,EAAY,QAAU,MAAQK,EAAeL,EAAY,KAAK,KAC9DA,EAAY,UAAY,MACvBK,EAAe,OAAOL,EAAY,OAAO,KAC1CA,EAAY,OAAS,MAAQ,OAAOA,EAAY,MAAS,SAE9D,CACF,EAjCaD,EAANO,EAAA,CADNC,EAAW,GACCR,GAmCb,MAAMM,EAAkBG,GACtB,OAAOA,GAAW,UAClB,OAAOA,GAAW,UAClB,OAAOA,GAAW",
+  "names": ["getBytes", "injectable", "Just", "Nothing", "EthersV6TransactionMapper", "transaction", "serializedTransaction", "getBytes", "Just", "Nothing", "isBigNumberish", "__decorateClass", "injectable", "number"]
+}

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

@@ -0,0 +1,2 @@
+import{BigNumber as r}from"ethers-v5";import{Transaction as s}from"ethers-v6";import{Just as o}from"purify-ts";import{EthersV6TransactionMapper as x}from"./EthersV6TransactionMapper";describe("EthersV6TransactionMapper",()=>{let n;beforeEach(()=>{n=new x}),describe("map",()=>{it("should return the correct TransactionSubset",()=>{const t=new s;t.chainId=1n,t.nonce=0,t.data="0x";const a=new Uint8Array([2,201,1,128,128,128,128,128,128,128,192]),e=n.map(t);expect(e).toEqual(o({subset:{chainId:1,to:void 0,data:"0x"},serializedTransaction:a,type:0}))}),it("should return the correct TransactionSubset with to attribute",()=>{const t=new s;t.chainId=1n,t.nonce=0,t.data="0x",t.to="0x0123456789abcdef0123456789abcdef01234567";const a=new Uint8Array([2,221,1,128,128,128,128,148,1,35,69,103,137,171,205,239,1,35,69,103,137,171,205,239,1,35,69,103,128,128,192]),e=n.map(t);expect(e).toEqual(o({subset:{chainId:1,to:"0x0123456789abcDEF0123456789abCDef01234567",data:"0x"},serializedTransaction:a,type:0}))}),it("should return the correct TransactionSubset with all attributes",()=>{const t=new s;t.type=1,t.to="0x0123456789abcdef0123456789abcdef01234567",t.data="0x",t.nonce=0,t.gasLimit=0n,t.gasPrice=0n,t.value=0n,t.chainId=1n;const a=new Uint8Array([1,220,1,128,128,128,148,1,35,69,103,137,171,205,239,1,35,69,103,137,171,205,239,1,35,69,103,128,128,192]),e=n.map(t);expect(e).toEqual(o({subset:{chainId:1,to:"0x0123456789abcDEF0123456789abCDef01234567",data:"0x"},serializedTransaction:a,type:1}))}),it("should return Nothing when the transaction is not an EthersV6Transaction",()=>{const t={},a=n.map(t);expect(a.isNothing()).toBeTruthy()}),it("should return Nothing when the transaction is not an EthersV5Transaction",()=>{const t={chainId:1,nonce:0,gasLimit:r.from(0),gasPrice:r.from(0),value:r.from(0),data:"0x",from:"0x",r:"0x",s:"0x",v:0,type:1,maxFeePerGas:r.from(0),maxPriorityFeePerGas:r.from(0)},a=n.map(t);expect(a.isNothing()).toBeTruthy()})})});
+//# sourceMappingURL=EthersV6TransactionMapper.test.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/EthersV6TransactionMapper.test.ts"],
+  "sourcesContent": ["import {\n  BigNumber as EthersV5BigNumber,\n  type Transaction as EthersV5Transaction,\n} from \"ethers-v5\";\nimport { Transaction as EthersV6Transaction } from \"ethers-v6\";\nimport { Just } from \"purify-ts\";\n\nimport { type Transaction } from \"@api/index\";\n\nimport { EthersV6TransactionMapper } from \"./EthersV6TransactionMapper\";\n\ndescribe(\"EthersV6TransactionMapper\", () => {\n  let mapper: EthersV6TransactionMapper;\n\n  beforeEach(() => {\n    mapper = new EthersV6TransactionMapper();\n  });\n\n  describe(\"map\", () => {\n    it(\"should return the correct TransactionSubset\", () => {\n      // GIVEN\n      const transaction = new EthersV6Transaction();\n      transaction.chainId = 1n;\n      transaction.nonce = 0;\n      transaction.data = \"0x\";\n      const serializedTransaction = new Uint8Array([\n        2, 201, 1, 128, 128, 128, 128, 128, 128, 128, 192,\n      ]);\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result).toEqual(\n        Just({\n          subset: {\n            chainId: 1,\n            to: undefined,\n            data: \"0x\",\n          },\n          serializedTransaction,\n          type: 0,\n        }),\n      );\n    });\n\n    it(\"should return the correct TransactionSubset with to attribute\", () => {\n      // GIVEN\n      const transaction = new EthersV6Transaction();\n      transaction.chainId = 1n;\n      transaction.nonce = 0;\n      transaction.data = \"0x\";\n      transaction.to = \"0x0123456789abcdef0123456789abcdef01234567\";\n      const serializedTransaction = new Uint8Array([\n        0x02, 0xdd, 0x01, 0x80, 0x80, 0x80, 0x80, 0x94, 0x01, 0x23, 0x45, 0x67,\n        0x89, 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,\n        0x01, 0x23, 0x45, 0x67, 0x80, 0x80, 0xc0,\n      ]);\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result).toEqual(\n        Just({\n          subset: {\n            chainId: 1,\n            to: \"0x0123456789abcDEF0123456789abCDef01234567\",\n            data: \"0x\",\n          },\n          serializedTransaction,\n          type: 0,\n        }),\n      );\n    });\n\n    it(\"should return the correct TransactionSubset with all attributes\", () => {\n      // GIVEN\n      const transaction = new EthersV6Transaction();\n      transaction.type = 1;\n      transaction.to = \"0x0123456789abcdef0123456789abcdef01234567\";\n      transaction.data = \"0x\";\n      transaction.nonce = 0;\n      transaction.gasLimit = 0n;\n      transaction.gasPrice = 0n;\n      transaction.value = 0n;\n      transaction.chainId = 1n;\n      const serializedTransaction = new Uint8Array([\n        0x01, 0xdc, 0x01, 0x80, 0x80, 0x80, 0x94, 0x01, 0x23, 0x45, 0x67, 0x89,\n        0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01,\n        0x23, 0x45, 0x67, 0x80, 0x80, 0xc0,\n      ]);\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result).toEqual(\n        Just({\n          subset: {\n            chainId: 1,\n            to: \"0x0123456789abcDEF0123456789abCDef01234567\",\n            data: \"0x\",\n          },\n          serializedTransaction,\n          type: 1,\n        }),\n      );\n    });\n\n    it(\"should return Nothing when the transaction is not an EthersV6Transaction\", () => {\n      // GIVEN\n      const transaction = {} as Transaction;\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result.isNothing()).toBeTruthy();\n    });\n\n    it(\"should return Nothing when the transaction is not an EthersV5Transaction\", () => {\n      // GIVEN\n      const transaction: EthersV5Transaction = {\n        chainId: 1,\n        nonce: 0,\n        gasLimit: EthersV5BigNumber.from(0),\n        gasPrice: EthersV5BigNumber.from(0),\n        value: EthersV5BigNumber.from(0),\n        data: \"0x\",\n        from: \"0x\",\n        r: \"0x\",\n        s: \"0x\",\n        v: 0,\n        type: 1,\n        maxFeePerGas: EthersV5BigNumber.from(0),\n        maxPriorityFeePerGas: EthersV5BigNumber.from(0),\n      };\n\n      // WHEN\n      const result = mapper.map(transaction);\n\n      // THEN\n      expect(result.isNothing()).toBeTruthy();\n    });\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["EthersV5BigNumber", "EthersV6Transaction", "Just", "EthersV6TransactionMapper", "mapper", "transaction", "serializedTransaction", "result"]
+}

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

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

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

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

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

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

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

@@ -1 +1,7 @@
-{"version":3,"file":"TransactionMapperService.js","sourceRoot":"","sources":["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAU,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAMtE,IAAM,wBAAwB,GAA9B,MAAM,wBAAwB;IAC3B,QAAQ,CAAsB;IAEtC,YAEE,OAA4B;QAE5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED,sBAAsB,CACpB,WAAwB;QAExB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnC,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACvC,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;gBACpB,OAAO,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QAED,oDAAoD;QACpD,OAAO,IAAI,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAC;IACzD,CAAC;CACF,CAAA;AAvBY,wBAAwB;IADpC,UAAU,EAAE;IAKR,WAAA,WAAW,CAAC,gBAAgB,CAAC,kBAAkB,CAAC,CAAA;;GAJxC,wBAAwB,CAuBpC"}
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.ts"],
+  "sourcesContent": ["import { injectable, multiInject } from \"inversify\";\nimport { Either, Left, Right } from \"purify-ts\";\n\nimport { 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": "iOAAA,OAAS,cAAAA,EAAY,eAAAC,MAAmB,YACxC,OAAiB,QAAAC,EAAM,SAAAC,MAAa,YAGpC,OAAS,oBAAAC,MAAwB,4CAM1B,IAAMC,EAAN,KAA+B,CAC5B,SAER,YAEEC,EACA,CACA,KAAK,SAAWA,CAClB,CAEA,uBACEC,EACwC,CACxC,UAAWC,KAAU,KAAK,SAAU,CAClC,MAAMC,EAASD,EAAO,IAAID,CAAW,EACrC,GAAIE,EAAO,OAAO,EAChB,OAAOC,EAAMD,EAAO,QAAQ,CAAC,CAEjC,CAGA,OAAOE,EAAK,IAAI,MAAM,8BAA8B,CAAC,CACvD,CACF,EAvBaN,EAANO,EAAA,CADNC,EAAW,EAKPC,EAAA,EAAAC,EAAYC,EAAiB,kBAAkB,IAJvCX",
+  "names": ["injectable", "multiInject", "Left", "Right", "transactionTypes", "TransactionMapperService", "mappers", "transaction", "mapper", "result", "Right", "Left", "__decorateClass", "injectable", "__decorateParam", "multiInject", "transactionTypes"]
+}

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/internal/transaction/service/mapper/TransactionMapperService.test.ts"],
+  "sourcesContent": ["import { type TransactionSubset } from \"@ledgerhq/context-module\";\nimport { Just, type Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { 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,OAAS,QAAAA,EAAkB,WAAAC,EAAS,SAAAC,MAAa,YAIjD,OAAS,4BAAAC,MAAgC,6BAEzC,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,EAAyBJ,EAAK,CAAE,KAAM,MAAO,CAAsB,CAAC,EACpEI,EAAyBH,CAAO,CAClC,EACAK,EAAU,IAAIH,EAAyBI,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,QAAQN,EAAM,CAAE,KAAM,MAAO,CAAC,CAAC,CAChD,CAAC,EAED,GAAG,0DAA2D,IAAM,CAElE,MAAMK,EAAU,CACdH,EAAyBH,CAAO,EAChCG,EAAyBJ,EAAK,CAAE,KAAM,QAAS,CAAsB,CAAC,CACxE,EACAM,EAAU,IAAIH,EAAyBI,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,CAAC,CAAgB,EAG/D,OAAOC,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOA,EAAQ,CAAC,EAAG,GAAG,EAAE,iBAAiB,EACzC,OAAOC,CAAM,EAAE,QAAQN,EAAM,CAAE,KAAM,QAAS,CAAC,CAAC,CAClD,CAAC,EAED,GAAG,yBAA0B,IAAM,CAEjC,MAAMK,EAAU,CACdH,EAAyBH,CAAO,EAChCG,EAAyBH,CAAO,CAClC,EACAK,EAAU,IAAIH,EAAyBI,CAAO,EAG9C,MAAMC,EAASF,EAAQ,uBAAuB,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",
+  "names": ["Just", "Nothing", "Right", "TransactionMapperService", "transactionMapperBuilder", "value", "service", "mappers", "result"]
+}

package/lib/esm/internal/transaction/service/mapper/model/TransactionMapperResult.js

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

package/lib/esm/internal/transaction/service/mapper/model/TransactionMapperResult.js.map

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

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

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

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

@@ -0,0 +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": "wMAKA,OACE,iBAAAA,EACA,uBAAAC,EACA,oBAAAC,MACK,2BACP,OACE,sBAAAC,EACA,oBAAAC,EACA,mBAAAC,EACA,sBAAAC,MACK,kCACP,OAAS,eAAAC,MAAmB,YAC5B,OAAS,cAAAC,MAAkB,YAC3B,OAAS,UAAAC,EAAQ,QAAAC,EAAM,SAAAC,EAAO,SAAAC,MAAa,YAsD3C,MAAMC,EAAkB,EAClBC,EAAa,GAGZ,IAAMC,EAAN,KAA+B,CAC7B,aACLC,EACAC,EAC6B,CAC7B,OAAOC,EAAO,OAAO,IACnBC,EAAY,KAAKC,EAAmBJ,CAAqB,CAAC,CAC5D,EAAE,MAAOK,GAIHJ,IAASK,EAAc,KAMlBC,EACL,IAAI,MAAM,oDAAoD,CAChE,EACSN,IAASK,EAAc,GACzBE,EAAM,aAAaH,EAAY,EAAE,EACrC,IAAKI,GAAQC,EAAmBD,CAAG,CAAC,EACpC,OAAQE,GAAUA,IAAU,IAAI,EAChC,IAAKA,GAAU,CAACA,CAAK,CAAC,EACtB,SAAS,IAAI,MAAM,0CAA0C,CAAC,EACxDV,IAASK,EAAc,MACzBE,EAAM,aAAaH,EAAY,KAAK,EACxC,IAAKO,GAAQ,IAAIC,EAAiB,EAAE,oBAAoBD,CAAG,EAAE,MAAM,CAAC,EACpE,IAAKD,GAAU,CAACA,CAAK,CAAC,EACtB,SAAS,IAAI,MAAM,6CAA6C,CAAC,EAM/DH,EAAM,aAAaH,EAAY,IAAI,EACvC,SAAS,IAAI,MAAM,+BAA+B,CAAC,EACnD,MAAOS,GACNN,EAAM,aAAaE,EAAmBI,CAAQ,CAAC,EAAE,SAC/C,IAAI,MAAM,gCAAgCA,CAAQ,EAAE,CACtD,CACF,EACC,MAAOA,GAAa,KAAK,qBAAqBA,EAAUb,CAAI,CAAC,CACjE,CACH,CAEQ,qBACNc,EACAd,EAC6B,CAE7B,OADAc,EAAOA,EAAK,MAAMlB,CAAe,EAC7BI,EAAK,SAAW,EACXM,EAAK,IAAI,MAAM,eAAe,CAAC,EAEjC,KAAK,uBAAuBQ,EAAMd,EAAM,EAAG,CAAC,CACrD,CAEQ,uBACNc,EACAd,EACAe,EACAC,EAC6B,CAE7B,MAAMC,EAAcjB,EAAKA,EAAK,OAAS,CAAC,EAClCkB,EACJD,EAAY,OAASE,EAAoB,MAAQF,EAAc,KAEjE,KAAOjB,EAAK,OAAS,GAAG,CACtB,MAAMoB,EAAUpB,EAAK,CAAC,EAEtB,OADAA,EAAOA,EAAK,MAAM,CAAC,EACXoB,EAAQ,KAAM,CACpB,KAAKD,EAAoB,MAEvBH,EAAeD,EACfA,GAAUK,EAAQ,OAASvB,EAC3B,MACF,KAAKsB,EAAoB,MAGvB,OAAO,KAAK,QAAQL,EAAK,MAAMC,CAAM,CAAC,EACnC,SAAS,IAAI,MAAM,kCAAkCA,CAAM,EAAE,CAAC,EAC9D,MAAOM,GAAW,CAEjBN,GAAUlB,EACVmB,EAAeD,EAEf,MAAMO,EACJF,EAAQ,QAAU,OACd,EACAA,EAAQ,MAAQ,EACdC,EAASD,EAAQ,MACjBA,EAAQ,MACVG,EACJH,EAAQ,SAAW,OAAYC,EAASC,EAAQF,EAAQ,OAC1D,OACEE,EAAQ,GACRA,GAASD,GACTE,EAAMF,GACNC,IAAUC,EAEHjB,EACL,IAAI,MACF,oCAAoCc,EAAQ,KAAK,YAAYA,EAAQ,MAAM,EAC7E,CACF,EAGK,MAAM,KAAK,CAAE,OAAQG,EAAMD,CAAM,EAAG,CAACE,EAAGC,IAAMA,CAAC,EACnD,IACEA,GAAMV,GAAUU,EAAIH,GAASF,EAAQ,SAAWvB,CACnD,EACC,OACC,CAAC6B,EAAkCC,IACjCD,EAAI,MAAOE,GACT,KAAK,uBACHd,EACAd,EACA2B,EACAX,CACF,EAAE,IAAKa,GAAc,CAAC,GAAGD,EAAQ,GAAGC,CAAS,CAAC,CAChD,EACFC,EAAM,CAAC,CAAC,CACV,CACJ,CAAC,EACL,KAAKX,EAAoB,IAIvB,GACE,KAAK,QAAQL,EAAK,MAAMC,CAAM,CAAC,EAC5B,OAAQgB,GAAehB,EAASC,EAAee,CAAU,EACzD,UAAU,EAEb,OAAOzB,EAAK,IAAI,MAAM,yBAAyBS,CAAM,EAAE,CAAC,EAE1D,MACF,KAAKI,EAAoB,KAGvB,OAAQC,EAAQ,SAAU,CACxB,KAAKY,EAAiB,WACpB,OAAO1B,EACL,IAAI,MAAM,+CAA+C,CAC3D,EACF,KAAK0B,EAAiB,WACpB,OAAO1B,EACL,IAAI,MAAM,+CAA+C,CAC3D,EACF,KAAK0B,EAAiB,YAEpB,OAAO,KAAK,SAASlB,EAAMC,EAAQlB,CAAU,EAAE,IAAKoC,GAAS,CAC3DA,CACF,CAAC,EACH,KAAKD,EAAiB,aAIpB,OAAO,KAAK,QAAQlB,EAAK,MAAMC,CAAM,CAAC,EACnC,SAAS,IAAI,MAAM,iCAAiCA,CAAM,EAAE,CAAC,EAC7D,MAAOM,IAENN,GAAUlB,EACH,KAAK,SAASiB,EAAMC,EAAQM,CAAM,EAAE,MAAOY,GAC5Cf,IAAc,KACTY,EAAM,CAACG,CAAI,CAAC,EAEZ,KAAK,UAAUA,EAAMf,CAAS,CAExC,EACF,CACP,CACA,MACF,KAAKC,EAAoB,MAEvB,OAAOb,EACL,IAAI,MAAM,oDAAoD,CAChE,CACJ,CACF,CAEA,OAAOA,EAAK,IAAI,MAAM,wCAAwC,CAAC,CACjE,CAEQ,UACNQ,EACAI,EAC6B,CAC7B,MAAMG,EAASP,EAAK,OACdQ,EACJJ,EAAU,QAAU,OAChB,EACAA,EAAU,MAAQ,EAChBG,EAASH,EAAU,MACnBA,EAAU,MACZK,EACJL,EAAU,MAAQ,OACdG,EACAH,EAAU,IAAM,EACdG,EAASH,EAAU,IACnBA,EAAU,IAClB,OAAII,GAASC,EACJjB,EAAK,IAAI,MAAM,6BAA6BgB,CAAK,SAASC,CAAG,EAAE,CAAC,EAElE,KAAK,SAAST,EAAMQ,EAAOC,EAAMD,CAAK,EAAE,IAAKW,GAAS,CAACA,CAAI,CAAC,CACrE,CAEA,SACEnB,EACAC,EACAmB,EAC2B,CAC3B,OAAOnB,EAAS,GAAKD,EAAK,OAASC,EAASmB,EACxC5B,EACE,IAAI,MACF,yCAAyCS,CAAM,cAAcmB,CAAI,EACnE,CACF,EACAJ,EAAMhB,EAAK,MAAMC,EAAQA,EAASmB,CAAI,CAAC,CAC7C,CAEA,QAAQpB,EAAiC,CAEvC,OAAOP,EAAM,aAAa,IAAI4B,EAAgBrB,CAAI,EAAE,kBAAkB,EAAI,CAAC,EACxE,OAAQsB,GAAQA,GAAO,OAAO,gBAAgB,EAC9C,IAAKA,GAAQ,OAAOA,CAAG,CAAC,CAC7B,CACF,EApOatC,EAANuC,EAAA,CADNC,EAAW,GACCxC",
+  "names": ["ContainerPath", "DataPathElementType", "DataPathLeafType", "bufferToHexaString", "ByteArrayBuilder", "ByteArrayParser", "hexaStringToBuffer", "Transaction", "injectable", "Either", "Left", "Maybe", "Right", "SELECTOR_LENGTH", "CHUNK_SIZE", "TransactionParserService", "serializedTransaction", "path", "Either", "Transaction", "bufferToHexaString", "transaction", "ContainerPath", "Left", "Maybe", "str", "hexaStringToBuffer", "bytes", "num", "ByteArrayBuilder", "calldata", "data", "offset", "parentOffset", "lastElement", "leafSlice", "DataPathElementType", "element", "length", "start", "end", "_", "i", "acc", "arrayOffset", "values", "newValues", "Right", "reference", "DataPathLeafType", "leaf", "size", "ByteArrayParser", "res", "__decorateClass", "injectable"]
+}

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

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

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

@@ -0,0 +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": ["ContainerPath", "bufferToHexaString", "ByteArrayBuilder", "hexaStringToBuffer", "Transaction", "TransactionParserService", "parser", "TO", "VALUE", "VALUE_BIN", "transaction", "value", "from", "to", "TX", "path"]
+}

package/lib/esm/internal/transaction/use-case/SignTransactionUseCase.js

@@ -1,35 +1,2 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { inject, injectable } from "inversify";
-import { appBinderTypes } from "../../app-binder/di/appBinderTypes";
-import { EthAppBinder } from "../../app-binder/EthAppBinder";
-let SignTransactionUseCase = class SignTransactionUseCase {
-    _appBinding;
-    constructor(appBinding) {
-        this._appBinding = appBinding;
-    }
-    execute(derivationPath, transaction, options) {
-        return this._appBinding.signTransaction({
-            derivationPath,
-            transaction,
-            options,
-        });
-    }
-};
-SignTransactionUseCase = __decorate([
-    injectable(),
-    __param(0, inject(appBinderTypes.AppBinding)),
-    __metadata("design:paramtypes", [EthAppBinder])
-], SignTransactionUseCase);
-export { SignTransactionUseCase };
-//# sourceMappingURL=SignTransactionUseCase.js.map
+var d=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var m=(t,i,p,n)=>{for(var r=n>1?void 0:n?s(i,p):i,a=t.length-1,e;a>=0;a--)(e=t[a])&&(r=(n?e(i,p,r):e(r))||r);return n&&r&&d(i,p,r),r},c=(t,i)=>(p,n)=>i(p,n,t);import{inject as B,injectable as T}from"inversify";import{appBinderTypes as f}from"../../app-binder/di/appBinderTypes";let o=class{_appBinding;constructor(i){this._appBinding=i}execute(i,p,n){return this._appBinding.signTransaction({derivationPath:i,transaction:p,options:n})}};o=m([T(),c(0,B(f.AppBinding))],o);export{o as SignTransactionUseCase};
+//# sourceMappingURL=SignTransactionUseCase.js.map

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

@@ -1 +1,7 @@
-{"version":3,"file":"SignTransactionUseCase.js","sourceRoot":"","sources":["../../../../../src/internal/transaction/use-case/SignTransactionUseCase.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAK/C,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAG1D,IAAM,sBAAsB,GAA5B,MAAM,sBAAsB;IACzB,WAAW,CAAe;IAElC,YAEE,UAAwB;QAExB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAED,OAAO,CACL,cAAsB,EACtB,WAAwB,EACxB,OAA4B;QAE5B,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC;YACtC,cAAc;YACd,WAAW;YACX,OAAO;SACR,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AArBY,sBAAsB;IADlC,UAAU,EAAE;IAKR,WAAA,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAA;qCACtB,YAAY;GALf,sBAAsB,CAqBlC"}
+{
+  "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": "iOAAA,OAAS,UAAAA,EAAQ,cAAAC,MAAkB,YAKnC,OAAS,kBAAAC,MAAsB,yCAIxB,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,CADNC,EAAW,EAKPC,EAAA,EAAAC,EAAOC,EAAe,UAAU,IAJxBT",
+  "names": ["inject", "injectable", "appBinderTypes", "SignTransactionUseCase", "appBinding", "derivationPath", "transaction", "options", "__decorateClass", "injectable", "__decorateParam", "inject", "appBinderTypes"]
+}

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

@@ -0,0 +1,2 @@
+import{Transaction as e}from"ethers-v6";import{SignTransactionUseCase as s}from"./SignTransactionUseCase";describe("SignTransactionUseCase",()=>{it("should call signTransaction on appBinder with the correct arguments",()=>{const t="m/44'/60'/0'/0/0",n=new e;n.to="0x1234567890123456789012345678901234567890",n.value=0n,n.data="0x";const a={signTransaction:jest.fn()};new s(a).execute(t,n),expect(a.signTransaction).toHaveBeenCalledWith({derivationPath:t,transaction:n})})});
+//# sourceMappingURL=SignTransactionUseCase.test.js.map

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

@@ -0,0 +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,OAAS,eAAAA,MAAmB,YAI5B,OAAS,0BAAAC,MAA8B,2BAEvC,SAAS,yBAA0B,IAAM,CACvC,GAAG,sEAAuE,IAAM,CAE9E,MAAMC,EAAiB,mBACjBC,EAA2B,IAAIH,EACrCG,EAAY,GAAK,6CACjBA,EAAY,MAAQ,GACpBA,EAAY,KAAO,KACnB,MAAMC,EAA0B,CAC9B,gBAAiB,KAAK,GAAG,CAC3B,EACgB,IAAIH,EAAuBG,CAAS,EAG5C,QAAQF,EAAgBC,CAAW,EAG3C,OAAOC,EAAU,eAAe,EAAE,qBAAqB,CACrD,eAAAF,EACA,YAAAC,CACF,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["Transaction", "SignTransactionUseCase", "derivationPath", "transaction", "appBinder"]
+}

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

@@ -1,9 +1,2 @@
-import { ContainerModule } from "inversify";
-import { typedDataTypes } from "../../typed-data/di/typedDataTypes";
-import { DefaultTypedDataParserService } from "../../typed-data/service/DefaultTypedDataParserService";
-import { SignTypedDataUseCase } from "../../typed-data/use-case/SignTypedDataUseCase";
-export const typedDataModuleFactory = () => new ContainerModule((bind, _unbind, _isBound, _rebind, _unbindAsync, _onActivation, _onDeactivation) => {
-    bind(typedDataTypes.SignTypedDataUseCase).to(SignTypedDataUseCase);
-    bind(typedDataTypes.TypedDataParserService).to(DefaultTypedDataParserService);
-});
-//# sourceMappingURL=typedDataModule.js.map
+import{ContainerModule as a}from"inversify";import{typedDataTypes as t}from"../../typed-data/di/typedDataTypes";import{DefaultTypedDataParserService as o}from"../../typed-data/service/DefaultTypedDataParserService";import{SignTypedDataUseCase as r}from"../../typed-data/use-case/SignTypedDataUseCase";const _=()=>new a((e,i,n,p,d,s,y)=>{e(t.SignTypedDataUseCase).to(r),e(t.TypedDataParserService).to(o)});export{_ as typedDataModuleFactory};
+//# sourceMappingURL=typedDataModule.js.map

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

@@ -1 +1,7 @@
-{"version":3,"file":"typedDataModule.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/di/typedDataModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AACxE,OAAO,EAAE,6BAA6B,EAAE,MAAM,4DAA4D,CAAC;AAC3G,OAAO,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAC;AAE1F,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,EAAE,CACzC,IAAI,eAAe,CACjB,CACE,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,aAAa,EACb,eAAe,EACf,EAAE;IACF,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC;IACnE,IAAI,CAAC,cAAc,CAAC,sBAAsB,CAAC,CAAC,EAAE,CAC5C,6BAA6B,CAC9B,CAAC;AACJ,CAAC,CACF,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/di/typedDataModule.ts"],
+  "sourcesContent": ["import { ContainerModule } from \"inversify\";\n\nimport { typedDataTypes } from \"@internal/typed-data/di/typedDataTypes\";\nimport { DefaultTypedDataParserService } from \"@internal/typed-data/service/DefaultTypedDataParserService\";\nimport { SignTypedDataUseCase } from \"@internal/typed-data/use-case/SignTypedDataUseCase\";\n\nexport const typedDataModuleFactory = () =>\n  new ContainerModule(\n    (\n      bind,\n      _unbind,\n      _isBound,\n      _rebind,\n      _unbindAsync,\n      _onActivation,\n      _onDeactivation,\n    ) => {\n      bind(typedDataTypes.SignTypedDataUseCase).to(SignTypedDataUseCase);\n      bind(typedDataTypes.TypedDataParserService).to(\n        DefaultTypedDataParserService,\n      );\n    },\n  );\n"],
+  "mappings": "AAAA,OAAS,mBAAAA,MAAuB,YAEhC,OAAS,kBAAAC,MAAsB,yCAC/B,OAAS,iCAAAC,MAAqC,6DAC9C,OAAS,wBAAAC,MAA4B,qDAE9B,MAAMC,EAAyB,IACpC,IAAIJ,EACF,CACEK,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,IACG,CACHN,EAAKJ,EAAe,oBAAoB,EAAE,GAAGE,CAAoB,EACjEE,EAAKJ,EAAe,sBAAsB,EAAE,GAC1CC,CACF,CACF,CACF",
+  "names": ["ContainerModule", "typedDataTypes", "DefaultTypedDataParserService", "SignTypedDataUseCase", "typedDataModuleFactory", "bind", "_unbind", "_isBound", "_rebind", "_unbindAsync", "_onActivation", "_onDeactivation"]
+}

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

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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/di/typedDataModule.test.ts"],
+  "sourcesContent": ["import { Container } from \"inversify\";\n\nimport { typedDataModuleFactory } from \"./typedDataModule\";\n\ndescribe(\"TypedDataModuleFactory\", () => {\n  describe(\"Default\", () => {\n    let container: Container;\n    let mod: ReturnType<typeof typedDataModuleFactory>;\n    beforeEach(() => {\n      mod = typedDataModuleFactory();\n      container = new Container();\n      container.load(mod);\n    });\n\n    it(\"should return the typed data module\", () => {\n      expect(mod).toBeDefined();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,OAAS,aAAAA,MAAiB,YAE1B,OAAS,0BAAAC,MAA8B,oBAEvC,SAAS,yBAA0B,IAAM,CACvC,SAAS,UAAW,IAAM,CACxB,IAAIC,EACAC,EACJ,WAAW,IAAM,CACfA,EAAMF,EAAuB,EAC7BC,EAAY,IAAIF,EAChBE,EAAU,KAAKC,CAAG,CACpB,CAAC,EAED,GAAG,sCAAuC,IAAM,CAC9C,OAAOA,CAAG,EAAE,YAAY,CAC1B,CAAC,CACH,CAAC,CACH,CAAC",
+  "names": ["Container", "typedDataModuleFactory", "container", "mod"]
+}

package/lib/esm/internal/typed-data/di/typedDataTypes.js

@@ -1,5 +1,2 @@
-export const typedDataTypes = {
-    SignTypedDataUseCase: Symbol.for("SignTypedDataUseCase"),
-    TypedDataParserService: Symbol.for("TypedDataParserService"),
-};
-//# sourceMappingURL=typedDataTypes.js.map
+const e={SignTypedDataUseCase:Symbol.for("SignTypedDataUseCase"),TypedDataParserService:Symbol.for("TypedDataParserService")};export{e as typedDataTypes};
+//# sourceMappingURL=typedDataTypes.js.map

package/lib/esm/internal/typed-data/di/typedDataTypes.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"typedDataTypes.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/di/typedDataTypes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,oBAAoB,EAAE,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC;IACxD,sBAAsB,EAAE,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC;CAC7D,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/di/typedDataTypes.ts"],
+  "sourcesContent": ["export const typedDataTypes = {\n  SignTypedDataUseCase: Symbol.for(\"SignTypedDataUseCase\"),\n  TypedDataParserService: Symbol.for(\"TypedDataParserService\"),\n};\n"],
+  "mappings": "AAAO,MAAMA,EAAiB,CAC5B,qBAAsB,OAAO,IAAI,sBAAsB,EACvD,uBAAwB,OAAO,IAAI,wBAAwB,CAC7D",
+  "names": ["typedDataTypes"]
+}

package/lib/esm/internal/typed-data/model/Types.js

@@ -1,55 +1,2 @@
-// Basic type (address, bool, uint256, etc)
-export class PrimitiveType {
-    typeName;
-    name;
-    size;
-    constructor(typeName, name, size) {
-        this.typeName = typeName;
-        this.name = name;
-        this.size = size;
-    }
-}
-// Arrays
-export class ArrayType {
-    typeName;
-    rootType;
-    rowType;
-    count;
-    levels;
-    constructor(typeName, rootType, rowType, count, levels) {
-        this.typeName = typeName;
-        this.rootType = rootType;
-        this.rowType = rowType;
-        this.count = count;
-        this.levels = levels;
-    }
-}
-// Custom structure
-export class StructType {
-    typeName;
-    constructor(typeName) {
-        this.typeName = typeName;
-    }
-}
-// The value is a message root. This is usually the primaryType name.
-export class TypedDataValueRoot {
-    root;
-    constructor(root) {
-        this.root = root;
-    }
-}
-// The value is an array. Represents the array length.
-export class TypedDataValueArray {
-    length;
-    constructor(length) {
-        this.length = length;
-    }
-}
-// The value is a field of any type. Contains the encoded value as a byte array.
-export class TypedDataValueField {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-}
-//# sourceMappingURL=Types.js.map
+class y{constructor(t,r,p){this.typeName=t;this.name=r;this.size=p}}class o{constructor(t,r,p,a,i){this.typeName=t;this.rootType=r;this.rowType=p;this.count=a;this.levels=i}}class c{constructor(t){this.typeName=t}}class u{constructor(t){this.root=t}}class l{constructor(t){this.length=t}}class s{constructor(t){this.data=t}}export{o as ArrayType,y as PrimitiveType,c as StructType,l as TypedDataValueArray,s as TypedDataValueField,u as TypedDataValueRoot};
+//# sourceMappingURL=Types.js.map

package/lib/esm/internal/typed-data/model/Types.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"Types.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/model/Types.ts"],"names":[],"mappings":"AAaA,2CAA2C;AAC3C,MAAM,OAAO,aAAa;IAEf;IACA;IACA;IAHT,YACS,QAAgB,EAChB,IAAuB,EACvB,IAAmB;QAFnB,aAAQ,GAAR,QAAQ,CAAQ;QAChB,SAAI,GAAJ,IAAI,CAAmB;QACvB,SAAI,GAAJ,IAAI,CAAe;IACzB,CAAC;CACL;AAED,SAAS;AACT,MAAM,OAAO,SAAS;IAEX;IACA;IACA;IACA;IACA;IALT,YACS,QAAgB,EAChB,QAAoC,EACpC,OAAe,EACf,KAAoB,EACpB,MAA4B;QAJ5B,aAAQ,GAAR,QAAQ,CAAQ;QAChB,aAAQ,GAAR,QAAQ,CAA4B;QACpC,YAAO,GAAP,OAAO,CAAQ;QACf,UAAK,GAAL,KAAK,CAAe;QACpB,WAAM,GAAN,MAAM,CAAsB;IAClC,CAAC;CACL;AAED,mBAAmB;AACnB,MAAM,OAAO,UAAU;IACF;IAAnB,YAAmB,QAAgB;QAAhB,aAAQ,GAAR,QAAQ,CAAQ;IAAG,CAAC;CACxC;AASD,qEAAqE;AACrE,MAAM,OAAO,kBAAkB;IACV;IAAnB,YAAmB,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;CACpC;AACD,sDAAsD;AACtD,MAAM,OAAO,mBAAmB;IACX;IAAnB,YAAmB,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IAAG,CAAC;CACtC;AACD,gFAAgF;AAChF,MAAM,OAAO,mBAAmB;IACX;IAAnB,YAAmB,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;CACxC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/model/Types.ts"],
+  "sourcesContent": ["import { type Maybe } from \"purify-ts\";\n\nexport type StructName = string;\nexport type FieldName = string;\nexport type FieldType = PrimitiveType | ArrayType | StructType;\nexport type PrimitiveTypeName =\n  | \"int\"\n  | \"uint\"\n  | \"address\"\n  | \"bytes\"\n  | \"string\"\n  | \"bool\";\n\n// Basic type (address, bool, uint256, etc)\nexport class PrimitiveType {\n  constructor(\n    public typeName: string,\n    public name: PrimitiveTypeName,\n    public size: Maybe<number>,\n  ) {}\n}\n\n// Arrays\nexport class ArrayType {\n  constructor(\n    public typeName: string,\n    public rootType: PrimitiveType | StructType,\n    public rowType: string,\n    public count: Maybe<number>,\n    public levels: Array<Maybe<number>>,\n  ) {}\n}\n\n// Custom structure\nexport class StructType {\n  constructor(public typeName: string) {}\n}\n\n// Typed data field value and metadata\nexport interface TypedDataValue {\n  path: string;\n  type: string;\n  value: TypedDataValueRoot | TypedDataValueArray | TypedDataValueField;\n}\n\n// The value is a message root. This is usually the primaryType name.\nexport class TypedDataValueRoot {\n  constructor(public root: string) {}\n}\n// The value is an array. Represents the array length.\nexport class TypedDataValueArray {\n  constructor(public length: number) {}\n}\n// The value is a field of any type. Contains the encoded value as a byte array.\nexport class TypedDataValueField {\n  constructor(public data: Uint8Array) {}\n}\n"],
+  "mappings": "AAcO,MAAMA,CAAc,CACzB,YACSC,EACAC,EACAC,EACP,CAHO,cAAAF,EACA,UAAAC,EACA,UAAAC,CACN,CACL,CAGO,MAAMC,CAAU,CACrB,YACSH,EACAI,EACAC,EACAC,EACAC,EACP,CALO,cAAAP,EACA,cAAAI,EACA,aAAAC,EACA,WAAAC,EACA,YAAAC,CACN,CACL,CAGO,MAAMC,CAAW,CACtB,YAAmBR,EAAkB,CAAlB,cAAAA,CAAmB,CACxC,CAUO,MAAMS,CAAmB,CAC9B,YAAmBC,EAAc,CAAd,UAAAA,CAAe,CACpC,CAEO,MAAMC,CAAoB,CAC/B,YAAmBC,EAAgB,CAAhB,YAAAA,CAAiB,CACtC,CAEO,MAAMC,CAAoB,CAC/B,YAAmBC,EAAkB,CAAlB,UAAAA,CAAmB,CACxC",
+  "names": ["PrimitiveType", "typeName", "name", "size", "ArrayType", "rootType", "rowType", "count", "levels", "StructType", "TypedDataValueRoot", "root", "TypedDataValueArray", "length", "TypedDataValueField", "data"]
+}

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

@@ -1,26 +1,2 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { injectable } from "inversify";
-import { TypedDataParser } from "./TypedDataParser";
-let DefaultTypedDataParserService = class DefaultTypedDataParserService {
-    parse(data) {
-        const parser = new TypedDataParser(data.types);
-        const types = parser.getStructDefinitions();
-        const domainResult = parser.parse("EIP712Domain", data.domain);
-        const messageResult = parser.parse(data.primaryType, data.message);
-        return domainResult.chain((domain) => messageResult.map((message) => ({
-            types,
-            domain,
-            message,
-        })));
-    }
-};
-DefaultTypedDataParserService = __decorate([
-    injectable()
-], DefaultTypedDataParserService);
-export { DefaultTypedDataParserService };
-//# sourceMappingURL=DefaultTypedDataParserService.js.map
+var c=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var i=(n,r,s,o)=>{for(var e=o>1?void 0:o?y(r,s):r,t=n.length-1,p;t>=0;t--)(p=n[t])&&(e=(o?p(r,s,e):p(e))||e);return o&&e&&c(r,s,e),e};import{injectable as d}from"inversify";import{TypedDataParser as T}from"./TypedDataParser";let m=class{parse(r){const s=new T(r.types),o=s.getStructDefinitions(),e=s.parse("EIP712Domain",r.domain),t=s.parse(r.primaryType,r.message);return e.chain(p=>t.map(a=>({types:o,domain:p,message:a})))}};m=i([d()],m);export{m as DefaultTypedDataParserService};
+//# sourceMappingURL=DefaultTypedDataParserService.js.map