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

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

@@ -1 +1,7 @@
-{"version":3,"file":"DefaultTypedDataParserService.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/service/DefaultTypedDataParserService.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAKvC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAO7C,IAAM,6BAA6B,GAAnC,MAAM,6BAA6B;IACxC,KAAK,CAAC,IAAe;QACnB,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,MAAM,KAAK,GAAG,MAAM,CAAC,oBAAoB,EAAE,CAAC;QAC5C,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAC/B,cAAc,EACd,IAAI,CAAC,MAAiC,CACvC,CAAC;QACF,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACnE,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CACnC,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YAC9B,KAAK;YACL,MAAM;YACN,OAAO;SACR,CAAC,CAAC,CACJ,CAAC;IACJ,CAAC;CACF,CAAA;AAjBY,6BAA6B;IADzC,UAAU,EAAE;GACA,6BAA6B,CAiBzC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/service/DefaultTypedDataParserService.ts"],
+  "sourcesContent": ["import { injectable } from \"inversify\";\nimport { Either } from \"purify-ts\";\n\nimport { TypedData } from \"@api/model/TypedData\";\n\nimport { TypedDataParser } from \"./TypedDataParser\";\nimport {\n  ParsedTypedData,\n  TypedDataParserService,\n} from \"./TypedDataParserService\";\n\n@injectable()\nexport class DefaultTypedDataParserService implements TypedDataParserService {\n  parse(data: TypedData): Either<Error, ParsedTypedData> {\n    const parser = new TypedDataParser(data.types);\n    const types = parser.getStructDefinitions();\n    const domainResult = parser.parse(\n      \"EIP712Domain\",\n      data.domain as Record<string, unknown>,\n    );\n    const messageResult = parser.parse(data.primaryType, data.message);\n    return domainResult.chain((domain) =>\n      messageResult.map((message) => ({\n        types,\n        domain,\n        message,\n      })),\n    );\n  }\n}\n"],
+  "mappings": "wMAAA,OAAS,cAAAA,MAAkB,YAK3B,OAAS,mBAAAC,MAAuB,oBAOzB,IAAMC,EAAN,KAAsE,CAC3E,MAAMC,EAAiD,CACrD,MAAMC,EAAS,IAAIC,EAAgBF,EAAK,KAAK,EACvCG,EAAQF,EAAO,qBAAqB,EACpCG,EAAeH,EAAO,MAC1B,eACAD,EAAK,MACP,EACMK,EAAgBJ,EAAO,MAAMD,EAAK,YAAaA,EAAK,OAAO,EACjE,OAAOI,EAAa,MAAOE,GACzBD,EAAc,IAAKE,IAAa,CAC9B,MAAAJ,EACA,OAAAG,EACA,QAAAC,CACF,EAAE,CACJ,CACF,CACF,EAjBaR,EAANS,EAAA,CADNC,EAAW,GACCV",
+  "names": ["injectable", "TypedDataParser", "DefaultTypedDataParserService", "data", "parser", "TypedDataParser", "types", "domainResult", "messageResult", "domain", "message", "__decorateClass", "injectable"]
+}

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

@@ -1,98 +1,2 @@
-import { hexaStringToBuffer } from "@ledgerhq/device-management-kit";
-import { Just, Maybe, Nothing } from "purify-ts";
-/**
- * Encodes a typed data value according to its type.
- * @param type The type of the value to encode.
- * @param value The value to encode into a byte array.
- * @returns An optional Uint8Array containing the encoded value, if the value was encodable for the given type.
- */
-export function encodeTypedDataValue(type, value) {
-    switch (type.name) {
-        case "string":
-            // Encode the value as a UTF-8 string
-            return typeof value !== "string"
-                ? Nothing
-                : Just(new TextEncoder().encode(value));
-        case "bytes":
-        case "address":
-            // Encode the hexadecimal string as bytes
-            return typeof value !== "string"
-                ? Nothing
-                : encodeTypedDataBytes(type, value);
-        case "bool":
-        case "uint":
-        case "int":
-            // Convert boolean values to numbers, so it can then be encoded as a number
-            if (type.name === "bool" && typeof value === "boolean") {
-                value = Number(value);
-            }
-            // Encode the value as a number
-            return typeof value !== "string" &&
-                typeof value !== "number" &&
-                typeof value !== "bigint"
-                ? Nothing
-                : encodeTypedDataNumber(type.name, type.size.mapOrDefault((s) => s * 8, 1), // Size in bits
-                value);
-    }
-}
-function encodeTypedDataBytes(type, value) {
-    const maxSize = type.name === "address" ? Just(20) : type.size;
-    const buffer = Maybe.fromNullable(hexaStringToBuffer(value));
-    return buffer.filter((b) => maxSize.mapOrDefault((s) => b.length <= s, true));
-}
-function encodeTypedDataNumber(type, sizeInBits, value) {
-    // Convert the value to a bigint
-    let bigintValue;
-    switch (typeof value) {
-        case "bigint":
-            bigintValue = value;
-            break;
-        case "number":
-            if (!Number.isInteger(value)) {
-                return Nothing;
-            }
-            bigintValue = BigInt(value);
-            break;
-        case "string":
-            if (value.length === 0) {
-                return Nothing;
-            }
-            try {
-                bigintValue = BigInt(value);
-            }
-            catch (_error) {
-                return Nothing;
-            }
-            break;
-    }
-    // Check the bounds of the value and convert it to two's complement if it is signed and negative
-    const signed = type === "int";
-    return checkBoundsAndConvert(bigintValue, BigInt(sizeInBits), signed).chain((converted) => Maybe.fromNullable(hexaStringToBuffer(converted.toString(16))));
-}
-/**
- * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.
- * @param value The value to check and convert.
- * @param sizeInBits The size of the value in bits.
- * @param signed Whether the value is signed or unsigned.
- * @returns The converted value, or null if the value is out of bounds.
- */
-function checkBoundsAndConvert(value, sizeInBits, signed) {
-    if (!signed) {
-        // Check if the value is within the bounds of an unsigned integer
-        return value >= 0n && value < 1n << sizeInBits ? Just(value) : Nothing;
-    }
-    // Check if the value is within the bounds of a signed integer
-    const limit = 1n << (sizeInBits - 1n);
-    if (value >= limit || value < -limit) {
-        return Nothing;
-    }
-    // Convert the value to two's complement if it is negative
-    // https://en.wikipedia.org/wiki/Two%27s_complement
-    if (value < 0n) {
-        const mask = (1n << sizeInBits) - 1n;
-        value = -value;
-        value = (~value & mask) + 1n;
-    }
-    return Just(value);
-}
-//# sourceMappingURL=TypedDataEncoder.js.map
+import{hexaStringToBuffer as f}from"@ledgerhq/device-management-kit";import{Just as s,Maybe as m,Nothing as i}from"purify-ts";function d(n,t){switch(n.name){case"string":return typeof t!="string"?i:s(new TextEncoder().encode(t));case"bytes":case"address":return typeof t!="string"?i:c(n,t);case"bool":case"uint":case"int":return n.name==="bool"&&typeof t=="boolean"&&(t=Number(t)),typeof t!="string"&&typeof t!="number"&&typeof t!="bigint"?i:g(n.name,n.size.mapOrDefault(r=>r*8,1),t)}}function c(n,t){const r=n.name==="address"?s(20):n.size;return m.fromNullable(f(t)).filter(o=>r.mapOrDefault(b=>o.length<=b,!0))}function g(n,t,r){let e;switch(typeof r){case"bigint":e=r;break;case"number":if(!Number.isInteger(r))return i;e=BigInt(r);break;case"string":if(r.length===0)return i;try{e=BigInt(r)}catch{return i}break}const o=n==="int";return a(e,BigInt(t),o).chain(b=>m.fromNullable(f(b.toString(16))))}function a(n,t,r){if(!r)return n>=0n&&n<1n<<t?s(n):i;const e=1n<<t-1n;if(n>=e||n<-e)return i;if(n<0n){const o=(1n<<t)-1n;n=-n,n=(~n&o)+1n}return s(n)}export{d as encodeTypedDataValue};
+//# sourceMappingURL=TypedDataEncoder.js.map

