npm - @ledgerhq/device-signer-kit-ethereum - Versions diffs - 0.0.0-transactionInspector-resolutionObj-20250916113438 → 0.0.0-trusted-names-native-transfer-1-20260121120757 - Mend

@ledgerhq/device-signer-kit-ethereum 0.0.0-transactionInspector-resolutionObj-20250916113438 → 0.0.0-trusted-names-native-transfer-1-20260121120757

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

Files changed (559) hide show

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

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

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../src/internal/transaction/service/parser/TransactionParserService.ts"],
-  "sourcesContent": ["import type {\n  DataPathElement,\n  DataPathElementSlice,\n  GenericPath,\n  TransactionSubset,\n} from \"@ledgerhq/context-module\";\nimport {\n  ContainerPath,\n  DataPathElementType,\n  DataPathLeafType,\n} from \"@ledgerhq/context-module\";\nimport {\n  ByteArrayBuilder,\n  ByteArrayParser,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { injectable } from \"inversify\";\nimport { Either, Left, Maybe, Right } from \"purify-ts\";\n\n/**\n * The goal of this service it to implement the GenericPath parser in the context\n * of an ethereum transaction.\n *\n * The abi of an ethereum transaction calldata is specified here:\n * https://docs.soliditylang.org/en/latest/abi-spec.html\n *\n * To be noted:\n *  - calldata is composed of:\n *    - the selector on 4 bytes\n *    - chunks of 32 bytes, whatever the size of the item contained in that chunk\n *    - static elements (fixed size) are encoded \"in-place\", always in 1 chunk padded with zeros\n *      (even a bool is on 32 bytes)\n *    - dynamic elements (variable size) are behind references (pointers) and then encoded with length+value\n *\n * Examples extracted from the abi specification:\n *  - example for a function with static elements:\n *    signature: baz(uint32 x, bool y)\n *    parameters: x = 69\n *                y = true\n *    - Encoding:\n *      0xcdcd77c0: the selector\n *      [0] 0x0000000000000000000000000000000000000000000000000000000000000045: value = 69\n *      [1] 0x0000000000000000000000000000000000000000000000000000000000000001: value = true\n *\n *  - example for a function with dynamic elements:\n *    signature: g(uint256[][] x, string[] x)\n *    parameters: x = [[1, 2], [3]]\n *                y = [\"one\", \"two\", \"three\"]\n *    - Encoding:\n *      0x2289b18c: the selector\n *      [0] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x\n *      [1] 0x0000000000000000000000000000000000000000000000000000000000000140: offset of y\n *      [2] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x\n *      [3] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x[0]\n *      [4] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of x[1]\n *      [5] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x[0]\n *      [6] 0x0000000000000000000000000000000000000000000000000000000000000001: value of x[0][0] = 1\n *      [7] 0x0000000000000000000000000000000000000000000000000000000000000002: value of x[0][1] = 2\n *      [8] 0x0000000000000000000000000000000000000000000000000000000000000001: length of x[1]\n *      [9] 0x0000000000000000000000000000000000000000000000000000000000000003: value of x[1][0] = 3\n *      [10] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y\n *      [11] 0x0000000000000000000000000000000000000000000000000000000000000060: offset of y[0]\n *      [12] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of y[1]\n *      [13] 0x00000000000000000000000000000000000000000000000000000000000000e0: offset of y[2]\n *      [14] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[0]\n *      [15] 0x6f6e650000000000000000000000000000000000000000000000000000000000: value of y[0] = \"one\"\n *      [16] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[1]\n *      [17] 0x74776f0000000000000000000000000000000000000000000000000000000000: value of y[1] = \"two\"\n *      [18] 0x0000000000000000000000000000000000000000000000000000000000000005: length of y[2]\n *      [19] 0x7468726565000000000000000000000000000000000000000000000000000000: value of y[2] = \"three\"\n */\nconst SELECTOR_LENGTH = 4;\nconst CHUNK_SIZE = 32;\n\n@injectable()\nexport class TransactionParserService {\n  public extractValue(\n    subset: TransactionSubset,\n    path: GenericPath,\n  ): Either<Error, Uint8Array[]> {\n    const { to, data, value } = subset;\n    /**\n     * We can first check container paths, which are in the transaction envelop\n     */\n    if (path === ContainerPath.FROM) {\n      // 'from' is not part of the unsigned ethereum transaction, and can\n      // only by recovered from the transaction signature later on.\n      // Therefore we cannot extract it from a transaction before signing it.\n      // It is not an issue since that field will typically be displayed as an\n      // address on the device and therefore don't require additional descriptors.\n      return Left(\n        new Error(\"Cannot get 'FROM' field of an unsigned transaction\"),\n      );\n    } else if (path === ContainerPath.TO) {\n      return Maybe.fromNullable(to)\n        .map((str) => hexaStringToBuffer(str))\n        .filter((bytes) => bytes !== null)\n        .map((bytes) => [bytes])\n        .toEither(new Error(\"Faild to extract TO field of transaction\"));\n    } else if (path === ContainerPath.VALUE) {\n      return Maybe.fromNullable(value)\n        .map((num) => new ByteArrayBuilder().add256BitUIntToData(num).build())\n        .map((bytes) => [bytes])\n        .toEither(new Error(\"Faild to extract VALUE field of transaction\"));\n    }\n\n    /**\n     * If it was not a path in the container, it means it's a path in the calldata\n     */\n    return Maybe.fromNullable(data)\n      .toEither(new Error(\"Transaction calldata is empty\"))\n      .chain((calldata) =>\n        Maybe.fromNullable(hexaStringToBuffer(calldata)).toEither(\n          new Error(`Invalid hex string calldata: ${calldata}`),\n        ),\n      )\n      .chain((calldata) => this.extractCalldataValue(calldata, path));\n  }\n\n  private extractCalldataValue(\n    data: Uint8Array,\n    path: DataPathElement[],\n  ): Either<Error, Uint8Array[]> {\n    data = data.slice(SELECTOR_LENGTH); // Remove the selector from the calldata\n    if (path.length === 0) {\n      return Left(new Error(\"Path is empty\"));\n    }\n    return this.extractCalldataValueAt(data, path, 0, 0);\n  }\n\n  private extractCalldataValueAt(\n    data: Uint8Array,\n    path: DataPathElement[],\n    offset: number,\n    parentOffset: number,\n  ): Either<Error, Uint8Array[]> {\n    // If the path ends with a slice, store it now as it is only allowed at the end of a binary path.\n    const lastElement = path[path.length - 1]!;\n    const leafSlice: DataPathElementSlice | null =\n      lastElement.type === DataPathElementType.SLICE ? lastElement : null;\n\n    while (path.length > 0) {\n      const element = path[0]!;\n      path = path.slice(1);\n      switch (element.type) {\n        case DataPathElementType.TUPLE:\n          // A tuple contain 1 element per chunk\n          parentOffset = offset;\n          offset += element.offset * CHUNK_SIZE;\n          break;\n        case DataPathElementType.ARRAY:\n          // An array contains a length, followed by the list of elements.\n          // See the examples with dynamic types at the top of this file for more informations.\n          return this.getU256(data.slice(offset))\n            .toEither(new Error(`Invalid array length at offset ${offset}`))\n            .chain((length) => {\n              // Skip the array length\n              offset += CHUNK_SIZE;\n              parentOffset = offset;\n              // Select the array slice to iterate on\n              const start =\n                element.start === undefined\n                  ? 0\n                  : element.start < 0\n                    ? length + element.start\n                    : element.start;\n              const end =\n                element.end === undefined\n                  ? length\n                  : element.end < 0\n                    ? length + element.end\n                    : element.end;\n              if (\n                start < 0 ||\n                start >= length ||\n                end > length ||\n                start >= end\n              ) {\n                return Left(\n                  new Error(\n                    `Array slice out of bounds, start=${element.start}, end=${element.end}`,\n                  ),\n                );\n              }\n              // Iterate on the array slice\n              return Array.from({ length: end - start }, (_, i) => i)\n                .map(\n                  (i) => offset + (i + start) * element.itemSize * CHUNK_SIZE,\n                )\n                .reduce(\n                  (acc: Either<Error, Uint8Array[]>, arrayOffset) =>\n                    acc.chain((values) =>\n                      this.extractCalldataValueAt(\n                        data,\n                        path,\n                        arrayOffset,\n                        parentOffset,\n                      ).map((newValues) => [...values, ...newValues]),\n                    ),\n                  Right([]),\n                );\n            });\n        case DataPathElementType.REF:\n          // A reference means the current slot points to a new offset in the calldata (a kind of pointer).\n          // That offset is relative to its 'parent' element, here named parentOffset.\n          // See the examples with dynamic types at the top of this file for more informations.\n          if (\n            this.getU256(data.slice(offset))\n              .ifJust((reference) => (offset = parentOffset + reference))\n              .isNothing()\n          ) {\n            return Left(new Error(`Invalid ref at offset ${offset}`));\n          }\n          break;\n        case DataPathElementType.LEAF:\n          // A leaf means we reached the end of the path.\n          // We have to check the leaf type to know how to extract the data.\n          switch (element.leafType) {\n            case DataPathLeafType.ARRAY_LEAF:\n              return Left(\n                new Error(\"Array leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.TUPLE_LEAF:\n              return Left(\n                new Error(\"Tuple leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.STATIC_LEAF:\n              // A static leaf is the chunk of current offset (data of static size)\n              return this.getSlice(data, offset, CHUNK_SIZE).chain((leaf) => {\n                if (leafSlice === null) {\n                  return Right([leaf]);\n                } else {\n                  return this.sliceLeaf(leaf, leafSlice);\n                }\n              });\n            case DataPathLeafType.DYNAMIC_LEAF:\n              // A dynamic leaf is composed of a length followed by the actual value\n              // (data of variable size such as a string).\n              // See the examples with dynamic types at the top of this file for more informations.\n              return this.getU256(data.slice(offset))\n                .toEither(new Error(`Invalid leaf length at offset ${offset}`))\n                .chain((length) => {\n                  // Skip dynamic leaf length\n                  offset += CHUNK_SIZE;\n                  return this.getSlice(data, offset, length).chain((leaf) => {\n                    if (leafSlice === null) {\n                      return Right([leaf]);\n                    } else {\n                      return this.sliceLeaf(leaf, leafSlice);\n                    }\n                  });\n                });\n          }\n          break;\n        case DataPathElementType.SLICE:\n          // If the last element was a slice, it was already popped at the beginning of this function\n          return Left(\n            new Error(\"Slice can only be used as last element of the path\"),\n          );\n      }\n    }\n    // We should have early-returned on a leaf\n    return Left(new Error(\"Path did not resolve to a leaf element\"));\n  }\n\n  private sliceLeaf(\n    data: Uint8Array,\n    leafSlice: DataPathElementSlice,\n  ): Either<Error, Uint8Array[]> {\n    const length = data.length;\n    const start =\n      leafSlice.start === undefined\n        ? 0\n        : leafSlice.start < 0\n          ? length + leafSlice.start\n          : leafSlice.start;\n    const end =\n      leafSlice.end === undefined\n        ? length\n        : leafSlice.end < 0\n          ? length + leafSlice.end\n          : leafSlice.end;\n    if (start >= end) {\n      return Left(new Error(`invalid leaf slice: start ${start}, end ${end}`));\n    }\n    return this.getSlice(data, start, end - start).map((leaf) => [leaf]);\n  }\n\n  getSlice(\n    data: Uint8Array,\n    offset: number,\n    size: number,\n  ): Either<Error, Uint8Array> {\n    return offset < 0 || data.length < offset + size\n      ? Left(\n          new Error(\n            `calldata too small to slice at offset ${offset} of length ${size}`,\n          ),\n        )\n      : Right(data.slice(offset, offset + size));\n  }\n\n  getU256(data: Uint8Array): Maybe<number> {\n    // https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding\n    return Maybe.fromNullable(new ByteArrayParser(data).extract256BitUInt(true))\n      .filter((res) => res <= Number.MAX_SAFE_INTEGER)\n      .map((res) => Number(res));\n  }\n}\n"],
-  "mappings": "wMAMA,OACE,iBAAAA,EACA,uBAAAC,EACA,oBAAAC,MACK,2BACP,OACE,oBAAAC,EACA,mBAAAC,EACA,sBAAAC,MACK,kCACP,OAAS,cAAAC,MAAkB,YAC3B,OAAiB,QAAAC,EAAM,SAAAC,EAAO,SAAAC,MAAa,YAsD3C,MAAMC,EAAkB,EAClBC,EAAa,GAGZ,IAAMC,EAAN,KAA+B,CAC7B,aACLC,EACAC,EAC6B,CAC7B,KAAM,CAAE,GAAAC,EAAI,KAAAC,EAAM,MAAAC,CAAM,EAAIJ,EAI5B,OAAIC,IAASI,EAAc,KAMlBC,EACL,IAAI,MAAM,oDAAoD,CAChE,EACSL,IAASI,EAAc,GACzBE,EAAM,aAAaL,CAAE,EACzB,IAAKM,GAAQC,EAAmBD,CAAG,CAAC,EACpC,OAAQE,GAAUA,IAAU,IAAI,EAChC,IAAKA,GAAU,CAACA,CAAK,CAAC,EACtB,SAAS,IAAI,MAAM,0CAA0C,CAAC,EACxDT,IAASI,EAAc,MACzBE,EAAM,aAAaH,CAAK,EAC5B,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,aAAaJ,CAAI,EAC3B,SAAS,IAAI,MAAM,+BAA+B,CAAC,EACnD,MAAOU,GACNN,EAAM,aAAaE,EAAmBI,CAAQ,CAAC,EAAE,SAC/C,IAAI,MAAM,gCAAgCA,CAAQ,EAAE,CACtD,CACF,EACC,MAAOA,GAAa,KAAK,qBAAqBA,EAAUZ,CAAI,CAAC,CAClE,CAEQ,qBACNE,EACAF,EAC6B,CAE7B,OADAE,EAAOA,EAAK,MAAMN,CAAe,EAC7BI,EAAK,SAAW,EACXK,EAAK,IAAI,MAAM,eAAe,CAAC,EAEjC,KAAK,uBAAuBH,EAAMF,EAAM,EAAG,CAAC,CACrD,CAEQ,uBACNE,EACAF,EACAa,EACAC,EAC6B,CAE7B,MAAMC,EAAcf,EAAKA,EAAK,OAAS,CAAC,EAClCgB,EACJD,EAAY,OAASE,EAAoB,MAAQF,EAAc,KAEjE,KAAOf,EAAK,OAAS,GAAG,CACtB,MAAMkB,EAAUlB,EAAK,CAAC,EAEtB,OADAA,EAAOA,EAAK,MAAM,CAAC,EACXkB,EAAQ,KAAM,CACpB,KAAKD,EAAoB,MAEvBH,EAAeD,EACfA,GAAUK,EAAQ,OAASrB,EAC3B,MACF,KAAKoB,EAAoB,MAGvB,OAAO,KAAK,QAAQf,EAAK,MAAMW,CAAM,CAAC,EACnC,SAAS,IAAI,MAAM,kCAAkCA,CAAM,EAAE,CAAC,EAC9D,MAAOM,GAAW,CAEjBN,GAAUhB,EACViB,EAAeD,EAEf,MAAMO,EACJF,EAAQ,QAAU,OACd,EACAA,EAAQ,MAAQ,EACdC,EAASD,EAAQ,MACjBA,EAAQ,MACVG,EACJH,EAAQ,MAAQ,OACZC,EACAD,EAAQ,IAAM,EACZC,EAASD,EAAQ,IACjBA,EAAQ,IAChB,OACEE,EAAQ,GACRA,GAASD,GACTE,EAAMF,GACNC,GAASC,EAEFhB,EACL,IAAI,MACF,oCAAoCa,EAAQ,KAAK,SAASA,EAAQ,GAAG,EACvE,CACF,EAGK,MAAM,KAAK,CAAE,OAAQG,EAAMD,CAAM,EAAG,CAACE,EAAGC,IAAMA,CAAC,EACnD,IACEA,GAAMV,GAAUU,EAAIH,GAASF,EAAQ,SAAWrB,CACnD,EACC,OACC,CAAC2B,EAAkCC,IACjCD,EAAI,MAAOE,GACT,KAAK,uBACHxB,EACAF,EACAyB,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,QAAQf,EAAK,MAAMW,CAAM,CAAC,EAC5B,OAAQgB,GAAehB,EAASC,EAAee,CAAU,EACzD,UAAU,EAEb,OAAOxB,EAAK,IAAI,MAAM,yBAAyBQ,CAAM,EAAE,CAAC,EAE1D,MACF,KAAKI,EAAoB,KAGvB,OAAQC,EAAQ,SAAU,CACxB,KAAKY,EAAiB,WACpB,OAAOzB,EACL,IAAI,MAAM,+CAA+C,CAC3D,EACF,KAAKyB,EAAiB,WACpB,OAAOzB,EACL,IAAI,MAAM,+CAA+C,CAC3D,EACF,KAAKyB,EAAiB,YAEpB,OAAO,KAAK,SAAS5B,EAAMW,EAAQhB,CAAU,EAAE,MAAOkC,GAChDf,IAAc,KACTY,EAAM,CAACG,CAAI,CAAC,EAEZ,KAAK,UAAUA,EAAMf,CAAS,CAExC,EACH,KAAKc,EAAiB,aAIpB,OAAO,KAAK,QAAQ5B,EAAK,MAAMW,CAAM,CAAC,EACnC,SAAS,IAAI,MAAM,iCAAiCA,CAAM,EAAE,CAAC,EAC7D,MAAOM,IAENN,GAAUhB,EACH,KAAK,SAASK,EAAMW,EAAQM,CAAM,EAAE,MAAOY,GAC5Cf,IAAc,KACTY,EAAM,CAACG,CAAI,CAAC,EAEZ,KAAK,UAAUA,EAAMf,CAAS,CAExC,EACF,CACP,CACA,MACF,KAAKC,EAAoB,MAEvB,OAAOZ,EACL,IAAI,MAAM,oDAAoD,CAChE,CACJ,CACF,CAEA,OAAOA,EAAK,IAAI,MAAM,wCAAwC,CAAC,CACjE,CAEQ,UACNH,EACAc,EAC6B,CAC7B,MAAMG,EAASjB,EAAK,OACdkB,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,EACJhB,EAAK,IAAI,MAAM,6BAA6Be,CAAK,SAASC,CAAG,EAAE,CAAC,EAElE,KAAK,SAASnB,EAAMkB,EAAOC,EAAMD,CAAK,EAAE,IAAKW,GAAS,CAACA,CAAI,CAAC,CACrE,CAEA,SACE7B,EACAW,EACAmB,EAC2B,CAC3B,OAAOnB,EAAS,GAAKX,EAAK,OAASW,EAASmB,EACxC3B,EACE,IAAI,MACF,yCAAyCQ,CAAM,cAAcmB,CAAI,EACnE,CACF,EACAJ,EAAM1B,EAAK,MAAMW,EAAQA,EAASmB,CAAI,CAAC,CAC7C,CAEA,QAAQ9B,EAAiC,CAEvC,OAAOI,EAAM,aAAa,IAAI2B,EAAgB/B,CAAI,EAAE,kBAAkB,EAAI,CAAC,EACxE,OAAQgC,GAAQA,GAAO,OAAO,gBAAgB,EAC9C,IAAKA,GAAQ,OAAOA,CAAG,CAAC,CAC7B,CACF,EAzOapC,EAANqC,EAAA,CADNC,EAAW,GACCtC",
+  "sourcesContent": ["import type {\n  DataPathElement,\n  DataPathElementSlice,\n  GenericPath,\n  TransactionSubset,\n} from \"@ledgerhq/context-module\";\nimport {\n  ContainerPath,\n  DataPathElementType,\n  DataPathLeafType,\n} from \"@ledgerhq/context-module\";\nimport {\n  ByteArrayBuilder,\n  ByteArrayParser,\n  hexaStringToBuffer,\n} from \"@ledgerhq/device-management-kit\";\nimport { injectable } from \"inversify\";\nimport { Either, Left, Maybe, Right } from \"purify-ts\";\n\n/**\n * The goal of this service it to implement the GenericPath parser in the context\n * of an ethereum transaction.\n *\n * The abi of an ethereum transaction calldata is specified here:\n * https://docs.soliditylang.org/en/latest/abi-spec.html\n *\n * To be noted:\n *  - calldata is composed of:\n *    - the selector on 4 bytes\n *    - chunks of 32 bytes, whatever the size of the item contained in that chunk\n *    - static elements (fixed size) are encoded \"in-place\", always in 1 chunk padded with zeros\n *      (even a bool is on 32 bytes)\n *    - dynamic elements (variable size) are behind references (pointers) and then encoded with length+value\n *\n * Examples extracted from the abi specification:\n *  - example for a function with static elements:\n *    signature: baz(uint32 x, bool y)\n *    parameters: x = 69\n *                y = true\n *    - Encoding:\n *      0xcdcd77c0: the selector\n *      [0] 0x0000000000000000000000000000000000000000000000000000000000000045: value = 69\n *      [1] 0x0000000000000000000000000000000000000000000000000000000000000001: value = true\n *\n *  - example for a function with dynamic elements:\n *    signature: g(uint256[][] x, string[] x)\n *    parameters: x = [[1, 2], [3]]\n *                y = [\"one\", \"two\", \"three\"]\n *    - Encoding:\n *      0x2289b18c: the selector\n *      [0] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x\n *      [1] 0x0000000000000000000000000000000000000000000000000000000000000140: offset of y\n *      [2] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x\n *      [3] 0x0000000000000000000000000000000000000000000000000000000000000040: offset of x[0]\n *      [4] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of x[1]\n *      [5] 0x0000000000000000000000000000000000000000000000000000000000000002: length of x[0]\n *      [6] 0x0000000000000000000000000000000000000000000000000000000000000001: value of x[0][0] = 1\n *      [7] 0x0000000000000000000000000000000000000000000000000000000000000002: value of x[0][1] = 2\n *      [8] 0x0000000000000000000000000000000000000000000000000000000000000001: length of x[1]\n *      [9] 0x0000000000000000000000000000000000000000000000000000000000000003: value of x[1][0] = 3\n *      [10] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y\n *      [11] 0x0000000000000000000000000000000000000000000000000000000000000060: offset of y[0]\n *      [12] 0x00000000000000000000000000000000000000000000000000000000000000a0: offset of y[1]\n *      [13] 0x00000000000000000000000000000000000000000000000000000000000000e0: offset of y[2]\n *      [14] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[0]\n *      [15] 0x6f6e650000000000000000000000000000000000000000000000000000000000: value of y[0] = \"one\"\n *      [16] 0x0000000000000000000000000000000000000000000000000000000000000003: length of y[1]\n *      [17] 0x74776f0000000000000000000000000000000000000000000000000000000000: value of y[1] = \"two\"\n *      [18] 0x0000000000000000000000000000000000000000000000000000000000000005: length of y[2]\n *      [19] 0x7468726565000000000000000000000000000000000000000000000000000000: value of y[2] = \"three\"\n */\nconst SELECTOR_LENGTH = 4;\nconst CHUNK_SIZE = 32;\n\n@injectable()\nexport class TransactionParserService {\n  public extractValue(\n    subset: TransactionSubset,\n    path: GenericPath,\n  ): Either<Error, Uint8Array[]> {\n    const { to, data, value } = subset;\n    /**\n     * We can first check container paths, which are in the transaction envelop\n     */\n    if (path === ContainerPath.FROM) {\n      // 'from' is not part of the unsigned ethereum transaction, and can\n      // only by recovered from the transaction signature later on.\n      // Therefore we cannot extract it from a transaction before signing it.\n      // It is not an issue since that field will typically be displayed as an\n      // address on the device and therefore don't require additional descriptors.\n      return Left(\n        new Error(\"Cannot get 'FROM' field of an unsigned transaction\"),\n      );\n    } else if (path === ContainerPath.TO) {\n      return Maybe.fromNullable(to)\n        .map((str) => hexaStringToBuffer(str))\n        .filter((bytes) => bytes !== null)\n        .map((bytes) => [bytes])\n        .toEither(new Error(\"Failed to extract TO field of transaction\"));\n    } else if (path === ContainerPath.VALUE) {\n      return Maybe.fromNullable(value)\n        .map((num) => new ByteArrayBuilder().add256BitUIntToData(num).build())\n        .map((bytes) => [bytes])\n        .toEither(new Error(\"Failed to extract VALUE field of transaction\"));\n    }\n\n    /**\n     * If it was not a path in the container, it means it's a path in the calldata\n     */\n    return Maybe.fromNullable(data)\n      .toEither(new Error(\"Transaction calldata is empty\"))\n      .chain((calldata) =>\n        Maybe.fromNullable(hexaStringToBuffer(calldata)).toEither(\n          new Error(`Invalid hex string calldata: ${calldata}`),\n        ),\n      )\n      .chain((calldata) => this.extractCalldataValue(calldata, path));\n  }\n\n  private extractCalldataValue(\n    data: Uint8Array,\n    path: DataPathElement[],\n  ): Either<Error, Uint8Array[]> {\n    data = data.slice(SELECTOR_LENGTH); // Remove the selector from the calldata\n    if (path.length === 0) {\n      return Left(new Error(\"Path is empty\"));\n    }\n    return this.extractCalldataValueAt(data, path, 0, 0);\n  }\n\n  private extractCalldataValueAt(\n    data: Uint8Array,\n    path: DataPathElement[],\n    offset: number,\n    parentOffset: number,\n  ): Either<Error, Uint8Array[]> {\n    // If the path ends with a slice, store it now as it is only allowed at the end of a binary path.\n    const lastElement = path[path.length - 1]!;\n    const leafSlice: DataPathElementSlice | null =\n      lastElement.type === DataPathElementType.SLICE ? lastElement : null;\n\n    while (path.length > 0) {\n      const element = path[0]!;\n      path = path.slice(1);\n      switch (element.type) {\n        case DataPathElementType.TUPLE:\n          // A tuple contain 1 element per chunk\n          parentOffset = offset;\n          offset += element.offset * CHUNK_SIZE;\n          break;\n        case DataPathElementType.ARRAY:\n          // An array contains a length, followed by the list of elements.\n          // See the examples with dynamic types at the top of this file for more informations.\n          return this.getU256(data.slice(offset))\n            .toEither(new Error(`Invalid array length at offset ${offset}`))\n            .chain((length) => {\n              // Skip the array length\n              offset += CHUNK_SIZE;\n              parentOffset = offset;\n              // Select the array slice to iterate on\n              const start =\n                element.start === undefined\n                  ? 0\n                  : element.start < 0\n                    ? length + element.start\n                    : element.start;\n              const end =\n                element.end === undefined\n                  ? length\n                  : element.end < 0\n                    ? length + element.end\n                    : element.end;\n              if (\n                start < 0 ||\n                start >= length ||\n                end > length ||\n                start >= end\n              ) {\n                return Left(\n                  new Error(\n                    `Array slice out of bounds, start=${element.start}, end=${element.end}`,\n                  ),\n                );\n              }\n              // Iterate on the array slice\n              return Array.from({ length: end - start }, (_, i) => i)\n                .map(\n                  (i) => offset + (i + start) * element.itemSize * CHUNK_SIZE,\n                )\n                .reduce(\n                  (acc: Either<Error, Uint8Array[]>, arrayOffset) =>\n                    acc.chain((values) =>\n                      this.extractCalldataValueAt(\n                        data,\n                        path,\n                        arrayOffset,\n                        parentOffset,\n                      ).map((newValues) => [...values, ...newValues]),\n                    ),\n                  Right([]),\n                );\n            });\n        case DataPathElementType.REF:\n          // A reference means the current slot points to a new offset in the calldata (a kind of pointer).\n          // That offset is relative to its 'parent' element, here named parentOffset.\n          // See the examples with dynamic types at the top of this file for more informations.\n          if (\n            this.getU256(data.slice(offset))\n              .ifJust((reference) => (offset = parentOffset + reference))\n              .isNothing()\n          ) {\n            return Left(new Error(`Invalid ref at offset ${offset}`));\n          }\n          break;\n        case DataPathElementType.LEAF:\n          // A leaf means we reached the end of the path.\n          // We have to check the leaf type to know how to extract the data.\n          switch (element.leafType) {\n            case DataPathLeafType.ARRAY_LEAF:\n              return Left(\n                new Error(\"Array leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.TUPLE_LEAF:\n              return Left(\n                new Error(\"Tuple leaf is not supported in v1 of protocol\"),\n              );\n            case DataPathLeafType.STATIC_LEAF:\n              // A static leaf is the chunk of current offset (data of static size)\n              return this.getSlice(data, offset, CHUNK_SIZE).chain((leaf) => {\n                if (leafSlice === null) {\n                  return Right([leaf]);\n                } else {\n                  return this.sliceLeaf(leaf, leafSlice);\n                }\n              });\n            case DataPathLeafType.DYNAMIC_LEAF:\n              // A dynamic leaf is composed of a length followed by the actual value\n              // (data of variable size such as a string).\n              // See the examples with dynamic types at the top of this file for more informations.\n              return this.getU256(data.slice(offset))\n                .toEither(new Error(`Invalid leaf length at offset ${offset}`))\n                .chain((length) => {\n                  // Skip dynamic leaf length\n                  offset += CHUNK_SIZE;\n                  return this.getSlice(data, offset, length).chain((leaf) => {\n                    if (leafSlice === null) {\n                      return Right([leaf]);\n                    } else {\n                      return this.sliceLeaf(leaf, leafSlice);\n                    }\n                  });\n                });\n          }\n          break;\n        case DataPathElementType.SLICE:\n          // If the last element was a slice, it was already popped at the beginning of this function\n          return Left(\n            new Error(\"Slice can only be used as last element of the path\"),\n          );\n      }\n    }\n    // We should have early-returned on a leaf\n    return Left(new Error(\"Path did not resolve to a leaf element\"));\n  }\n\n  private sliceLeaf(\n    data: Uint8Array,\n    leafSlice: DataPathElementSlice,\n  ): Either<Error, Uint8Array[]> {\n    const length = data.length;\n    const start =\n      leafSlice.start === undefined\n        ? 0\n        : leafSlice.start < 0\n          ? length + leafSlice.start\n          : leafSlice.start;\n    const end =\n      leafSlice.end === undefined\n        ? length\n        : leafSlice.end < 0\n          ? length + leafSlice.end\n          : leafSlice.end;\n    if (start >= end) {\n      return Left(new Error(`invalid leaf slice: start ${start}, end ${end}`));\n    }\n    return this.getSlice(data, start, end - start).map((leaf) => [leaf]);\n  }\n\n  getSlice(\n    data: Uint8Array,\n    offset: number,\n    size: number,\n  ): Either<Error, Uint8Array> {\n    return offset < 0 || data.length < offset + size\n      ? Left(\n          new Error(\n            `calldata too small to slice at offset ${offset} of length ${size}`,\n          ),\n        )\n      : Right(data.slice(offset, offset + size));\n  }\n\n  getU256(data: Uint8Array): Maybe<number> {\n    // https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding\n    return Maybe.fromNullable(new ByteArrayParser(data).extract256BitUInt(true))\n      .filter((res) => res <= Number.MAX_SAFE_INTEGER)\n      .map((res) => Number(res));\n  }\n}\n"],
+  "mappings": "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",
   "names": ["ContainerPath", "DataPathElementType", "DataPathLeafType", "ByteArrayBuilder", "ByteArrayParser", "hexaStringToBuffer", "injectable", "Left", "Maybe", "Right", "SELECTOR_LENGTH", "CHUNK_SIZE", "TransactionParserService", "subset", "path", "to", "data", "value", "ContainerPath", "Left", "Maybe", "str", "hexaStringToBuffer", "bytes", "num", "ByteArrayBuilder", "calldata", "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 CHANGED Viewed

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

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

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

package/lib/esm/package.json CHANGED Viewed

@@ -1,39 +1,4 @@
 {
-  "name": "@ledgerhq/device-signer-kit-ethereum",
-  "version": "1.6.0",
-  "private": false,
-  "license": "Apache-2.0",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "import": "./lib/esm/index.js",
-      "require": "./lib/cjs/index.js"
-    },
-    "./*": {
-      "types": "./lib/types/*",
-      "import": "./lib/esm/*",
-      "require": "./lib/cjs/*"
-    }
-  },
-  "files": [
-    "./lib"
-  ],
-  "scripts": {
-    "prebuild": "rimraf lib",
-    "build": "pnpm ldmk-tool build --entryPoints src/index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
-    "dev": "concurrently \"pnpm watch:builds\" \"pnpm watch:types\"",
-    "watch:builds": "pnpm ldmk-tool watch --entryPoints src/index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
-    "watch:types": "concurrently \"tsc --watch -p tsconfig.prod.json\" \"tsc-alias --watch -p tsconfig.prod.json\"",
-    "lint": "eslint",
-    "lint:fix": "pnpm lint --fix",
-    "postpack": "find . -name '*.tgz' -exec cp {} ../../../dist/ \\; ",
-    "prettier": "prettier . --check",
-    "prettier:fix": "prettier . --write",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
-  },
   "dependencies": {
     "@ledgerhq/signer-utils": "workspace:*",
     "ethers": "catalog:",
@@ -46,8 +11,8 @@
   "devDependencies": {
     "@ledgerhq/context-module": "workspace:*",
     "@ledgerhq/device-management-kit": "workspace:*",
-    "@ledgerhq/ldmk-tool": "workspace:*",
     "@ledgerhq/eslint-config-dsdk": "workspace:*",
+    "@ledgerhq/ldmk-tool": "workspace:*",
     "@ledgerhq/prettier-config-dsdk": "workspace:*",
     "@ledgerhq/tsconfig-dsdk": "workspace:*",
     "@ledgerhq/vitest-config-dmk": "workspace:*",
@@ -55,8 +20,47 @@
     "rxjs": "catalog:",
     "ts-node": "catalog:"
   },
+  "exports": {
+    ".": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js",
+      "types": "./lib/types/index.d.ts"
+    },
+    "./*": {
+      "import": "./lib/esm/*",
+      "require": "./lib/cjs/*",
+      "types": "./lib/types/*"
+    }
+  },
+  "files": [
+    "./lib"
+  ],
+  "license": "Apache-2.0",
+  "name": "@ledgerhq/device-signer-kit-ethereum",
   "peerDependencies": {
     "@ledgerhq/context-module": "workspace:*",
     "@ledgerhq/device-management-kit": "workspace:*"
-  }
+  },
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/device-sdk-ts.git"
+  },
+  "scripts": {
+    "build": "pnpm ldmk-tool build --entryPoints src/index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
+    "dev": "concurrently \"pnpm watch:builds\" \"pnpm watch:types\"",
+    "lint": "eslint",
+    "lint:fix": "pnpm lint --fix",
+    "postpack": "find . -name '*.tgz' -exec cp {} ../../../dist/ \\; ",
+    "prebuild": "rimraf lib",
+    "prettier": "prettier . --check",
+    "prettier:fix": "prettier . --write",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "watch:builds": "pnpm ldmk-tool watch --entryPoints src/index.ts,src/**/*.ts --tsconfig tsconfig.prod.json",
+    "watch:types": "concurrently \"tsc --watch -p tsconfig.prod.json\" \"tsc-alias --watch -p tsconfig.prod.json\""
+  },
+  "version": "0.0.0-trusted-names-native-transfer-1-20260121120757"
 }

package/lib/types/api/SignerEth.d.ts CHANGED Viewed

@@ -3,8 +3,10 @@ import { type SignDelegationAuthorizationDAReturnType } from "./app-binder/SignD
 import { type SignPersonalMessageDAReturnType } from "./app-binder/SignPersonalMessageDeviceActionTypes";
 import { type SignTransactionDAReturnType } from "./app-binder/SignTransactionDeviceActionTypes";
 import { type SignTypedDataDAReturnType } from "./app-binder/SignTypedDataDeviceActionTypes";
+import { type VerifySafeAddressDAReturnType } from "./app-binder/VerifySafeAddressDeviceActionTypes";
 import { type AddressOptions } from "./model/AddressOptions";
 import { type MessageOptions } from "./model/MessageOptions";
+import { type SafeAddressOptions } from "./model/SafeAddressOptions";
 import { type TransactionOptions } from "./model/TransactionOptions";
 import { type TypedData } from "./model/TypedData";
 import { type TypedDataOptions } from "./model/TypedDataOptions";
@@ -13,6 +15,7 @@ export interface SignerEth {
     signMessage: (derivationPath: string, message: string | Uint8Array, options?: MessageOptions) => SignPersonalMessageDAReturnType;
     signTypedData: (derivationPath: string, typedData: TypedData, options?: TypedDataOptions) => SignTypedDataDAReturnType;
     getAddress: (derivationPath: string, options?: AddressOptions) => GetAddressDAReturnType;
+    verifySafeAddress: (safeContractAddress: string, options?: SafeAddressOptions) => VerifySafeAddressDAReturnType;
     signDelegationAuthorization: (derivationPath: string, chainId: number, contractAddress: string, nonce: number) => SignDelegationAuthorizationDAReturnType;
 }
 //# sourceMappingURL=SignerEth.d.ts.map