package/lib/esm/internal/typed-data/service/TypedDataEncoder.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"TypedDataEncoder.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/service/TypedDataEncoder.ts"],"names":[],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/service/TypedDataEncoder.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Just, Maybe, Nothing } from \"purify-ts\";\n\nimport {\n  type PrimitiveType,\n  type PrimitiveTypeName,\n} from \"@internal/typed-data/model/Types\";\n\n/**\n * Encodes a typed data value according to its type.\n * @param type The type of the value to encode.\n * @param value The value to encode into a byte array.\n * @returns An optional Uint8Array containing the encoded value, if the value was encodable for the given type.\n */\nexport function encodeTypedDataValue(\n  type: PrimitiveType,\n  value: unknown,\n): Maybe<Uint8Array> {\n  switch (type.name) {\n    case \"string\":\n      // Encode the value as a UTF-8 string\n      return typeof value !== \"string\"\n        ? Nothing\n        : Just(new TextEncoder().encode(value));\n    case \"bytes\":\n    case \"address\":\n      // Encode the hexadecimal string as bytes\n      return typeof value !== \"string\"\n        ? Nothing\n        : encodeTypedDataBytes(type, value);\n    case \"bool\":\n    case \"uint\":\n    case \"int\":\n      // Convert boolean values to numbers, so it can then be encoded as a number\n      if (type.name === \"bool\" && typeof value === \"boolean\") {\n        value = Number(value);\n      }\n      // Encode the value as a number\n      return typeof value !== \"string\" &&\n        typeof value !== \"number\" &&\n        typeof value !== \"bigint\"\n        ? Nothing\n        : encodeTypedDataNumber(\n            type.name,\n            type.size.mapOrDefault((s) => s * 8, 1), // Size in bits\n            value,\n          );\n  }\n}\n\nfunction encodeTypedDataBytes(\n  type: PrimitiveType,\n  value: string,\n): Maybe<Uint8Array> {\n  const maxSize = type.name === \"address\" ? Just(20) : type.size;\n  const buffer = Maybe.fromNullable(hexaStringToBuffer(value));\n  return buffer.filter((b) => maxSize.mapOrDefault((s) => b.length <= s, true));\n}\n\nfunction encodeTypedDataNumber(\n  type: PrimitiveTypeName,\n  sizeInBits: number,\n  value: string | number | bigint,\n): Maybe<Uint8Array> {\n  // Convert the value to a bigint\n  let bigintValue: bigint;\n  switch (typeof value) {\n    case \"bigint\":\n      bigintValue = value;\n      break;\n    case \"number\":\n      if (!Number.isInteger(value)) {\n        return Nothing;\n      }\n      bigintValue = BigInt(value);\n      break;\n    case \"string\":\n      if (value.length === 0) {\n        return Nothing;\n      }\n      try {\n        bigintValue = BigInt(value);\n      } catch (_error: unknown) {\n        return Nothing;\n      }\n      break;\n  }\n  // Check the bounds of the value and convert it to two's complement if it is signed and negative\n  const signed = type === \"int\";\n  return checkBoundsAndConvert(bigintValue, BigInt(sizeInBits), signed).chain(\n    (converted) =>\n      Maybe.fromNullable(hexaStringToBuffer(converted.toString(16))),\n  );\n}\n\n/**\n * Checks the bounds of a signed or unsigned integer value and converts it to two's complement if it is signed and negative.\n * @param value The value to check and convert.\n * @param sizeInBits The size of the value in bits.\n * @param signed Whether the value is signed or unsigned.\n * @returns The converted value, or null if the value is out of bounds.\n */\nfunction checkBoundsAndConvert(\n  value: bigint,\n  sizeInBits: bigint,\n  signed: boolean,\n): Maybe<bigint> {\n  if (!signed) {\n    // Check if the value is within the bounds of an unsigned integer\n    return value >= 0n && value < 1n << sizeInBits ? Just(value) : Nothing;\n  }\n\n  // Check if the value is within the bounds of a signed integer\n  const limit = 1n << (sizeInBits - 1n);\n  if (value >= limit || value < -limit) {\n    return Nothing;\n  }\n\n  // Convert the value to two's complement if it is negative\n  // https://en.wikipedia.org/wiki/Two%27s_complement\n  if (value < 0n) {\n    const mask = (1n << sizeInBits) - 1n;\n    value = -value;\n    value = (~value & mask) + 1n;\n  }\n\n  return Just(value);\n}\n"],
+  "mappings": "AAAA,OAAS,sBAAAA,MAA0B,kCACnC,OAAS,QAAAC,EAAM,SAAAC,EAAO,WAAAC,MAAe,YAa9B,SAASC,EACdC,EACAC,EACmB,CACnB,OAAQD,EAAK,KAAM,CACjB,IAAK,SAEH,OAAO,OAAOC,GAAU,SACpBH,EACAF,EAAK,IAAI,YAAY,EAAE,OAAOK,CAAK,CAAC,EAC1C,IAAK,QACL,IAAK,UAEH,OAAO,OAAOA,GAAU,SACpBH,EACAI,EAAqBF,EAAMC,CAAK,EACtC,IAAK,OACL,IAAK,OACL,IAAK,MAEH,OAAID,EAAK,OAAS,QAAU,OAAOC,GAAU,YAC3CA,EAAQ,OAAOA,CAAK,GAGf,OAAOA,GAAU,UACtB,OAAOA,GAAU,UACjB,OAAOA,GAAU,SACfH,EACAK,EACEH,EAAK,KACLA,EAAK,KAAK,aAAcI,GAAMA,EAAI,EAAG,CAAC,EACtCH,CACF,CACR,CACF,CAEA,SAASC,EACPF,EACAC,EACmB,CACnB,MAAMI,EAAUL,EAAK,OAAS,UAAYJ,EAAK,EAAE,EAAII,EAAK,KAE1D,OADeH,EAAM,aAAaF,EAAmBM,CAAK,CAAC,EAC7C,OAAQK,GAAMD,EAAQ,aAAcD,GAAME,EAAE,QAAUF,EAAG,EAAI,CAAC,CAC9E,CAEA,SAASD,EACPH,EACAO,EACAN,EACmB,CAEnB,IAAIO,EACJ,OAAQ,OAAOP,EAAO,CACpB,IAAK,SACHO,EAAcP,EACd,MACF,IAAK,SACH,GAAI,CAAC,OAAO,UAAUA,CAAK,EACzB,OAAOH,EAETU,EAAc,OAAOP,CAAK,EAC1B,MACF,IAAK,SACH,GAAIA,EAAM,SAAW,EACnB,OAAOH,EAET,GAAI,CACFU,EAAc,OAAOP,CAAK,CAC5B,MAA0B,CACxB,OAAOH,CACT,CACA,KACJ,CAEA,MAAMW,EAAST,IAAS,MACxB,OAAOU,EAAsBF,EAAa,OAAOD,CAAU,EAAGE,CAAM,EAAE,MACnEE,GACCd,EAAM,aAAaF,EAAmBgB,EAAU,SAAS,EAAE,CAAC,CAAC,CACjE,CACF,CASA,SAASD,EACPT,EACAM,EACAE,EACe,CACf,GAAI,CAACA,EAEH,OAAOR,GAAS,IAAMA,EAAQ,IAAMM,EAAaX,EAAKK,CAAK,EAAIH,EAIjE,MAAMc,EAAQ,IAAOL,EAAa,GAClC,GAAIN,GAASW,GAASX,EAAQ,CAACW,EAC7B,OAAOd,EAKT,GAAIG,EAAQ,GAAI,CACd,MAAMY,GAAQ,IAAMN,GAAc,GAClCN,EAAQ,CAACA,EACTA,GAAS,CAACA,EAAQY,GAAQ,EAC5B,CAEA,OAAOjB,EAAKK,CAAK,CACnB",
+  "names": ["hexaStringToBuffer", "Just", "Maybe", "Nothing", "encodeTypedDataValue", "type", "value", "encodeTypedDataBytes", "encodeTypedDataNumber", "s", "maxSize", "b", "sizeInBits", "bigintValue", "signed", "checkBoundsAndConvert", "converted", "limit", "mask"]
+}

package/lib/esm/internal/typed-data/service/TypedDataEncoder.test.js

@@ -0,0 +1,2 @@
+import{Just as x,Nothing as e}from"purify-ts";import{PrimitiveType as a}from"../../typed-data/model/Types";import{encodeTypedDataValue as n}from"./TypedDataEncoder";describe("TypedDataEncoder",()=>{const i=new a("address","address",e),E=new a("bytes","bytes",e),D=new a("bytes","bytes",x(7)),C=new a("string","string",e),l=new a("bool","bool",e),r=new a("int8","int",x(1)),s=new a("int16","int",x(2)),y=new a("int32","int",x(4)),u=new a("int64","int",x(8)),b=new a("int128","int",x(16)),p=new a("int256","int",x(32)),o=new a("uint8","uint",x(1)),m=new a("uint16","uint",x(2)),v=new a("uint32","uint",x(4)),A=new a("uint64","uint",x(8)),U=new a("uint128","uint",x(16)),F=new a("uint256","uint",x(32));it("Encode an address",()=>{const f=["0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC","0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826","0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF","0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57","0xBdaBea57B0BDABeA57b0bdABEA57b0BDabEa57"].map(t=>n(i,t)),c=[x(Uint8Array.from([204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204])),x(Uint8Array.from([205,42,61,159,147,142,19,205,148,126,192,90,188,127,231,52,223,141,216,38])),x(Uint8Array.from([222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239])),x(Uint8Array.from([176,189,171,234,87,176,189,171,234,87,176,189,171,234,87,176,189,171,234,87])),x(Uint8Array.from([189,171,234,87,176,189,171,234,87,176,189,171,234,87,176,189,171,234,87]))];expect(f).toStrictEqual(c)}),it("Encode an address with invalid size",()=>{const f=n(i,"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccCff");expect(f).toStrictEqual(e)}),it("Encode an address with invalid value",()=>{const f=n(i,"0xbonjourcCCCCcCCCCCCcCcCccCcCCCcCcccccccC");expect(f).toStrictEqual(e)}),it("Encode an address with invalid value type",()=>{const f=n(i,17);expect(f).toStrictEqual(e)}),it("Encode an byte array",()=>{const f=["0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcc","0x13CD947Ec05AbC7FE734Df8DD826","0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeFbeeF","0xBDabEa57"].map(t=>n(E,t)),c=[x(Uint8Array.from([204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204])),x(Uint8Array.from([19,205,148,126,192,90,188,127,231,52,223,141,216,38])),x(Uint8Array.from([222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239,190,239])),x(Uint8Array.from([189,171,234,87]))];expect(f).toStrictEqual(c)}),it("Encode an byte array with size",()=>{const f=["0x13CD947Ec05AbC","0x13CD947Ec05A","0x13CD947Ec05AbCde"].map(t=>n(D,t)),c=[x(Uint8Array.from([19,205,148,126,192,90,188])),x(Uint8Array.from([19,205,148,126,192,90])),e];expect(f).toStrictEqual(c)}),it("Encode a string",()=>{const f=["Hello, Bob!",'"did:ethr:0xf7398bacf610bb4e3b567811279fcb3c41919f89"','"2021-03-04T21:08:22.615Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>',"_<did:key:z6MkgFneaaMjN6zybqLNXgt4YfmVx2XZhzPdDyk4ZK81daHZ>"].map(t=>n(C,t)),c=[x(Uint8Array.from([72,101,108,108,111,44,32,66,111,98,33])),x(Uint8Array.from([34,100,105,100,58,101,116,104,114,58,48,120,102,55,51,57,56,98,97,99,102,54,49,48,98,98,52,101,51,98,53,54,55,56,49,49,50,55,57,102,99,98,51,99,52,49,57,49,57,102,56,57,34])),x(Uint8Array.from([34,50,48,50,49,45,48,51,45,48,52,84,50,49,58,48,56,58,50,50,46,54,49,53,90,34,94,94,60,104,116,116,112,58,47,47,119,119,119,46,119,51,46,111,114,103,47,50,48,48,49,47,88,77,76,83,99,104,101,109,97,35,100,97,116,101,84,105,109,101,62])),x(Uint8Array.from([95,60,100,105,100,58,107,101,121,58,122,54,77,107,103,70,110,101,97,97,77,106,78,54,122,121,98,113,76,78,88,103,116,52,89,102,109,86,120,50,88,90,104,122,80,100,68,121,107,52,90,75,56,49,100,97,72,90,62]))];expect(f).toStrictEqual(c)}),it("Encode a string with invalid value type",()=>{const f=n(C,17);expect(f).toStrictEqual(e)}),it("Encode a signed number",()=>{const f=[{type:r,value:127},{type:r,value:-128},{type:s,value:"32767"},{type:s,value:"-32768"},{type:y,value:"0x7FFFFFFF"},{type:y,value:"-2147483648"},{type:u,value:9223372036854775807n},{type:u,value:-9223372036854775808n},{type:b,value:"170141183460469231731687303715884105727"},{type:b,value:"-170141183460469231731687303715884105728"},{type:p,value:57896044618658097711785492504343953926634992332820282019728792003956564819967n},{type:p,value:-57896044618658097711785492504343953926634992332820282019728792003956564819968n}].map(t=>n(t.type,t.value)),c=[x(Uint8Array.from([127])),x(Uint8Array.from([128])),x(Uint8Array.from([127,255])),x(Uint8Array.from([128,0])),x(Uint8Array.from([127,255,255,255])),x(Uint8Array.from([128,0,0,0])),x(Uint8Array.from([127,255,255,255,255,255,255,255])),x(Uint8Array.from([128,0,0,0,0,0,0,0])),x(Uint8Array.from([127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255])),x(Uint8Array.from([128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])),x(Uint8Array.from([127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255])),x(Uint8Array.from([128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]))];expect(f).toStrictEqual(c)}),it("Encode a signed number, out of bounds",()=>{const f=[{type:r,value:""},{type:r,value:128},{type:r,value:-129},{type:s,value:"32768"},{type:s,value:"-32769"},{type:y,value:"0xFFFFFFFF"},{type:y,value:"-2147483649"},{type:u,value:9223372036854775808n},{type:u,value:-9223372036854775809n},{type:b,value:"170141183460469231731687303715884105728"},{type:b,value:"-170141183460469231731687303715884105729"},{type:p,value:57896044618658097711785492504343953926634992332820282019728792003956564819968n},{type:p,value:-57896044618658097711785492504343953926634992332820282019728792003956564819969n}].map(t=>n(t.type,t.value)),c=[e,e,e,e,e,e,e,e,e,e,e,e,e];expect(f).toStrictEqual(c)}),it("Encode an unsigned number",()=>{const f=[{type:o,value:0},{type:o,value:255},{type:m,value:"65535"},{type:v,value:"0xFFFFFFFF"},{type:A,value:18446744073709551615n},{type:U,value:"340282366920938463463374607431768211455"},{type:F,value:115792089237316195423570985008687907853269984665640564039457584007913129639935n}].map(t=>n(t.type,t.value)),c=[x(Uint8Array.from([0])),x(Uint8Array.from([255])),x(Uint8Array.from([255,255])),x(Uint8Array.from([255,255,255,255])),x(Uint8Array.from([255,255,255,255,255,255,255,255])),x(Uint8Array.from([255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255])),x(Uint8Array.from([255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255]))];expect(f).toStrictEqual(c)}),it("Encode an unsigned number, out of bound",()=>{const f=[{type:o,value:""},{type:o,value:.5},{type:o,value:-1},{type:o,value:256},{type:m,value:"65536"},{type:v,value:"0x100000000"},{type:A,value:18446744073709551616n},{type:U,value:"340282366920938463463374607431768211456"},{type:F,value:115792089237316195423570985008687907853269984665640564039457584007913129639936n}].map(t=>n(t.type,t.value)),c=[e,e,e,e,e,e,e,e,e];expect(f).toStrictEqual(c)}),it("Encode a boolean",()=>{const f=[!1,!0,0,1,"0","0x1"].map(t=>n(l,t)),c=[x(Uint8Array.from([0])),x(Uint8Array.from([1])),x(Uint8Array.from([0])),x(Uint8Array.from([1])),x(Uint8Array.from([0])),x(Uint8Array.from([1]))];expect(f).toStrictEqual(c)}),it("Encode a boolean, out of bounds",()=>{const f=[-1,2].map(t=>n(l,t)),c=[e,e];expect(f).toStrictEqual(c)}),it("Encode an invalid data type",()=>{const f=[{type:o,value:!0},{type:r,value:{}},{type:l,value:void 0},{type:C,value:42},{type:E,value:42},{type:i,value:!1}].map(t=>n(t.type,t.value)),c=[e,e,e,e,e,e];expect(f).toStrictEqual(c)})});
+//# sourceMappingURL=TypedDataEncoder.test.js.map

package/lib/esm/internal/typed-data/service/TypedDataEncoder.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/service/TypedDataEncoder.test.ts"],
+  "sourcesContent": ["import { Just, Nothing } from \"purify-ts\";\n\nimport { PrimitiveType } from \"@internal/typed-data/model/Types\";\n\nimport { encodeTypedDataValue } from \"./TypedDataEncoder\";\n\ndescribe(\"TypedDataEncoder\", () => {\n  const ADDRESS_TYPE = new PrimitiveType(\"address\", \"address\", Nothing);\n  const BYTES_TYPE = new PrimitiveType(\"bytes\", \"bytes\", Nothing);\n  const BYTES_TYPE_WITH_LENGTH = new PrimitiveType(\"bytes\", \"bytes\", Just(7));\n  const STRING_TYPE = new PrimitiveType(\"string\", \"string\", Nothing);\n  const BOOL_TYPE = new PrimitiveType(\"bool\", \"bool\", Nothing);\n  const I8_TYPE = new PrimitiveType(\"int8\", \"int\", Just(1));\n  const I16_TYPE = new PrimitiveType(\"int16\", \"int\", Just(2));\n  const I32_TYPE = new PrimitiveType(\"int32\", \"int\", Just(4));\n  const I64_TYPE = new PrimitiveType(\"int64\", \"int\", Just(8));\n  const I128_TYPE = new PrimitiveType(\"int128\", \"int\", Just(16));\n  const I256_TYPE = new PrimitiveType(\"int256\", \"int\", Just(32));\n  const U8_TYPE = new PrimitiveType(\"uint8\", \"uint\", Just(1));\n  const U16_TYPE = new PrimitiveType(\"uint16\", \"uint\", Just(2));\n  const U32_TYPE = new PrimitiveType(\"uint32\", \"uint\", Just(4));\n  const U64_TYPE = new PrimitiveType(\"uint64\", \"uint\", Just(8));\n  const U128_TYPE = new PrimitiveType(\"uint128\", \"uint\", Just(16));\n  const U256_TYPE = new PrimitiveType(\"uint256\", \"uint\", Just(32));\n\n  it(\"Encode an address\", () => {\n    // GIVEN\n    const addresses = [\n      \"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC\",\n      \"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826\",\n      \"0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF\",\n      \"0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57\",\n      \"0xBdaBea57B0BDABeA57b0bdABEA57b0BDabEa57\",\n    ];\n    // WHEN\n    const encoded = addresses.map((address) =>\n      encodeTypedDataValue(ADDRESS_TYPE, address),\n    );\n    // THEN\n    const expected = [\n      Just(\n        Uint8Array.from([\n          0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,\n          0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0xcd, 0x2a, 0x3d, 0x9f, 0x93, 0x8e, 0x13, 0xcd, 0x94, 0x7e, 0xc0,\n          0x5a, 0xbc, 0x7f, 0xe7, 0x34, 0xdf, 0x8d, 0xd8, 0x26,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe,\n          0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0xb0, 0xbd, 0xab, 0xea, 0x57, 0xb0, 0xbd, 0xab, 0xea, 0x57, 0xb0,\n          0xbd, 0xab, 0xea, 0x57, 0xb0, 0xbd, 0xab, 0xea, 0x57,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0xbd, 0xab, 0xea, 0x57, 0xb0, 0xbd, 0xab, 0xea, 0x57, 0xb0, 0xbd,\n          0xab, 0xea, 0x57, 0xb0, 0xbd, 0xab, 0xea, 0x57,\n        ]),\n      ),\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode an address with invalid size\", () => {\n    // GIVEN\n    const address = \"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccCff\";\n    // WHEN\n    const encoded = encodeTypedDataValue(ADDRESS_TYPE, address);\n    // THEN\n    expect(encoded).toStrictEqual(Nothing);\n  });\n\n  it(\"Encode an address with invalid value\", () => {\n    // GIVEN\n    const address = \"0xbonjourcCCCCcCCCCCCcCcCccCcCCCcCcccccccC\";\n    // WHEN\n    const encoded = encodeTypedDataValue(ADDRESS_TYPE, address);\n    // THEN\n    expect(encoded).toStrictEqual(Nothing);\n  });\n\n  it(\"Encode an address with invalid value type\", () => {\n    // GIVEN\n    const address = 17;\n    // WHEN\n    const encoded = encodeTypedDataValue(ADDRESS_TYPE, address);\n    // THEN\n    expect(encoded).toStrictEqual(Nothing);\n  });\n\n  it(\"Encode an byte array\", () => {\n    // GIVEN\n    const bytes = [\n      \"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcc\",\n      \"0x13CD947Ec05AbC7FE734Df8DD826\",\n      \"0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeFbeeF\",\n      \"0xBDabEa57\",\n    ];\n    // WHEN\n    const encoded = bytes.map((b) => encodeTypedDataValue(BYTES_TYPE, b));\n    // THEN\n    const expected = [\n      Just(\n        Uint8Array.from([\n          0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,\n          0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x13, 0xcd, 0x94, 0x7e, 0xc0, 0x5a, 0xbc, 0x7f, 0xe7, 0x34, 0xdf,\n          0x8d, 0xd8, 0x26,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe,\n          0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xbe, 0xef,\n        ]),\n      ),\n      Just(Uint8Array.from([0xbd, 0xab, 0xea, 0x57])),\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode an byte array with size\", () => {\n    // GIVEN\n    const bytes = [\"0x13CD947Ec05AbC\", \"0x13CD947Ec05A\", \"0x13CD947Ec05AbCde\"];\n    // WHEN\n    const encoded = bytes.map((b) =>\n      encodeTypedDataValue(BYTES_TYPE_WITH_LENGTH, b),\n    );\n    // THEN\n    const expected = [\n      Just(Uint8Array.from([0x13, 0xcd, 0x94, 0x7e, 0xc0, 0x5a, 0xbc])),\n      Just(Uint8Array.from([0x13, 0xcd, 0x94, 0x7e, 0xc0, 0x5a])),\n      Nothing,\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode a string\", () => {\n    // GIVEN\n    const strings = [\n      \"Hello, Bob!\",\n      '\"did:ethr:0xf7398bacf610bb4e3b567811279fcb3c41919f89\"',\n      '\"2021-03-04T21:08:22.615Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime>',\n      \"_<did:key:z6MkgFneaaMjN6zybqLNXgt4YfmVx2XZhzPdDyk4ZK81daHZ>\",\n    ];\n    // WHEN\n    const encoded = strings.map((str) =>\n      encodeTypedDataValue(STRING_TYPE, str),\n    );\n    // THEN\n    const expected = [\n      Just(\n        Uint8Array.from([\n          0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x42, 0x6f, 0x62, 0x21,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x22, 0x64, 0x69, 0x64, 0x3a, 0x65, 0x74, 0x68, 0x72, 0x3a, 0x30,\n          0x78, 0x66, 0x37, 0x33, 0x39, 0x38, 0x62, 0x61, 0x63, 0x66, 0x36,\n          0x31, 0x30, 0x62, 0x62, 0x34, 0x65, 0x33, 0x62, 0x35, 0x36, 0x37,\n          0x38, 0x31, 0x31, 0x32, 0x37, 0x39, 0x66, 0x63, 0x62, 0x33, 0x63,\n          0x34, 0x31, 0x39, 0x31, 0x39, 0x66, 0x38, 0x39, 0x22,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x22, 0x32, 0x30, 0x32, 0x31, 0x2d, 0x30, 0x33, 0x2d, 0x30, 0x34,\n          0x54, 0x32, 0x31, 0x3a, 0x30, 0x38, 0x3a, 0x32, 0x32, 0x2e, 0x36,\n          0x31, 0x35, 0x5a, 0x22, 0x5e, 0x5e, 0x3c, 0x68, 0x74, 0x74, 0x70,\n          0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f,\n          0x72, 0x67, 0x2f, 0x32, 0x30, 0x30, 0x31, 0x2f, 0x58, 0x4d, 0x4c,\n          0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x23, 0x64, 0x61, 0x74, 0x65,\n          0x54, 0x69, 0x6d, 0x65, 0x3e,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x5f, 0x3c, 0x64, 0x69, 0x64, 0x3a, 0x6b, 0x65, 0x79, 0x3a, 0x7a,\n          0x36, 0x4d, 0x6b, 0x67, 0x46, 0x6e, 0x65, 0x61, 0x61, 0x4d, 0x6a,\n          0x4e, 0x36, 0x7a, 0x79, 0x62, 0x71, 0x4c, 0x4e, 0x58, 0x67, 0x74,\n          0x34, 0x59, 0x66, 0x6d, 0x56, 0x78, 0x32, 0x58, 0x5a, 0x68, 0x7a,\n          0x50, 0x64, 0x44, 0x79, 0x6b, 0x34, 0x5a, 0x4b, 0x38, 0x31, 0x64,\n          0x61, 0x48, 0x5a, 0x3e,\n        ]),\n      ),\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode a string with invalid value type\", () => {\n    // GIVEN\n    const string = 17;\n    // WHEN\n    const encoded = encodeTypedDataValue(STRING_TYPE, string);\n    // THEN\n    expect(encoded).toStrictEqual(Nothing);\n  });\n\n  it(\"Encode a signed number\", () => {\n    // GIVEN\n    const signed = [\n      { type: I8_TYPE, value: 127 },\n      { type: I8_TYPE, value: -128 },\n      { type: I16_TYPE, value: \"32767\" },\n      { type: I16_TYPE, value: \"-32768\" },\n      { type: I32_TYPE, value: \"0x7FFFFFFF\" },\n      { type: I32_TYPE, value: \"-2147483648\" },\n      { type: I64_TYPE, value: 9223372036854775807n },\n      { type: I64_TYPE, value: -9223372036854775808n },\n      { type: I128_TYPE, value: \"170141183460469231731687303715884105727\" },\n      { type: I128_TYPE, value: \"-170141183460469231731687303715884105728\" },\n      {\n        type: I256_TYPE,\n        value:\n          57896044618658097711785492504343953926634992332820282019728792003956564819967n,\n      },\n      {\n        type: I256_TYPE,\n        value:\n          -57896044618658097711785492504343953926634992332820282019728792003956564819968n,\n      },\n    ];\n    // WHEN\n    const encoded = signed.map((s) => encodeTypedDataValue(s.type, s.value));\n    // THEN\n    const expected = [\n      Just(Uint8Array.from([0x7f])),\n      Just(Uint8Array.from([0x80])),\n      Just(Uint8Array.from([0x7f, 0xff])),\n      Just(Uint8Array.from([0x80, 0x00])),\n      Just(Uint8Array.from([0x7f, 0xff, 0xff, 0xff])),\n      Just(Uint8Array.from([0x80, 0x00, 0x00, 0x00])),\n      Just(Uint8Array.from([0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])),\n      Just(Uint8Array.from([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])),\n      Just(\n        Uint8Array.from([\n          0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n          0xff, 0xff, 0xff, 0xff, 0xff,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n          0x00, 0x00, 0x00, 0x00, 0x00,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n        ]),\n      ),\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode a signed number, out of bounds\", () => {\n    // GIVEN\n    const signed = [\n      { type: I8_TYPE, value: \"\" },\n      { type: I8_TYPE, value: 128 },\n      { type: I8_TYPE, value: -129 },\n      { type: I16_TYPE, value: \"32768\" },\n      { type: I16_TYPE, value: \"-32769\" },\n      { type: I32_TYPE, value: \"0xFFFFFFFF\" },\n      { type: I32_TYPE, value: \"-2147483649\" },\n      { type: I64_TYPE, value: 9223372036854775808n },\n      { type: I64_TYPE, value: -9223372036854775809n },\n      { type: I128_TYPE, value: \"170141183460469231731687303715884105728\" },\n      { type: I128_TYPE, value: \"-170141183460469231731687303715884105729\" },\n      {\n        type: I256_TYPE,\n        value:\n          57896044618658097711785492504343953926634992332820282019728792003956564819968n,\n      },\n      {\n        type: I256_TYPE,\n        value:\n          -57896044618658097711785492504343953926634992332820282019728792003956564819969n,\n      },\n    ];\n    // WHEN\n    const encoded = signed.map((s) => encodeTypedDataValue(s.type, s.value));\n    // THEN\n    const expected = [\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode an unsigned number\", () => {\n    // GIVEN\n    const unsigned = [\n      { type: U8_TYPE, value: 0 },\n      { type: U8_TYPE, value: 255 },\n      { type: U16_TYPE, value: \"65535\" },\n      { type: U32_TYPE, value: \"0xFFFFFFFF\" },\n      { type: U64_TYPE, value: 18446744073709551615n },\n      { type: U128_TYPE, value: \"340282366920938463463374607431768211455\" },\n      {\n        type: U256_TYPE,\n        value:\n          115792089237316195423570985008687907853269984665640564039457584007913129639935n,\n      },\n    ];\n    // WHEN\n    const encoded = unsigned.map((s) => encodeTypedDataValue(s.type, s.value));\n    // THEN\n    const expected = [\n      Just(Uint8Array.from([0x00])),\n      Just(Uint8Array.from([0xff])),\n      Just(Uint8Array.from([0xff, 0xff])),\n      Just(Uint8Array.from([0xff, 0xff, 0xff, 0xff])),\n      Just(Uint8Array.from([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])),\n      Just(\n        Uint8Array.from([\n          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n          0xff, 0xff, 0xff, 0xff, 0xff,\n        ]),\n      ),\n      Just(\n        Uint8Array.from([\n          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\n        ]),\n      ),\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode an unsigned number, out of bound\", () => {\n    // GIVEN\n    const unsigned = [\n      { type: U8_TYPE, value: \"\" },\n      { type: U8_TYPE, value: 0.5 },\n      { type: U8_TYPE, value: -1 },\n      { type: U8_TYPE, value: 256 },\n      { type: U16_TYPE, value: \"65536\" },\n      { type: U32_TYPE, value: \"0x100000000\" },\n      { type: U64_TYPE, value: 18446744073709551616n },\n      { type: U128_TYPE, value: \"340282366920938463463374607431768211456\" },\n      {\n        type: U256_TYPE,\n        value:\n          115792089237316195423570985008687907853269984665640564039457584007913129639936n,\n      },\n    ];\n    // WHEN\n    const encoded = unsigned.map((s) => encodeTypedDataValue(s.type, s.value));\n    // THEN\n    const expected = [\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n      Nothing,\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode a boolean\", () => {\n    // GIVEN\n    const bools = [false, true, 0, 1, \"0\", \"0x1\"];\n    // WHEN\n    const encoded = bools.map((b) => encodeTypedDataValue(BOOL_TYPE, b));\n    // THEN\n    const expected = [\n      Just(Uint8Array.from([0x00])),\n      Just(Uint8Array.from([0x01])),\n      Just(Uint8Array.from([0x00])),\n      Just(Uint8Array.from([0x01])),\n      Just(Uint8Array.from([0x00])),\n      Just(Uint8Array.from([0x01])),\n    ];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode a boolean, out of bounds\", () => {\n    // GIVEN\n    const bools = [-1, 2];\n    // WHEN\n    const encoded = bools.map((b) => encodeTypedDataValue(BOOL_TYPE, b));\n    // THEN\n    const expected = [Nothing, Nothing];\n    expect(encoded).toStrictEqual(expected);\n  });\n\n  it(\"Encode an invalid data type\", () => {\n    // GIVEN\n    const data = [\n      { type: U8_TYPE, value: true },\n      { type: I8_TYPE, value: {} },\n      { type: BOOL_TYPE, value: undefined },\n      { type: STRING_TYPE, value: 42 },\n      { type: BYTES_TYPE, value: 42 },\n      { type: ADDRESS_TYPE, value: false },\n    ];\n    // WHEN\n    const encoded = data.map((d) => encodeTypedDataValue(d.type, d.value));\n    // THEN\n    const expected = [Nothing, Nothing, Nothing, Nothing, Nothing, Nothing];\n    expect(encoded).toStrictEqual(expected);\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["Just", "Nothing", "PrimitiveType", "encodeTypedDataValue", "ADDRESS_TYPE", "BYTES_TYPE", "BYTES_TYPE_WITH_LENGTH", "STRING_TYPE", "BOOL_TYPE", "I8_TYPE", "I16_TYPE", "I32_TYPE", "I64_TYPE", "I128_TYPE", "I256_TYPE", "U8_TYPE", "U16_TYPE", "U32_TYPE", "U64_TYPE", "U128_TYPE", "U256_TYPE", "encoded", "address", "expected", "b", "str", "s", "d"]
+}

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