package/lib/types/api/SignerEth.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"SignerEth.d.ts","sourceRoot":"","sources":["../../../src/api/SignerEth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAC1F,OAAO,EAAE,KAAK,uCAAuC,EAAE,MAAM,kDAAkD,CAAC;AAChH,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,sDAAsD,CAAC;AAC5G,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AACpG,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAChG,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEpE,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,CACf,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,UAAU,EACvB,OAAO,CAAC,EAAE,kBAAkB,KACzB,2BAA2B,CAAC;IACjC,WAAW,EAAE,CACX,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,OAAO,CAAC,EAAE,cAAc,KACrB,+BAA+B,CAAC;IACrC,aAAa,EAAE,CACb,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,gBAAgB,KACvB,yBAAyB,CAAC;IAC/B,UAAU,EAAE,CACV,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,cAAc,KACrB,sBAAsB,CAAC;IAC5B,2BAA2B,EAAE,CAC3B,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,MAAM,KACV,uCAAuC,CAAC;CAC9C"}
1	+ {"version":3,"file":"SignerEth.d.ts","sourceRoot":"","sources":["../../../src/api/SignerEth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,6CAA6C,CAAC;AAC1F,OAAO,EAAE,KAAK,uCAAuC,EAAE,MAAM,kDAAkD,CAAC;AAChH,OAAO,EAAE,KAAK,+BAA+B,EAAE,MAAM,sDAAsD,CAAC;AAC5G,OAAO,EAAE,KAAK,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AACpG,OAAO,EAAE,KAAK,yBAAyB,EAAE,MAAM,gDAAgD,CAAC;AAChG,OAAO,EAAE,KAAK,6BAA6B,EAAE,MAAM,oDAAoD,CAAC;AACxG,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEpE,MAAM,WAAW,SAAS;IACxB,eAAe,EAAE,CACf,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,UAAU,EACvB,OAAO,CAAC,EAAE,kBAAkB,KACzB,2BAA2B,CAAC;IACjC,WAAW,EAAE,CACX,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,OAAO,CAAC,EAAE,cAAc,KACrB,+BAA+B,CAAC;IACrC,aAAa,EAAE,CACb,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,SAAS,EACpB,OAAO,CAAC,EAAE,gBAAgB,KACvB,yBAAyB,CAAC;IAC/B,UAAU,EAAE,CACV,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,cAAc,KACrB,sBAAsB,CAAC;IAC5B,iBAAiB,EAAE,CACjB,mBAAmB,EAAE,MAAM,EAC3B,OAAO,CAAC,EAAE,kBAAkB,KACzB,6BAA6B,CAAC;IACnC,2BAA2B,EAAE,CAC3B,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,MAAM,KACV,uCAAuC,CAAC;CAC9C"}

package/lib/types/api/app-binder/SignTransactionDeviceActionTypes.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { type ClearSignContextSuccess, type ContextModule, type TransactionSubset } from "@ledgerhq/context-module";
+import { type ContextModule, type TransactionSubset } from "@ledgerhq/context-module";
 import { type CommandErrorResult, type DeviceActionState, type ExecuteDeviceActionReturnType, type OpenAppDAError, type OpenAppDARequiredInteraction, type UserInteractionRequired } from "@ledgerhq/device-management-kit";
 import { type GetConfigCommandResponse } from "../app-binder/GetConfigCommandTypes";
 import { type ClearSigningType } from "../model/ClearSigningType";
@@ -6,17 +6,20 @@ import { type Signature } from "../model/Signature";
 import { type TransactionOptions } from "../model/TransactionOptions";
 import { type TransactionType } from "../model/TransactionType";
 import { type EthErrorCodes } from "../../internal/app-binder/command/utils/ethAppErrors";
+import { type ContextWithSubContexts } from "../../internal/app-binder/task/BuildFullContextsTask";
 import { type TransactionMapperService } from "../../internal/transaction/service/mapper/TransactionMapperService";
 import { type TransactionParserService } from "../../internal/transaction/service/parser/TransactionParserService";
 export declare enum SignTransactionDAStep {
     OPEN_APP = "signer.eth.steps.openApp",
     GET_APP_CONFIG = "signer.eth.steps.getAppConfig",
+    GET_ADDRESS = "signer.eth.steps.getAddress",
     WEB3_CHECKS_OPT_IN = "signer.eth.steps.web3ChecksOptIn",
     WEB3_CHECKS_OPT_IN_RESULT = "signer.eth.steps.web3ChecksOptInResult",
-    PRE_BUILD_CONTEXT = "signer.eth.steps.preBuildContext",
-    BUILD_CONTEXT = "signer.eth.steps.buildContext",
-    BUILD_SUB_CONTEXT_AND_PROVIDE = "signer.eth.steps.buildSubContextAndProvide",
-    SIGN_TRANSACTION = "signer.eth.steps.signTransaction"
+    PARSE_TRANSACTION = "signer.eth.steps.parseTransaction",
+    BUILD_CONTEXTS = "signer.eth.steps.buildContexts",
+    PROVIDE_CONTEXTS = "signer.eth.steps.provideContexts",
+    SIGN_TRANSACTION = "signer.eth.steps.signTransaction",
+    BLIND_SIGN_TRANSACTION_FALLBACK = "signer.eth.steps.blindSignTransactionFallback"
 }
 export type SignTransactionDAOutput = Signature;
 export type SignTransactionDAInput = {
@@ -41,11 +44,10 @@ export type SignTransactionDAState = DeviceActionState<SignTransactionDAOutput,
 export type SignTransactionDAInternalState = {
     readonly error: SignTransactionDAError | null;
     readonly appConfig: GetConfigCommandResponse | null;
-    readonly clearSignContexts: ClearSignContextSuccess[] | null;
-    readonly clearSignContextsOptional: ClearSignContextSuccess[] | null;
     readonly subset: TransactionSubset | null;
-    readonly transactionType: TransactionType | null;
+    readonly contexts: ContextWithSubContexts[];
     readonly clearSigningType: ClearSigningType | null;
+    readonly transactionType: TransactionType | null;
     readonly signature: Signature | null;
 };
 export type SignTransactionDAReturnType = ExecuteDeviceActionReturnType<SignTransactionDAOutput, SignTransactionDAError, SignTransactionDAIntermediateValue>;

package/lib/types/api/app-binder/SignTransactionDeviceActionTypes.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"SignTransactionDeviceActionTypes.d.ts","sourceRoot":"","sources":["../../../../src/api/app-binder/SignTransactionDeviceActionTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,~~uBAAuB,EAC5B,KAAK,~~aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAC9G,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAE9G,oBAAY,qBAAqB;IAC/B,QAAQ,6BAA6B;IACrC,cAAc,kCAAkC;IAChD,kBAAkB,qCAAqC;IACvD,yBAAyB,2CAA2C;IACpE,iBAAiB,~~qCAAqC~~;~~IACtD~~,~~aAAa~~,~~kCAAkC~~;~~IAC/C~~,~~6BAA6B,+CAA+C~~;~~IAC5E~~,gBAAgB,qCAAqC;~~CACtD~~;AAED,MAAM,MAAM,uBAAuB,GAAG,SAAS,CAAC;AAEhD,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B,cAAc,GACd,kBAAkB,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC;AAE/C,KAAK,oCAAoC,GACrC,4BAA4B,GAC5B,uBAAuB,CAAC,eAAe,GACvC,uBAAuB,CAAC,eAAe,CAAC;AAE5C,MAAM,MAAM,kCAAkC,GAC1C;IACE,uBAAuB,EAAE,oCAAoC,CAAC;IAC9D,IAAI,EAAE,OAAO,CACX,qBAAqB,EACrB,qBAAqB,CAAC,yBAAyB,CAChD,CAAC;CACH,GACD;IACE,uBAAuB,EAAE,uBAAuB,CAAC,IAAI,CAAC;IACtD,IAAI,EAAE,qBAAqB,CAAC,yBAAyB,CAAC;IACtD,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEN,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,CACpD,uBAAuB,EACvB,sBAAsB,EACtB,kCAAkC,CACnC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI,CAAC;IACpD,QAAQ,CAAC,~~iBAAiB~~,EAAE,~~uBAAuB~~,~~EAAE,~~GAAG,IAAI,CAAC;~~IAC7D~~,QAAQ,CAAC,~~yBAAyB~~,EAAE,~~uBAAuB~~,EAAE,~~GAAG,IAAI,~~CAAC;~~IACrE~~,QAAQ,CAAC,~~MAAM~~,EAAE,~~iBAAiB~~,GAAG,IAAI,CAAC;~~IAC1C~~,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACjD,QAAQ,CAAC,~~gBAAgB,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnD,QAAQ,CAAC,~~SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,6BAA6B,CACrE,uBAAuB,EACvB,sBAAsB,EACtB,kCAAkC,CACnC,CAAC"}
1	+ {"version":3,"file":"SignTransactionDeviceActionTypes.d.ts","sourceRoot":"","sources":["../../../../src/api/app-binder/SignTransactionDeviceActionTypes.ts"],"names":[],"mappings":"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"}

package/lib/types/api/app-binder/SignTypedDataDeviceActionTypes.d.ts CHANGED Viewed

@@ -5,10 +5,13 @@ import { type Signature } from "../model/Signature";
 import { type TypedData } from "../model/TypedData";
 import { type EthErrorCodes } from "../../internal/app-binder/command/utils/ethAppErrors";
 import type { ProvideEIP712ContextTaskArgs } from "../../internal/app-binder/task/ProvideEIP712ContextTask";
+import { type TransactionMapperService } from "../../internal/transaction/service/mapper/TransactionMapperService";
+import { type TransactionParserService } from "../../internal/transaction/service/parser/TransactionParserService";
 import { type TypedDataParserService } from "../../internal/typed-data/service/TypedDataParserService";
 export declare enum SignTypedDataDAStateStep {
     OPEN_APP = "signer.eth.steps.openApp",
     GET_APP_CONFIG = "signer.eth.steps.getAppConfig",
+    GET_ADDRESS = "signer.eth.steps.getAddress",
     WEB3_CHECKS_OPT_IN = "signer.eth.steps.web3ChecksOptIn",
     WEB3_CHECKS_OPT_IN_RESULT = "signer.eth.steps.web3ChecksOptInResult",
     BUILD_CONTEXT = "signer.eth.steps.buildContext",
@@ -22,6 +25,8 @@ export type SignTypedDataDAInput = {
     readonly derivationPath: string;
     readonly data: TypedData;
     readonly parser: TypedDataParserService;
+    readonly transactionMapper: TransactionMapperService;
+    readonly transactionParser: TransactionParserService;
     readonly contextModule: ContextModule;
     readonly skipOpenApp: boolean;
 };
@@ -39,6 +44,7 @@ export type SignTypedDataDAState = DeviceActionState<SignTypedDataDAOutput, Sign
 export type SignTypedDataDAInternalState = {
     readonly error: SignTypedDataDAError | null;
     readonly appConfig: GetConfigCommandResponse | null;
+    readonly from: string | null;
     readonly typedDataContext: ProvideEIP712ContextTaskArgs | null;
     readonly signature: Signature | null;
 };

package/lib/types/api/app-binder/SignTypedDataDeviceActionTypes.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"SignTypedDataDeviceActionTypes.d.ts","sourceRoot":"","sources":["../../../../src/api/app-binder/SignTypedDataDeviceActionTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oDAAoD,CAAC;AACvG,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,qDAAqD,CAAC;AAElG,oBAAY,wBAAwB;IAClC,QAAQ,6BAA6B;IACrC,cAAc,kCAAkC;IAChD,kBAAkB,qCAAqC;IACvD,yBAAyB,2CAA2C;IACpE,aAAa,kCAAkC;IAC/C,eAAe,oCAAoC;IACnD,uBAAuB,2CAA2C;IAClE,eAAe,mCAAmC;IAClD,sBAAsB,yCAAyC;CAChE;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC;AAE9C,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B,cAAc,GACd,kBAAkB,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC;AAE/C,KAAK,kCAAkC,GACnC,4BAA4B,GAC5B,uBAAuB,CAAC,eAAe,GACvC,uBAAuB,CAAC,aAAa,CAAC;AAE1C,MAAM,MAAM,gCAAgC,GACxC;IACE,uBAAuB,EAAE,kCAAkC,CAAC;IAC5D,IAAI,EAAE,OAAO,CACX,wBAAwB,EACxB,wBAAwB,CAAC,yBAAyB,CACnD,CAAC;CACH,GACD;IACE,uBAAuB,EAAE,uBAAuB,CAAC,IAAI,CAAC;IACtD,IAAI,EAAE,wBAAwB,CAAC,yBAAyB,CAAC;IACzD,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEN,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAClD,qBAAqB,EACrB,oBAAoB,EACpB,gCAAgC,CACjC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI,CAAC;IACpD,QAAQ,CAAC,gBAAgB,EAAE,4BAA4B,GAAG,IAAI,CAAC;IAC/D,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CACnE,qBAAqB,EACrB,oBAAoB,EACpB,gCAAgC,CACjC,CAAC"}
1	+ {"version":3,"file":"SignTypedDataDeviceActionTypes.d.ts","sourceRoot":"","sources":["../../../../src/api/app-binder/SignTypedDataDeviceActionTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC7B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,oDAAoD,CAAC;AACvG,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAC9G,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAC9G,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,qDAAqD,CAAC;AAElG,oBAAY,wBAAwB;IAClC,QAAQ,6BAA6B;IACrC,cAAc,kCAAkC;IAChD,WAAW,gCAAgC;IAC3C,kBAAkB,qCAAqC;IACvD,yBAAyB,2CAA2C;IACpE,aAAa,kCAAkC;IAC/C,eAAe,oCAAoC;IACnD,uBAAuB,2CAA2C;IAClE,eAAe,mCAAmC;IAClD,sBAAsB,yCAAyC;CAChE;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC;AAE9C,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,iBAAiB,EAAE,wBAAwB,CAAC;IACrD,QAAQ,CAAC,iBAAiB,EAAE,wBAAwB,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B,cAAc,GACd,kBAAkB,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC;AAE/C,KAAK,kCAAkC,GACnC,4BAA4B,GAC5B,uBAAuB,CAAC,eAAe,GACvC,uBAAuB,CAAC,aAAa,CAAC;AAE1C,MAAM,MAAM,gCAAgC,GACxC;IACE,uBAAuB,EAAE,kCAAkC,CAAC;IAC5D,IAAI,EAAE,OAAO,CACX,wBAAwB,EACxB,wBAAwB,CAAC,yBAAyB,CACnD,CAAC;CACH,GACD;IACE,uBAAuB,EAAE,uBAAuB,CAAC,IAAI,CAAC;IACtD,IAAI,EAAE,wBAAwB,CAAC,yBAAyB,CAAC;IACzD,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEN,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAClD,qBAAqB,EACrB,oBAAoB,EACpB,gCAAgC,CACjC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,CAAC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,SAAS,EAAE,wBAAwB,GAAG,IAAI,CAAC;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,4BAA4B,GAAG,IAAI,CAAC;IAC/D,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CACnE,qBAAqB,EACrB,oBAAoB,EACpB,gCAAgC,CACjC,CAAC"}