@@ -1,207 +1,2 @@
-import { Just, Left, Maybe, Nothing, Right } from "purify-ts";
-import { ArrayType, PrimitiveType, StructType, TypedDataValueArray, TypedDataValueField, TypedDataValueRoot, } from "../../typed-data/model/Types";
-import { encodeTypedDataValue } from "./TypedDataEncoder";
-/**
- * A parser for EIP-712 typed data messages.
- *
- * ```typescript
- * const types = {
- *   Person: [
- *     { name: 'name', type: 'string' },
- *     { name: 'age', type: 'uint256' },
- *     { name: "wallets", type: "address[]" },
- *   ],
- * };
- * const parser = new TypedDataParser(types);
- *
- * const message = {
- *   name: 'Alice',
- *   age: 30,
- *   wallets: [
- *     "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
- *     "0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB",
- *   ],
- * };
- * const rootType = 'Person';
- *
- * const result = parser.parse(rootType, message);
- * ```
- */
-export class TypedDataParser {
-    structs;
-    /**
-     * Creates a new instance of the TypedDataParser class.
-     * @param types The types to be used for parsing the message.
-     */
-    constructor(types) {
-        // Parse the types to be used later for parsing a message.
-        const structs = {};
-        for (const [typedName, typedData] of Object.entries(types)) {
-            const parsedTypedData = {};
-            for (const data of typedData) {
-                parsedTypedData[data.name] = this.parseType(data.type);
-            }
-            structs[typedName] = parsedTypedData;
-        }
-        this.structs = structs;
-    }
-    /**
-     * Returns the parsed definitions of custom structs as defined in the types passed to the constructor.
-     * @returns The struct definitions.
-     */
-    getStructDefinitions() {
-        return this.structs;
-    }
-    /**
-     * Parses a message according to the primary type and the types passed to the constructor.
-     * @param primaryType The root type of the message.
-     * @param message The message to parse.
-     * @returns An Either containing the parsed values or an error.
-     */
-    parse(primaryType, message) {
-        if (!this.isRecord(message)) {
-            return Left(new Error("Message is not a record"));
-        }
-        const values = [
-            {
-                path: "",
-                type: "",
-                value: new TypedDataValueRoot(primaryType),
-            },
-        ];
-        return this.visitValue(primaryType, message, "", (val) => values.push(val))
-            ? Right(values)
-            : Left(new Error("Failed to parse"));
-    }
-    isRecord(value) {
-        return typeof value === "object" && value !== null;
-    }
-    /**
-     * Parses a type string description into a PrimitiveType, ArrayType, or StructType object.
-     * The description string should match https://eips.ethereum.org/EIPS/eip-712#definition-of-typed-structured-data-%F0%9D%95%8A
-     * Any string which doesn't match those patterns is considered a custom struct.
-     * @param type The type string to parse.
-     * @returns The parsed type object.
-     */
-    parseType(type) {
-        return this.tryParsePrimitiveType(type).mapOrDefault((just) => just, this.tryParseArrayType(type).mapOrDefault((just) => just, new StructType(type)));
-    }
-    tryParsePrimitiveType(type) {
-        // int8 to int256 and uint8 to uint256
-        {
-            const match = type.match(/^(((u?)int)(\d+))$/);
-            if (match) {
-                const size = parseInt(match[4]);
-                if (size % 8 !== 0 || size === 0 || size > 256) {
-                    return Nothing; // Unsupported number
-                }
-                return Just(new PrimitiveType(match[1], // typeName such as uint64
-                match[3] ? "uint" : "int", // name such as uint
-                Just(size / 8)));
-            }
-        }
-        // bytes1 to bytes32, or bytes (dynamic size)
-        {
-            const match = type.match(/^((bytes)(\d*))$/);
-            if (match) {
-                const size = match[3] ? parseInt(match[3]) : null;
-                if (size !== null && (size === 0 || size > 32)) {
-                    return Nothing; // Unsupported  byte array
-                }
-                return Just(new PrimitiveType(match[1], // typename such as bytes32
-                "bytes", // name
-                Maybe.fromNullable(size)));
-            }
-        }
-        // Other primitive types
-        if (type === "address" || type === "bool" || type === "string") {
-            return Just(new PrimitiveType(type, // typeName
-            type, // name
-            Nothing));
-        }
-        // Not a primitive type
-        return Nothing;
-    }
-    tryParseArrayType(type) {
-        // Try to match an array such as: foo[2][][3]
-        const match = type.match(/^([^[[]*)(((\[\d*\])*)\[\d*\])$/);
-        if (match) {
-            const matchLevels = [...match[2].matchAll(/\[(\d*)\]/g)];
-            if (matchLevels && matchLevels.length > 0) {
-                const levels = matchLevels.map(([, size]) => size ? Just(parseInt(size)) : Nothing);
-                const rootType = this.tryParsePrimitiveType(match[1]).mapOrDefault((just) => just, new StructType(match[1]));
-                return Just(new ArrayType(type, // typeName such as: foo[2][][3]
-                rootType, // rootType such as: foo
-                match[1] + match[3], // rowType such as: foo[2][]
-                levels[levels.length - 1], // rows count such as: 3
-                levels));
-            }
-        }
-        // Not an array
-        return Nothing;
-    }
-    /**
-     * Visits a value and its children recursively, parsing them into TypedDataValue objects.
-     * @param type The type of the value.
-     * @param value The value to visit.
-     * @param path The path of the value.
-     * @param callback The callback to call for each parsed value.
-     * @returns True if the value and its children were successfully parsed, false otherwise.
-     */
-    visitValue(type, value, path, callback) {
-        return (this.tryVisitStructValue(type, value, path, callback) ||
-            this.tryVisitPrimitiveValue(type, value, path, callback) ||
-            this.tryVisitArrayValue(type, value, path, callback));
-    }
-    tryVisitPrimitiveValue(type, value, path, callback) {
-        // Basic type (address, bool, uint256, etc)
-        return (!this.isRecord(value) &&
-            !Array.isArray(value) &&
-            this.tryParsePrimitiveType(type)
-                .chain((primitiveType) => encodeTypedDataValue(primitiveType, value).ifJust((encoded) => {
-                callback({
-                    path,
-                    type,
-                    value: new TypedDataValueField(encoded),
-                });
-            }))
-                .isJust());
-    }
-    tryVisitStructValue(type, value, path, callback) {
-        const structType = this.structs[type];
-        if (structType === undefined || !this.isRecord(value)) {
-            return false;
-        }
-        for (const [fieldName, fieldType] of Object.entries(structType)) {
-            const fieldValue = value[fieldName];
-            if (fieldValue === undefined) {
-                return false;
-            }
-            const nextPath = path.length ? `${path}.${fieldName}` : fieldName;
-            if (!this.visitValue(fieldType.typeName, fieldValue, `${nextPath}`, callback)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    tryVisitArrayValue(type, value, path, callback) {
-        return (Array.isArray(value) &&
-            this.tryParseArrayType(type)
-                .filter((t) => t.count.mapOrDefault((c) => value.length == c, true))
-                .mapOrDefault((t) => {
-                callback({
-                    path: path,
-                    type,
-                    value: new TypedDataValueArray(value.length),
-                });
-                for (const entry of value) {
-                    const nextPath = path.length ? `${path}.[]` : "[]";
-                    if (!this.visitValue(t.rowType, entry, `${nextPath}`, callback)) {
-                        return false;
-                    }
-                }
-                return true;
-            }, false));
-    }
-}
-//# sourceMappingURL=TypedDataParser.js.map
+import{Just as s,Left as d,Maybe as f,Nothing as o,Right as m}from"purify-ts";import{ArrayType as T,PrimitiveType as y,StructType as p,TypedDataValueArray as h,TypedDataValueField as V,TypedDataValueRoot as g}from"../../typed-data/model/Types";import{encodeTypedDataValue as v}from"./TypedDataEncoder";class R{structs;constructor(t){const e={};for(const[r,i]of Object.entries(t)){const n={};for(const a of i)n[a.name]=this.parseType(a.type);e[r]=n}this.structs=e}getStructDefinitions(){return this.structs}parse(t,e){if(!this.isRecord(e))return d(new Error("Message is not a record"));const r=[{path:"",type:"",value:new g(t)}];return this.visitValue(t,e,"",i=>r.push(i))?m(r):d(new Error("Failed to parse"))}isRecord(t){return typeof t=="object"&&t!==null}parseType(t){return this.tryParsePrimitiveType(t).mapOrDefault(e=>e,this.tryParseArrayType(t).mapOrDefault(e=>e,new p(t)))}tryParsePrimitiveType(t){{const e=t.match(/^(((u?)int)(\d+))$/);if(e){const r=parseInt(e[4]);return r%8!==0||r===0||r>256?o:s(new y(e[1],e[3]?"uint":"int",s(r/8)))}}{const e=t.match(/^((bytes)(\d*))$/);if(e){const r=e[3]?parseInt(e[3]):null;return r!==null&&(r===0||r>32)?o:s(new y(e[1],"bytes",f.fromNullable(r)))}}return t==="address"||t==="bool"||t==="string"?s(new y(t,t,o)):o}tryParseArrayType(t){const e=t.match(/^([^[[]*)(((\[\d*\])*)\[\d*\])$/);if(e){const r=[...e[2].matchAll(/\[(\d*)\]/g)];if(r&&r.length>0){const i=r.map(([,a])=>a?s(parseInt(a)):o),n=this.tryParsePrimitiveType(e[1]).mapOrDefault(a=>a,new p(e[1]));return s(new T(t,n,e[1]+e[3],i[i.length-1],i))}}return o}visitValue(t,e,r,i){return this.tryVisitStructValue(t,e,r,i)||this.tryVisitPrimitiveValue(t,e,r,i)||this.tryVisitArrayValue(t,e,r,i)}tryVisitPrimitiveValue(t,e,r,i){return!this.isRecord(e)&&!Array.isArray(e)&&this.tryParsePrimitiveType(t).chain(n=>v(n,e).ifJust(a=>{i({path:r,type:t,value:new V(a)})})).isJust()}tryVisitStructValue(t,e,r,i){const n=this.structs[t];if(n===void 0||!this.isRecord(e))return!1;for(const[a,u]of Object.entries(n)){const l=e[a];if(l===void 0)return!1;const c=r.length?`${r}.${a}`:a;if(!this.visitValue(u.typeName,l,`${c}`,i))return!1}return!0}tryVisitArrayValue(t,e,r,i){return Array.isArray(e)&&this.tryParseArrayType(t).filter(n=>n.count.mapOrDefault(a=>e.length==a,!0)).mapOrDefault(n=>{i({path:r,type:t,value:new h(e.length)});for(const a of e){const u=r.length?`${r}.[]`:"[]";if(!this.visitValue(n.rowType,a,`${u}`,i))return!1}return!0},!1)}}export{R as TypedDataParser};
+//# sourceMappingURL=TypedDataParser.js.map

package/lib/esm/internal/typed-data/service/TypedDataParser.js.map

@@ -1 +1,7 @@
-{"version":3,"file":"TypedDataParser.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/service/TypedDataParser.ts"],"names":[],"mappings":"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"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/service/TypedDataParser.ts"],
+  "sourcesContent": ["import { type Either, Just, Left, Maybe, Nothing, Right } from \"purify-ts\";\n\nimport { type TypedDataField } from \"@api/model/TypedData\";\nimport {\n  ArrayType,\n  type FieldName,\n  type FieldType,\n  PrimitiveType,\n  type StructName,\n  StructType,\n  type TypedDataValue,\n  TypedDataValueArray,\n  TypedDataValueField,\n  TypedDataValueRoot,\n} from \"@internal/typed-data/model/Types\";\n\nimport { encodeTypedDataValue } from \"./TypedDataEncoder\";\n\n/**\n * A parser for EIP-712 typed data messages.\n *\n * ```typescript\n * const types = {\n *   Person: [\n *     { name: 'name', type: 'string' },\n *     { name: 'age', type: 'uint256' },\n *     { name: \"wallets\", type: \"address[]\" },\n *   ],\n * };\n * const parser = new TypedDataParser(types);\n *\n * const message = {\n *   name: 'Alice',\n *   age: 30,\n *   wallets: [\n *     \"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB\",\n *     \"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB\",\n *   ],\n * };\n * const rootType = 'Person';\n *\n * const result = parser.parse(rootType, message);\n * ```\n */\nexport class TypedDataParser {\n  private readonly structs: Record<StructName, Record<FieldName, FieldType>>;\n\n  /**\n   * Creates a new instance of the TypedDataParser class.\n   * @param types The types to be used for parsing the message.\n   */\n  constructor(types: Record<string, Array<TypedDataField>>) {\n    // Parse the types to be used later for parsing a message.\n    const structs: Record<StructName, Record<FieldName, FieldType>> = {};\n    for (const [typedName, typedData] of Object.entries(types)) {\n      const parsedTypedData: Record<FieldName, FieldType> = {};\n      for (const data of typedData) {\n        parsedTypedData[data.name] = this.parseType(data.type);\n      }\n      structs[typedName] = parsedTypedData;\n    }\n    this.structs = structs;\n  }\n\n  /**\n   * Returns the parsed definitions of custom structs as defined in the types passed to the constructor.\n   * @returns The struct definitions.\n   */\n  public getStructDefinitions(): Record<\n    StructName,\n    Record<FieldName, FieldType>\n  > {\n    return this.structs;\n  }\n\n  /**\n   * Parses a message according to the primary type and the types passed to the constructor.\n   * @param primaryType The root type of the message.\n   * @param message The message to parse.\n   * @returns An Either containing the parsed values or an error.\n   */\n  public parse(\n    primaryType: string,\n    message: unknown,\n  ): Either<Error, Array<TypedDataValue>> {\n    if (!this.isRecord(message)) {\n      return Left(new Error(\"Message is not a record\"));\n    }\n    const values: Array<TypedDataValue> = [\n      {\n        path: \"\",\n        type: \"\",\n        value: new TypedDataValueRoot(primaryType),\n      },\n    ];\n    return this.visitValue(primaryType, message, \"\", (val) => values.push(val))\n      ? Right(values)\n      : Left(new Error(\"Failed to parse\"));\n  }\n\n  private isRecord(value: unknown): value is Record<string, unknown> {\n    return typeof value === \"object\" && value !== null;\n  }\n\n  /**\n   * Parses a type string description into a PrimitiveType, ArrayType, or StructType object.\n   * The description string should match https://eips.ethereum.org/EIPS/eip-712#definition-of-typed-structured-data-%F0%9D%95%8A\n   * Any string which doesn't match those patterns is considered a custom struct.\n   * @param type The type string to parse.\n   * @returns The parsed type object.\n   */\n  private parseType(type: string): PrimitiveType | ArrayType | StructType {\n    return this.tryParsePrimitiveType(type).mapOrDefault(\n      (just) => just,\n      this.tryParseArrayType(type).mapOrDefault(\n        (just) => just,\n        new StructType(type),\n      ),\n    );\n  }\n\n  private tryParsePrimitiveType(type: string): Maybe<PrimitiveType> {\n    // int8 to int256 and uint8 to uint256\n    {\n      const match = type.match(/^(((u?)int)(\\d+))$/);\n      if (match) {\n        const size = parseInt(match[4]!);\n        if (size % 8 !== 0 || size === 0 || size > 256) {\n          return Nothing; // Unsupported number\n        }\n        return Just(\n          new PrimitiveType(\n            match[1]!, // typeName such as uint64\n            match[3] ? \"uint\" : \"int\", // name such as uint\n            Just(size / 8), // size in bytes such as 8 for an uint64\n          ),\n        );\n      }\n    }\n\n    // bytes1 to bytes32, or bytes (dynamic size)\n    {\n      const match = type.match(/^((bytes)(\\d*))$/);\n      if (match) {\n        const size = match[3] ? parseInt(match[3]) : null;\n        if (size !== null && (size === 0 || size > 32)) {\n          return Nothing; // Unsupported  byte array\n        }\n        return Just(\n          new PrimitiveType(\n            match[1]!, // typename such as bytes32\n            \"bytes\", // name\n            Maybe.fromNullable(size), // size in bytes, or null for a dynamic size\n          ),\n        );\n      }\n    }\n\n    // Other primitive types\n    if (type === \"address\" || type === \"bool\" || type === \"string\") {\n      return Just(\n        new PrimitiveType(\n          type, // typeName\n          type, // name\n          Nothing, // size not applicable for those types\n        ),\n      );\n    }\n\n    // Not a primitive type\n    return Nothing;\n  }\n\n  private tryParseArrayType(type: string): Maybe<ArrayType> {\n    // Try to match an array such as: foo[2][][3]\n    const match = type.match(/^([^[[]*)(((\\[\\d*\\])*)\\[\\d*\\])$/);\n    if (match) {\n      const matchLevels = [...match[2]!.matchAll(/\\[(\\d*)\\]/g)];\n      if (matchLevels && matchLevels.length > 0) {\n        const levels = matchLevels.map(([, size]) =>\n          size ? Just(parseInt(size)) : Nothing,\n        );\n        const rootType = this.tryParsePrimitiveType(match[1]!).mapOrDefault(\n          (just) => just,\n          new StructType(match[1]!),\n        );\n        return Just(\n          new ArrayType(\n            type, // typeName such as: foo[2][][3]\n            rootType, // rootType such as: foo\n            match[1]! + match[3], // rowType such as: foo[2][]\n            levels[levels.length - 1]!, // rows count such as: 3\n            levels, // All levels for that array (null for dynamic size), such as: [2, null, 3]\n          ),\n        );\n      }\n    }\n\n    // Not an array\n    return Nothing;\n  }\n\n  /**\n   * Visits a value and its children recursively, parsing them into TypedDataValue objects.\n   * @param type The type of the value.\n   * @param value The value to visit.\n   * @param path The path of the value.\n   * @param callback The callback to call for each parsed value.\n   * @returns True if the value and its children were successfully parsed, false otherwise.\n   */\n  private visitValue(\n    type: string,\n    value: unknown,\n    path: string,\n    callback: (parsedValue: TypedDataValue) => void,\n  ): boolean {\n    return (\n      this.tryVisitStructValue(type, value, path, callback) ||\n      this.tryVisitPrimitiveValue(type, value, path, callback) ||\n      this.tryVisitArrayValue(type, value, path, callback)\n    );\n  }\n\n  private tryVisitPrimitiveValue(\n    type: string,\n    value: unknown,\n    path: string,\n    callback: (parsedValue: TypedDataValue) => void,\n  ): boolean {\n    // Basic type (address, bool, uint256, etc)\n    return (\n      !this.isRecord(value) &&\n      !Array.isArray(value) &&\n      this.tryParsePrimitiveType(type)\n        .chain((primitiveType) =>\n          encodeTypedDataValue(primitiveType, value).ifJust((encoded) => {\n            callback({\n              path,\n              type,\n              value: new TypedDataValueField(encoded),\n            });\n          }),\n        )\n        .isJust()\n    );\n  }\n\n  private tryVisitStructValue(\n    type: string,\n    value: unknown,\n    path: string,\n    callback: (parsedValue: TypedDataValue) => void,\n  ): boolean {\n    const structType = this.structs[type];\n    if (structType === undefined || !this.isRecord(value)) {\n      return false;\n    }\n    for (const [fieldName, fieldType] of Object.entries(structType)) {\n      const fieldValue = value[fieldName];\n      if (fieldValue === undefined) {\n        return false;\n      }\n      const nextPath = path.length ? `${path}.${fieldName}` : fieldName;\n      if (\n        !this.visitValue(\n          fieldType.typeName,\n          fieldValue,\n          `${nextPath}`,\n          callback,\n        )\n      ) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private tryVisitArrayValue(\n    type: string,\n    value: unknown,\n    path: string,\n    callback: (parsedValue: TypedDataValue) => void,\n  ): boolean {\n    return (\n      Array.isArray(value) &&\n      this.tryParseArrayType(type)\n        .filter((t) => t.count.mapOrDefault((c) => value.length == c, true))\n        .mapOrDefault((t) => {\n          callback({\n            path: path,\n            type,\n            value: new TypedDataValueArray(value.length),\n          });\n          for (const entry of value) {\n            const nextPath = path.length ? `${path}.[]` : \"[]\";\n            if (!this.visitValue(t.rowType, entry, `${nextPath}`, callback)) {\n              return false;\n            }\n          }\n          return true;\n        }, false)\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["Just", "Left", "Maybe", "Nothing", "Right", "ArrayType", "PrimitiveType", "StructType", "TypedDataValueArray", "TypedDataValueField", "TypedDataValueRoot", "encodeTypedDataValue", "TypedDataParser", "types", "structs", "typedName", "typedData", "parsedTypedData", "data", "primaryType", "message", "values", "val", "value", "type", "just", "match", "size", "matchLevels", "levels", "rootType", "path", "callback", "primitiveType", "encoded", "structType", "fieldName", "fieldType", "fieldValue", "nextPath", "t", "c", "entry"]
+}

package/lib/esm/internal/typed-data/service/TypedDataParser.test.js

@@ -0,0 +1,2 @@
+import{hexaStringToBuffer as u}from"@ledgerhq/device-management-kit";import{Just as s,Nothing as o,Right as w}from"purify-ts";import{ArrayType as d,PrimitiveType as r,StructType as m,TypedDataValueArray as b,TypedDataValueField as y,TypedDataValueRoot as f}from"../../typed-data/model/Types";import{TypedDataParser as p}from"./TypedDataParser";describe("TypedDataParser - types parsing",()=>{it("Parse primitive types bytes",()=>{const i={TestStruct:[{name:"test1",type:"bytes"},{name:"test2",type:"bytes1"},{name:"test3",type:"bytes2"},{name:"test4",type:"bytes31"},{name:"test5",type:"bytes32"}]},e=new p(i),t={TestStruct:{test1:new r("bytes","bytes",o),test2:new r("bytes1","bytes",s(1)),test3:new r("bytes2","bytes",s(2)),test4:new r("bytes31","bytes",s(31)),test5:new r("bytes32","bytes",s(32))}};expect(e.getStructDefinitions()).toStrictEqual(t)}),it("Parse primitive types bytes, out of bound",()=>{const i={TestStruct:[{name:"invalid1",type:"bytes0"},{name:"invalid2",type:"bytes33"}]},e=new p(i),t={TestStruct:{invalid1:new m("bytes0"),invalid2:new m("bytes33")}};expect(e.getStructDefinitions()).toStrictEqual(t)}),it("Parse primitive types number",()=>{const i={TestStruct:[{name:"test1",type:"int8"},{name:"test2",type:"uint8"},{name:"test3",type:"int16"},{name:"test4",type:"uint32"},{name:"test5",type:"uint64"},{name:"test6",type:"int128"},{name:"test7",type:"int136"},{name:"test8",type:"int144"},{name:"test9",type:"uint240"},{name:"test10",type:"uint248"},{name:"test11",type:"uint256"},{name:"test12",type:"int256"}]},e=new p(i),t={TestStruct:{test1:new r("int8","int",s(1)),test2:new r("uint8","uint",s(1)),test3:new r("int16","int",s(2)),test4:new r("uint32","uint",s(4)),test5:new r("uint64","uint",s(8)),test6:new r("int128","int",s(16)),test7:new r("int136","int",s(17)),test8:new r("int144","int",s(18)),test9:new r("uint240","uint",s(30)),test10:new r("uint248","uint",s(31)),test11:new r("uint256","uint",s(32)),test12:new r("int256","int",s(32))}};expect(e.getStructDefinitions()).toStrictEqual(t)}),it("Parse primitive types number, out of bound",()=>{const i={TestStruct:[{name:"invalid1",type:"int0"},{name:"invalid2",type:"uint0"},{name:"invalid3",type:"int7"},{name:"invalid4",type:"int257"},{name:"invalid5",type:"uint257"},{name:"invalid6",type:"int512"}]},e=new p(i),t={TestStruct:{invalid1:new m("int0"),invalid2:new m("uint0"),invalid3:new m("int7"),invalid4:new m("int257"),invalid5:new m("uint257"),invalid6:new m("int512")}};expect(e.getStructDefinitions()).toStrictEqual(t)}),it("Parse primitive types others",()=>{const i={TestStruct:[{name:"test1",type:"address"},{name:"test2",type:"bool"},{name:"test3",type:"string"}]},e=new p(i),t={TestStruct:{test1:new r("address","address",o),test2:new r("bool","bool",o),test3:new r("string","string",o)}};expect(e.getStructDefinitions()).toStrictEqual(t)}),it("Parse arrays",()=>{const i={TestStruct:[{name:"test1",type:"address[]"},{name:"test2",type:"uint16[3]"},{name:"test3",type:"custom[2][][3]"},{name:"test4",type:"string[2][][3][]"}]},e=new p(i),t={TestStruct:{test1:new d("address[]",new r("address","address",o),"address",o,[o]),test2:new d("uint16[3]",new r("uint16","uint",s(2)),"uint16",s(3),[s(3)]),test3:new d("custom[2][][3]",new m("custom"),"custom[2][]",s(3),[s(2),o,s(3)]),test4:new d("string[2][][3][]",new r("string","string",o),"string[2][][3]",o,[s(2),o,s(3),o])}};expect(e.getStructDefinitions()).toStrictEqual(t)}),it("Parse custom struct",()=>{const i={TestStruct:[{name:"test",type:"MyCustomStructure"}]},e=new p(i),t={TestStruct:{test:new m("MyCustomStructure")}};expect(e.getStructDefinitions()).toStrictEqual(t)})});describe("TypedDataParser - message parsing",()=>{const i={domain:{chainId:0,name:"Ether Mail",verifyingContract:"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC",version:"1"},message:{contents:"Hello, Bob!",from:{name:"Cow",wallets:["0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826","0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"]},to:[{wallets:["0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB","0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57","0xB0B0b0b0b0b0B000000000000000000000000000"],name:"Bob"}]},primaryType:"Mail",types:{EIP712Domain:[{name:"name",type:"string"},{name:"version",type:"string"},{name:"chainId",type:"uint256"},{name:"verifyingContract",type:"address"}],Mail:[{name:"from",type:"Person"},{name:"to",type:"Person[1]"},{name:"contents",type:"string"}],Person:[{name:"name",type:"string"},{name:"wallets",type:"address[]"}]}};it("Parse an EIP712 message",()=>{const e=i.types,t=i.primaryType,n=i.message,a=new p(e).parse(t,n),l=[{path:"",type:"",value:new f(t)},{path:"from.name",type:"string",value:new y(new TextEncoder().encode("Cow"))},{path:"from.wallets",type:"address[]",value:new b(2)},{path:"from.wallets.[]",type:"address",value:new y(u("0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"))},{path:"from.wallets.[]",type:"address",value:new y(u("0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"))},{path:"to",type:"Person[1]",value:new b(1)},{path:"to.[].name",type:"string",value:new y(new TextEncoder().encode("Bob"))},{path:"to.[].wallets",type:"address[]",value:new b(3)},{path:"to.[].wallets.[]",type:"address",value:new y(u("0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB"))},{path:"to.[].wallets.[]",type:"address",value:new y(u("0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57"))},{path:"to.[].wallets.[]",type:"address",value:new y(u("0xB0B0b0b0b0b0B000000000000000000000000000"))},{path:"contents",type:"string",value:new y(new TextEncoder().encode("Hello, Bob!"))}];expect(a).toStrictEqual(w(l))}),it("Parse an EIP712 domain",()=>{const e=i.types,t="EIP712Domain",n=i.domain,c=new p(e),a=[{path:"",type:"",value:new f(t)},{path:"name",type:"string",value:new y(new TextEncoder().encode("Ether Mail"))},{path:"version",type:"string",value:new y(new TextEncoder().encode("1"))},{path:"chainId",type:"uint256",value:new y(Uint8Array.from([0]))},{path:"verifyingContract",type:"address",value:new y(u("0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"))}],l=c.parse(t,n);expect(l).toStrictEqual(w(a))}),it("Invalid primary type",()=>{const e=i.types,t="unknown",n=i.domain,a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Struct points to an unknown custom type",()=>{const e={Mail:[{name:"from",type:"Person"}]},t="Mail",n={from:"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Array contains an unknown custom type",()=>{const e={Mail:[{name:"from",type:"Person[]"}]},t="Mail",n={from:["0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"]},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Invalid primitive value",()=>{const e={Mail:[{name:"from",type:"uint8"}]},t="Mail",n={from:3e3},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Array instead of primitive value",()=>{const e={Mail:[{name:"from",type:"uint8"}]},t="Mail",n={from:[42]},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Struct instead of primitive value",()=>{const e={Mail:[{name:"from",type:"uint8"}]},t="Mail",n={from:{data:42}},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Struct value not a record",()=>{const e={Mail:[{name:"from",type:"Person"}],Person:[{name:"data",type:"uint8"}]},t="Mail",n={from:42},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Struct field not present in value",()=>{const e={Mail:[{name:"from",type:"uint8"}]},t="Mail",n={to:42},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Array value not an array",()=>{const e={Mail:[{name:"from",type:"uint8[]"}]},t="Mail",n={from:42},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)}),it("Array value with invalid size",()=>{const e={Mail:[{name:"from",type:"uint8[3]"}]},t="Mail",n={from:[42]},a=new p(e).parse(t,n);expect(a.isLeft()).toStrictEqual(!0)})});
+//# sourceMappingURL=TypedDataParser.test.js.map

package/lib/esm/internal/typed-data/service/TypedDataParser.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/service/TypedDataParser.test.ts"],
+  "sourcesContent": ["import { hexaStringToBuffer } from \"@ledgerhq/device-management-kit\";\nimport { Just, Nothing, Right } from \"purify-ts\";\n\nimport { type TypedData } from \"@api/model/TypedData\";\nimport {\n  ArrayType,\n  PrimitiveType,\n  StructType,\n  TypedDataValueArray,\n  TypedDataValueField,\n  TypedDataValueRoot,\n} from \"@internal/typed-data/model/Types\";\n\nimport { TypedDataParser } from \"./TypedDataParser\";\n\ndescribe(\"TypedDataParser - types parsing\", () => {\n  it(\"Parse primitive types bytes\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [\n        { name: \"test1\", type: \"bytes\" },\n        { name: \"test2\", type: \"bytes1\" },\n        { name: \"test3\", type: \"bytes2\" },\n        { name: \"test4\", type: \"bytes31\" },\n        { name: \"test5\", type: \"bytes32\" },\n      ],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        test1: new PrimitiveType(\"bytes\", \"bytes\", Nothing),\n        test2: new PrimitiveType(\"bytes1\", \"bytes\", Just(1)),\n        test3: new PrimitiveType(\"bytes2\", \"bytes\", Just(2)),\n        test4: new PrimitiveType(\"bytes31\", \"bytes\", Just(31)),\n        test5: new PrimitiveType(\"bytes32\", \"bytes\", Just(32)),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n\n  it(\"Parse primitive types bytes, out of bound\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [\n        { name: \"invalid1\", type: \"bytes0\" },\n        { name: \"invalid2\", type: \"bytes33\" },\n      ],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        invalid1: new StructType(\"bytes0\"),\n        invalid2: new StructType(\"bytes33\"),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n\n  it(\"Parse primitive types number\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [\n        { name: \"test1\", type: \"int8\" },\n        { name: \"test2\", type: \"uint8\" },\n        { name: \"test3\", type: \"int16\" },\n        { name: \"test4\", type: \"uint32\" },\n        { name: \"test5\", type: \"uint64\" },\n        { name: \"test6\", type: \"int128\" },\n        { name: \"test7\", type: \"int136\" },\n        { name: \"test8\", type: \"int144\" },\n        { name: \"test9\", type: \"uint240\" },\n        { name: \"test10\", type: \"uint248\" },\n        { name: \"test11\", type: \"uint256\" },\n        { name: \"test12\", type: \"int256\" },\n      ],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        test1: new PrimitiveType(\"int8\", \"int\", Just(1)),\n        test2: new PrimitiveType(\"uint8\", \"uint\", Just(1)),\n        test3: new PrimitiveType(\"int16\", \"int\", Just(2)),\n        test4: new PrimitiveType(\"uint32\", \"uint\", Just(4)),\n        test5: new PrimitiveType(\"uint64\", \"uint\", Just(8)),\n        test6: new PrimitiveType(\"int128\", \"int\", Just(16)),\n        test7: new PrimitiveType(\"int136\", \"int\", Just(17)),\n        test8: new PrimitiveType(\"int144\", \"int\", Just(18)),\n        test9: new PrimitiveType(\"uint240\", \"uint\", Just(30)),\n        test10: new PrimitiveType(\"uint248\", \"uint\", Just(31)),\n        test11: new PrimitiveType(\"uint256\", \"uint\", Just(32)),\n        test12: new PrimitiveType(\"int256\", \"int\", Just(32)),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n\n  it(\"Parse primitive types number, out of bound\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [\n        { name: \"invalid1\", type: \"int0\" },\n        { name: \"invalid2\", type: \"uint0\" },\n        { name: \"invalid3\", type: \"int7\" },\n        { name: \"invalid4\", type: \"int257\" },\n        { name: \"invalid5\", type: \"uint257\" },\n        { name: \"invalid6\", type: \"int512\" },\n      ],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        invalid1: new StructType(\"int0\"),\n        invalid2: new StructType(\"uint0\"),\n        invalid3: new StructType(\"int7\"),\n        invalid4: new StructType(\"int257\"),\n        invalid5: new StructType(\"uint257\"),\n        invalid6: new StructType(\"int512\"),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n\n  it(\"Parse primitive types others\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [\n        { name: \"test1\", type: \"address\" },\n        { name: \"test2\", type: \"bool\" },\n        { name: \"test3\", type: \"string\" },\n      ],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        test1: new PrimitiveType(\"address\", \"address\", Nothing),\n        test2: new PrimitiveType(\"bool\", \"bool\", Nothing),\n        test3: new PrimitiveType(\"string\", \"string\", Nothing),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n\n  it(\"Parse arrays\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [\n        { name: \"test1\", type: \"address[]\" },\n        { name: \"test2\", type: \"uint16[3]\" },\n        { name: \"test3\", type: \"custom[2][][3]\" },\n        { name: \"test4\", type: \"string[2][][3][]\" },\n      ],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        test1: new ArrayType(\n          \"address[]\",\n          new PrimitiveType(\"address\", \"address\", Nothing),\n          \"address\",\n          Nothing,\n          [Nothing],\n        ),\n        test2: new ArrayType(\n          \"uint16[3]\",\n          new PrimitiveType(\"uint16\", \"uint\", Just(2)),\n          \"uint16\",\n          Just(3),\n          [Just(3)],\n        ),\n        test3: new ArrayType(\n          \"custom[2][][3]\",\n          new StructType(\"custom\"),\n          \"custom[2][]\",\n          Just(3),\n          [Just(2), Nothing, Just(3)],\n        ),\n        test4: new ArrayType(\n          \"string[2][][3][]\",\n          new PrimitiveType(\"string\", \"string\", Nothing),\n          \"string[2][][3]\",\n          Nothing,\n          [Just(2), Nothing, Just(3), Nothing],\n        ),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n\n  it(\"Parse custom struct\", () => {\n    // GIVEN\n    const types = {\n      TestStruct: [{ name: \"test\", type: \"MyCustomStructure\" }],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = {\n      TestStruct: {\n        test: new StructType(\"MyCustomStructure\"),\n      },\n    };\n    expect(parser.getStructDefinitions()).toStrictEqual(expected);\n  });\n});\n\ndescribe(\"TypedDataParser - message parsing\", () => {\n  const MESSAGE: TypedData = {\n    domain: {\n      chainId: 0,\n      name: \"Ether Mail\",\n      verifyingContract: \"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC\",\n      version: \"1\",\n    },\n    message: {\n      contents: \"Hello, Bob!\",\n      from: {\n        name: \"Cow\",\n        wallets: [\n          \"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826\",\n          \"0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF\",\n        ],\n      },\n      to: [\n        {\n          wallets: [\n            \"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB\",\n            \"0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57\",\n            \"0xB0B0b0b0b0b0B000000000000000000000000000\",\n          ],\n          name: \"Bob\",\n        },\n      ],\n    },\n    primaryType: \"Mail\",\n    types: {\n      EIP712Domain: [\n        { name: \"name\", type: \"string\" },\n        { name: \"version\", type: \"string\" },\n        { name: \"chainId\", type: \"uint256\" },\n        { name: \"verifyingContract\", type: \"address\" },\n      ],\n      Mail: [\n        { name: \"from\", type: \"Person\" },\n        { name: \"to\", type: \"Person[1]\" },\n        { name: \"contents\", type: \"string\" },\n      ],\n      Person: [\n        { name: \"name\", type: \"string\" },\n        { name: \"wallets\", type: \"address[]\" },\n      ],\n    },\n  };\n\n  it(\"Parse an EIP712 message\", () => {\n    // GIVEN\n    const types = MESSAGE.types;\n    const primaryType = MESSAGE.primaryType;\n    const message = MESSAGE.message;\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    const expected = [\n      {\n        path: \"\",\n        type: \"\",\n        value: new TypedDataValueRoot(primaryType),\n      },\n      {\n        path: \"from.name\",\n        type: \"string\",\n        value: new TypedDataValueField(new TextEncoder().encode(\"Cow\")),\n      },\n      {\n        path: \"from.wallets\",\n        type: \"address[]\",\n        value: new TypedDataValueArray(2),\n      },\n      {\n        path: \"from.wallets.[]\",\n        type: \"address\",\n        value: new TypedDataValueField(\n          hexaStringToBuffer(\"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826\")!,\n        ),\n      },\n      {\n        path: \"from.wallets.[]\",\n        type: \"address\",\n        value: new TypedDataValueField(\n          hexaStringToBuffer(\"0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF\")!,\n        ),\n      },\n      { path: \"to\", type: \"Person[1]\", value: new TypedDataValueArray(1) },\n      {\n        path: \"to.[].name\",\n        type: \"string\",\n        value: new TypedDataValueField(new TextEncoder().encode(\"Bob\")),\n      },\n      {\n        path: \"to.[].wallets\",\n        type: \"address[]\",\n        value: new TypedDataValueArray(3),\n      },\n      {\n        path: \"to.[].wallets.[]\",\n        type: \"address\",\n        value: new TypedDataValueField(\n          hexaStringToBuffer(\"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB\")!,\n        ),\n      },\n      {\n        path: \"to.[].wallets.[]\",\n        type: \"address\",\n        value: new TypedDataValueField(\n          hexaStringToBuffer(\"0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57\")!,\n        ),\n      },\n      {\n        path: \"to.[].wallets.[]\",\n        type: \"address\",\n        value: new TypedDataValueField(\n          hexaStringToBuffer(\"0xB0B0b0b0b0b0B000000000000000000000000000\")!,\n        ),\n      },\n      {\n        path: \"contents\",\n        type: \"string\",\n        value: new TypedDataValueField(new TextEncoder().encode(\"Hello, Bob!\")),\n      },\n    ];\n    expect(parsed).toStrictEqual(Right(expected));\n  });\n\n  it(\"Parse an EIP712 domain\", () => {\n    // GIVEN\n    const types = MESSAGE.types;\n    const primaryType = \"EIP712Domain\";\n    const message = MESSAGE.domain;\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const expected = [\n      {\n        path: \"\",\n        type: \"\",\n        value: new TypedDataValueRoot(primaryType),\n      },\n      {\n        path: \"name\",\n        type: \"string\",\n        value: new TypedDataValueField(new TextEncoder().encode(\"Ether Mail\")),\n      },\n      {\n        path: \"version\",\n        type: \"string\",\n        value: new TypedDataValueField(new TextEncoder().encode(\"1\")),\n      },\n      {\n        path: \"chainId\",\n        type: \"uint256\",\n        value: new TypedDataValueField(Uint8Array.from([0])),\n      },\n      {\n        path: \"verifyingContract\",\n        type: \"address\",\n        value: new TypedDataValueField(\n          hexaStringToBuffer(\"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC\")!,\n        ),\n      },\n    ];\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed).toStrictEqual(Right(expected));\n  });\n\n  it(\"Invalid primary type\", () => {\n    // GIVEN\n    const types = MESSAGE.types;\n    const primaryType = \"unknown\";\n    const message = MESSAGE.domain;\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Struct points to an unknown custom type\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"Person\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: \"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826\",\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Array contains an unknown custom type\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"Person[]\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: [\"0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826\"],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Invalid primitive value\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"uint8\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: 3000,\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Array instead of primitive value\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"uint8\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: [42],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Struct instead of primitive value\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"uint8\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: { data: 42 },\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Struct value not a record\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"Person\" }],\n      Person: [{ name: \"data\", type: \"uint8\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: 42,\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Struct field not present in value\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"uint8\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      to: 42,\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Array value not an array\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"uint8[]\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: 42,\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n\n  it(\"Array value with invalid size\", () => {\n    // GIVEN\n    const types = {\n      Mail: [{ name: \"from\", type: \"uint8[3]\" }],\n    };\n    const primaryType = \"Mail\";\n    const message = {\n      from: [42],\n    };\n    // WHEN\n    const parser = new TypedDataParser(types);\n    // THEN\n    const parsed = parser.parse(primaryType, message);\n    expect(parsed.isLeft()).toStrictEqual(true);\n  });\n});\n"],
+  "mappings": "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",
+  "names": ["hexaStringToBuffer", "Just", "Nothing", "Right", "ArrayType", "PrimitiveType", "StructType", "TypedDataValueArray", "TypedDataValueField", "TypedDataValueRoot", "TypedDataParser", "types", "parser", "expected", "MESSAGE", "primaryType", "message", "parsed"]
+}

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

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

package/lib/esm/internal/typed-data/service/TypedDataParserService.js.map

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