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

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

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

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

@@ -1 +1,7 @@
-{"version":3,"file":"typedDataTypes.js","sourceRoot":"","sources":["../../../../../src/internal/typed-data/di/typedDataTypes.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG;IAC5B,oBAAoB,EAAE,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC;IACxD,sBAAsB,EAAE,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC;CAC7D,CAAC"}
+{
+  "version": 3,
+  "sources": ["../../../../../src/internal/typed-data/di/typedDataTypes.ts"],
+  "sourcesContent": ["export const typedDataTypes = {\n  SignTypedDataUseCase: Symbol.for(\"SignTypedDataUseCase\"),\n  TypedDataParserService: Symbol.for(\"TypedDataParserService\"),\n};\n"],
+  "mappings": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,oBAAAE,IAAA,eAAAC,EAAAH,GAAO,MAAME,EAAiB,CAC5B,qBAAsB,OAAO,IAAI,sBAAsB,EACvD,uBAAwB,OAAO,IAAI,wBAAwB,CAC7D",
+  "names": ["typedDataTypes_exports", "__export", "typedDataTypes", "__toCommonJS"]
+}

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

@@ -1,64 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedDataValueField = exports.TypedDataValueArray = exports.TypedDataValueRoot = exports.StructType = exports.ArrayType = exports.PrimitiveType = void 0;
-// Basic type (address, bool, uint256, etc)
-class PrimitiveType {
-    typeName;
-    name;
-    size;
-    constructor(typeName, name, size) {
-        this.typeName = typeName;
-        this.name = name;
-        this.size = size;
-    }
-}
-exports.PrimitiveType = PrimitiveType;
-// Arrays
-class ArrayType {
-    typeName;
-    rootType;
-    rowType;
-    count;
-    levels;
-    constructor(typeName, rootType, rowType, count, levels) {
-        this.typeName = typeName;
-        this.rootType = rootType;
-        this.rowType = rowType;
-        this.count = count;
-        this.levels = levels;
-    }
-}
-exports.ArrayType = ArrayType;
-// Custom structure
-class StructType {
-    typeName;
-    constructor(typeName) {
-        this.typeName = typeName;
-    }
-}
-exports.StructType = StructType;
-// The value is a message root. This is usually the primaryType name.
-class TypedDataValueRoot {
-    root;
-    constructor(root) {
-        this.root = root;
-    }
-}
-exports.TypedDataValueRoot = TypedDataValueRoot;
-// The value is an array. Represents the array length.
-class TypedDataValueArray {
-    length;
-    constructor(length) {
-        this.length = length;
-    }
-}
-exports.TypedDataValueArray = TypedDataValueArray;
-// The value is a field of any type. Contains the encoded value as a byte array.
-class TypedDataValueField {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-}
-exports.TypedDataValueField = TypedDataValueField;
-//# sourceMappingURL=Types.js.map
+"use strict";var i=Object.defineProperty;var y=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var u=(t,e)=>{for(var r in e)i(t,r,{get:e[r],enumerable:!0})},l=(t,e,r,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let p of o(e))!c.call(t,p)&&p!==r&&i(t,p,{get:()=>e[p],enumerable:!(a=y(e,p))||a.enumerable});return t};var s=t=>l(i({},"__esModule",{value:!0}),t);var x={};u(x,{ArrayType:()=>b,PrimitiveType:()=>n,StructType:()=>T,TypedDataValueArray:()=>d,TypedDataValueField:()=>g,TypedDataValueRoot:()=>m});module.exports=s(x);class n{constructor(e,r,a){this.typeName=e;this.name=r;this.size=a}}class b{constructor(e,r,a,p,v){this.typeName=e;this.rootType=r;this.rowType=a;this.count=p;this.levels=v}}class T{constructor(e){this.typeName=e}}class m{constructor(e){this.root=e}}class d{constructor(e){this.length=e}}class g{constructor(e){this.data=e}}0&&(module.exports={ArrayType,PrimitiveType,StructType,TypedDataValueArray,TypedDataValueField,TypedDataValueRoot});
+//# sourceMappingURL=Types.js.map

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

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

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

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

package/lib/cjs/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,yCAAuC;AAKvC,uDAAoD;AAO7C,IAAM,6BAA6B,GAAnC,MAAM,6BAA6B;IACxC,KAAK,CAAC,IAAe;QACnB,MAAM,MAAM,GAAG,IAAI,iCAAe,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,sEAA6B;wCAA7B,6BAA6B;IADzC,IAAA,sBAAU,GAAE;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": "2iBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mCAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAA2B,qBAK3BC,EAAgC,6BAOzB,IAAMC,EAAN,KAAsE,CAC3E,MAAMC,EAAiD,CACrD,MAAMC,EAAS,IAAI,kBAAgBD,EAAK,KAAK,EACvCE,EAAQD,EAAO,qBAAqB,EACpCE,EAAeF,EAAO,MAC1B,eACAD,EAAK,MACP,EACMI,EAAgBH,EAAO,MAAMD,EAAK,YAAaA,EAAK,OAAO,EACjE,OAAOG,EAAa,MAAOE,GACzBD,EAAc,IAAKE,IAAa,CAC9B,MAAAJ,EACA,OAAAG,EACA,QAAAC,CACF,EAAE,CACJ,CACF,CACF,EAjBaP,EAANQ,EAAA,IADN,cAAW,GACCR",
+  "names": ["DefaultTypedDataParserService_exports", "__export", "DefaultTypedDataParserService", "__toCommonJS", "import_inversify", "import_TypedDataParser", "DefaultTypedDataParserService", "data", "parser", "types", "domainResult", "messageResult", "domain", "message", "__decorateClass"]
+}

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

@@ -1,101 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeTypedDataValue = encodeTypedDataValue;
-const device_management_kit_1 = require("@ledgerhq/device-management-kit");
-const purify_ts_1 = require("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.
- */
-function encodeTypedDataValue(type, value) {
-    switch (type.name) {
-        case "string":
-            // Encode the value as a UTF-8 string
-            return typeof value !== "string"
-                ? purify_ts_1.Nothing
-                : (0, purify_ts_1.Just)(new TextEncoder().encode(value));
-        case "bytes":
-        case "address":
-            // Encode the hexadecimal string as bytes
-            return typeof value !== "string"
-                ? purify_ts_1.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"
-                ? purify_ts_1.Nothing
-                : encodeTypedDataNumber(type.name, type.size.mapOrDefault((s) => s * 8, 1), // Size in bits
-                value);
-    }
-}
-function encodeTypedDataBytes(type, value) {
-    const maxSize = type.name === "address" ? (0, purify_ts_1.Just)(20) : type.size;
-    const buffer = purify_ts_1.Maybe.fromNullable((0, device_management_kit_1.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 purify_ts_1.Nothing;
-            }
-            bigintValue = BigInt(value);
-            break;
-        case "string":
-            if (value.length === 0) {
-                return purify_ts_1.Nothing;
-            }
-            try {
-                bigintValue = BigInt(value);
-            }
-            catch (_error) {
-                return purify_ts_1.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) => purify_ts_1.Maybe.fromNullable((0, device_management_kit_1.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 ? (0, purify_ts_1.Just)(value) : purify_ts_1.Nothing;
-    }
-    // Check if the value is within the bounds of a signed integer
-    const limit = 1n << (sizeInBits - 1n);
-    if (value >= limit || value < -limit) {
-        return purify_ts_1.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 (0, purify_ts_1.Just)(value);
-}
-//# sourceMappingURL=TypedDataEncoder.js.map
+"use strict";var s=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var a=(n,t)=>{for(var r in t)s(n,r,{get:t[r],enumerable:!0})},y=(n,t,r,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of c(t))!g.call(n,o)&&o!==r&&s(n,o,{get:()=>t[o],enumerable:!(i=m(t,o))||i.enumerable});return n};var p=n=>y(s({},"__esModule",{value:!0}),n);var N={};a(N,{encodeTypedDataValue:()=>d});module.exports=p(N);var f=require("@ledgerhq/device-management-kit"),e=require("purify-ts");function d(n,t){switch(n.name){case"string":return typeof t!="string"?e.Nothing:(0,e.Just)(new TextEncoder().encode(t));case"bytes":case"address":return typeof t!="string"?e.Nothing:u(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"?e.Nothing:T(n.name,n.size.mapOrDefault(r=>r*8,1),t)}}function u(n,t){const r=n.name==="address"?(0,e.Just)(20):n.size;return e.Maybe.fromNullable((0,f.hexaStringToBuffer)(t)).filter(o=>r.mapOrDefault(b=>o.length<=b,!0))}function T(n,t,r){let i;switch(typeof r){case"bigint":i=r;break;case"number":if(!Number.isInteger(r))return e.Nothing;i=BigInt(r);break;case"string":if(r.length===0)return e.Nothing;try{i=BigInt(r)}catch{return e.Nothing}break}const o=n==="int";return h(i,BigInt(t),o).chain(b=>e.Maybe.fromNullable((0,f.hexaStringToBuffer)(b.toString(16))))}function h(n,t,r){if(!r)return n>=0n&&n<1n<<t?(0,e.Just)(n):e.Nothing;const i=1n<<t-1n;if(n>=i||n<-i)return e.Nothing;if(n<0n){const o=(1n<<t)-1n;n=-n,n=(~n&o)+1n}return(0,e.Just)(n)}0&&(module.exports={encodeTypedDataValue});
+//# sourceMappingURL=TypedDataEncoder.js.map

package/lib/cjs/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": "yaAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,IAAA,eAAAC,EAAAH,GAAA,IAAAI,EAAmC,2CACnCC,EAAqC,qBAa9B,SAASH,EACdI,EACAC,EACmB,CACnB,OAAQD,EAAK,KAAM,CACjB,IAAK,SAEH,OAAO,OAAOC,GAAU,SACpB,aACA,QAAK,IAAI,YAAY,EAAE,OAAOA,CAAK,CAAC,EAC1C,IAAK,QACL,IAAK,UAEH,OAAO,OAAOA,GAAU,SACpB,UACAC,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,SACf,UACAE,EACEH,EAAK,KACLA,EAAK,KAAK,aAAcI,GAAMA,EAAI,EAAG,CAAC,EACtCH,CACF,CACR,CACF,CAEA,SAASC,EACPF,EACAC,EACmB,CACnB,MAAMI,EAAUL,EAAK,OAAS,aAAY,QAAK,EAAE,EAAIA,EAAK,KAE1D,OADe,QAAM,gBAAa,sBAAmBC,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,OAAO,UAETO,EAAc,OAAOP,CAAK,EAC1B,MACF,IAAK,SACH,GAAIA,EAAM,SAAW,EACnB,OAAO,UAET,GAAI,CACFO,EAAc,OAAOP,CAAK,CAC5B,MAA0B,CACxB,OAAO,SACT,CACA,KACJ,CAEA,MAAMQ,EAAST,IAAS,MACxB,OAAOU,EAAsBF,EAAa,OAAOD,CAAU,EAAGE,CAAM,EAAE,MACnEE,GACC,QAAM,gBAAa,sBAAmBA,EAAU,SAAS,EAAE,CAAC,CAAC,CACjE,CACF,CASA,SAASD,EACPT,EACAM,EACAE,EACe,CACf,GAAI,CAACA,EAEH,OAAOR,GAAS,IAAMA,EAAQ,IAAMM,KAAa,QAAKN,CAAK,EAAI,UAIjE,MAAMW,EAAQ,IAAOL,EAAa,GAClC,GAAIN,GAASW,GAASX,EAAQ,CAACW,EAC7B,OAAO,UAKT,GAAIX,EAAQ,GAAI,CACd,MAAMY,GAAQ,IAAMN,GAAc,GAClCN,EAAQ,CAACA,EACTA,GAAS,CAACA,EAAQY,GAAQ,EAC5B,CAEA,SAAO,QAAKZ,CAAK,CACnB",
+  "names": ["TypedDataEncoder_exports", "__export", "encodeTypedDataValue", "__toCommonJS", "import_device_management_kit", "import_purify_ts", "type", "value", "encodeTypedDataBytes", "encodeTypedDataNumber", "s", "maxSize", "b", "sizeInBits", "bigintValue", "signed", "checkBoundsAndConvert", "converted", "limit", "mask"]
+}

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

@@ -0,0 +1,2 @@
+"use strict";var x=require("purify-ts"),c=require("../../typed-data/model/Types"),a=require("./TypedDataEncoder");describe("TypedDataEncoder",()=>{const r=new c.PrimitiveType("address","address",x.Nothing),l=new c.PrimitiveType("bytes","bytes",x.Nothing),F=new c.PrimitiveType("bytes","bytes",(0,x.Just)(7)),p=new c.PrimitiveType("string","string",x.Nothing),C=new c.PrimitiveType("bool","bool",x.Nothing),o=new c.PrimitiveType("int8","int",(0,x.Just)(1)),i=new c.PrimitiveType("int16","int",(0,x.Just)(2)),s=new c.PrimitiveType("int32","int",(0,x.Just)(4)),y=new c.PrimitiveType("int64","int",(0,x.Just)(8)),u=new c.PrimitiveType("int128","int",(0,x.Just)(16)),b=new c.PrimitiveType("int256","int",(0,x.Just)(32)),d=new c.PrimitiveType("uint8","uint",(0,x.Just)(1)),E=new c.PrimitiveType("uint16","uint",(0,x.Just)(2)),m=new c.PrimitiveType("uint32","uint",(0,x.Just)(4)),v=new c.PrimitiveType("uint64","uint",(0,x.Just)(8)),A=new c.PrimitiveType("uint128","uint",(0,x.Just)(16)),U=new c.PrimitiveType("uint256","uint",(0,x.Just)(32));it("Encode an address",()=>{const e=["0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC","0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826","0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF","0xB0BdaBea57B0BDABeA57b0bdABEA57b0BDabEa57","0xBdaBea57B0BDABeA57b0bdABEA57b0BDabEa57"].map(f=>(0,a.encodeTypedDataValue)(r,f)),t=[(0,x.Just)(Uint8Array.from([204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204])),(0,x.Just)(Uint8Array.from([205,42,61,159,147,142,19,205,148,126,192,90,188,127,231,52,223,141,216,38])),(0,x.Just)(Uint8Array.from([222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239])),(0,x.Just)(Uint8Array.from([176,189,171,234,87,176,189,171,234,87,176,189,171,234,87,176,189,171,234,87])),(0,x.Just)(Uint8Array.from([189,171,234,87,176,189,171,234,87,176,189,171,234,87,176,189,171,234,87]))];expect(e).toStrictEqual(t)}),it("Encode an address with invalid size",()=>{const e=(0,a.encodeTypedDataValue)(r,"0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccCff");expect(e).toStrictEqual(x.Nothing)}),it("Encode an address with invalid value",()=>{const e=(0,a.encodeTypedDataValue)(r,"0xbonjourcCCCCcCCCCCCcCcCccCcCCCcCcccccccC");expect(e).toStrictEqual(x.Nothing)}),it("Encode an address with invalid value type",()=>{const e=(0,a.encodeTypedDataValue)(r,17);expect(e).toStrictEqual(x.Nothing)}),it("Encode an byte array",()=>{const e=["0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcc","0x13CD947Ec05AbC7FE734Df8DD826","0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeFbeeF","0xBDabEa57"].map(f=>(0,a.encodeTypedDataValue)(l,f)),t=[(0,x.Just)(Uint8Array.from([204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204])),(0,x.Just)(Uint8Array.from([19,205,148,126,192,90,188,127,231,52,223,141,216,38])),(0,x.Just)(Uint8Array.from([222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239,222,173,190,239,190,239])),(0,x.Just)(Uint8Array.from([189,171,234,87]))];expect(e).toStrictEqual(t)}),it("Encode an byte array with size",()=>{const e=["0x13CD947Ec05AbC","0x13CD947Ec05A","0x13CD947Ec05AbCde"].map(f=>(0,a.encodeTypedDataValue)(F,f)),t=[(0,x.Just)(Uint8Array.from([19,205,148,126,192,90,188])),(0,x.Just)(Uint8Array.from([19,205,148,126,192,90])),x.Nothing];expect(e).toStrictEqual(t)}),it("Encode a string",()=>{const e=["Hello, Bob!",'"did:ethr:0xf7398bacf610bb4e3b567811279fcb3c41919f89"','"2021-03-04T21:08:22.615Z"^^<http://www.w3.org/2001/XMLSchema#dateTime>',"_<did:key:z6MkgFneaaMjN6zybqLNXgt4YfmVx2XZhzPdDyk4ZK81daHZ>"].map(f=>(0,a.encodeTypedDataValue)(p,f)),t=[(0,x.Just)(Uint8Array.from([72,101,108,108,111,44,32,66,111,98,33])),(0,x.Just)(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])),(0,x.Just)(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])),(0,x.Just)(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(e).toStrictEqual(t)}),it("Encode a string with invalid value type",()=>{const e=(0,a.encodeTypedDataValue)(p,17);expect(e).toStrictEqual(x.Nothing)}),it("Encode a signed number",()=>{const e=[{type:o,value:127},{type:o,value:-128},{type:i,value:"32767"},{type:i,value:"-32768"},{type:s,value:"0x7FFFFFFF"},{type:s,value:"-2147483648"},{type:y,value:9223372036854775807n},{type:y,value:-9223372036854775808n},{type:u,value:"170141183460469231731687303715884105727"},{type:u,value:"-170141183460469231731687303715884105728"},{type:b,value:57896044618658097711785492504343953926634992332820282019728792003956564819967n},{type:b,value:-57896044618658097711785492504343953926634992332820282019728792003956564819968n}].map(f=>(0,a.encodeTypedDataValue)(f.type,f.value)),t=[(0,x.Just)(Uint8Array.from([127])),(0,x.Just)(Uint8Array.from([128])),(0,x.Just)(Uint8Array.from([127,255])),(0,x.Just)(Uint8Array.from([128,0])),(0,x.Just)(Uint8Array.from([127,255,255,255])),(0,x.Just)(Uint8Array.from([128,0,0,0])),(0,x.Just)(Uint8Array.from([127,255,255,255,255,255,255,255])),(0,x.Just)(Uint8Array.from([128,0,0,0,0,0,0,0])),(0,x.Just)(Uint8Array.from([127,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255])),(0,x.Just)(Uint8Array.from([128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0])),(0,x.Just)(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])),(0,x.Just)(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(e).toStrictEqual(t)}),it("Encode a signed number, out of bounds",()=>{const e=[{type:o,value:""},{type:o,value:128},{type:o,value:-129},{type:i,value:"32768"},{type:i,value:"-32769"},{type:s,value:"0xFFFFFFFF"},{type:s,value:"-2147483649"},{type:y,value:9223372036854775808n},{type:y,value:-9223372036854775809n},{type:u,value:"170141183460469231731687303715884105728"},{type:u,value:"-170141183460469231731687303715884105729"},{type:b,value:57896044618658097711785492504343953926634992332820282019728792003956564819968n},{type:b,value:-57896044618658097711785492504343953926634992332820282019728792003956564819969n}].map(f=>(0,a.encodeTypedDataValue)(f.type,f.value)),t=[x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing];expect(e).toStrictEqual(t)}),it("Encode an unsigned number",()=>{const e=[{type:d,value:0},{type:d,value:255},{type:E,value:"65535"},{type:m,value:"0xFFFFFFFF"},{type:v,value:18446744073709551615n},{type:A,value:"340282366920938463463374607431768211455"},{type:U,value:115792089237316195423570985008687907853269984665640564039457584007913129639935n}].map(f=>(0,a.encodeTypedDataValue)(f.type,f.value)),t=[(0,x.Just)(Uint8Array.from([0])),(0,x.Just)(Uint8Array.from([255])),(0,x.Just)(Uint8Array.from([255,255])),(0,x.Just)(Uint8Array.from([255,255,255,255])),(0,x.Just)(Uint8Array.from([255,255,255,255,255,255,255,255])),(0,x.Just)(Uint8Array.from([255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255])),(0,x.Just)(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(e).toStrictEqual(t)}),it("Encode an unsigned number, out of bound",()=>{const e=[{type:d,value:""},{type:d,value:.5},{type:d,value:-1},{type:d,value:256},{type:E,value:"65536"},{type:m,value:"0x100000000"},{type:v,value:18446744073709551616n},{type:A,value:"340282366920938463463374607431768211456"},{type:U,value:115792089237316195423570985008687907853269984665640564039457584007913129639936n}].map(f=>(0,a.encodeTypedDataValue)(f.type,f.value)),t=[x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing];expect(e).toStrictEqual(t)}),it("Encode a boolean",()=>{const e=[!1,!0,0,1,"0","0x1"].map(f=>(0,a.encodeTypedDataValue)(C,f)),t=[(0,x.Just)(Uint8Array.from([0])),(0,x.Just)(Uint8Array.from([1])),(0,x.Just)(Uint8Array.from([0])),(0,x.Just)(Uint8Array.from([1])),(0,x.Just)(Uint8Array.from([0])),(0,x.Just)(Uint8Array.from([1]))];expect(e).toStrictEqual(t)}),it("Encode a boolean, out of bounds",()=>{const e=[-1,2].map(f=>(0,a.encodeTypedDataValue)(C,f)),t=[x.Nothing,x.Nothing];expect(e).toStrictEqual(t)}),it("Encode an invalid data type",()=>{const e=[{type:d,value:!0},{type:o,value:{}},{type:C,value:void 0},{type:p,value:42},{type:l,value:42},{type:r,value:!1}].map(f=>(0,a.encodeTypedDataValue)(f.type,f.value)),t=[x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing,x.Nothing];expect(e).toStrictEqual(t)})});
+//# sourceMappingURL=TypedDataEncoder.test.js.map

package/lib/cjs/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": ["import_purify_ts", "import_Types", "import_TypedDataEncoder", "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/cjs/internal/typed-data/service/TypedDataParser.js

@@ -1,211 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypedDataParser = void 0;
-const purify_ts_1 = require("purify-ts");
-const Types_1 = require("../../typed-data/model/Types");
-const TypedDataEncoder_1 = require("./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);
- * ```
- */
-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 (0, purify_ts_1.Left)(new Error("Message is not a record"));
-        }
-        const values = [
-            {
-                path: "",
-                type: "",
-                value: new Types_1.TypedDataValueRoot(primaryType),
-            },
-        ];
-        return this.visitValue(primaryType, message, "", (val) => values.push(val))
-            ? (0, purify_ts_1.Right)(values)
-            : (0, purify_ts_1.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 Types_1.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 purify_ts_1.Nothing; // Unsupported number
-                }
-                return (0, purify_ts_1.Just)(new Types_1.PrimitiveType(match[1], // typeName such as uint64
-                match[3] ? "uint" : "int", // name such as uint
-                (0, purify_ts_1.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 purify_ts_1.Nothing; // Unsupported  byte array
-                }
-                return (0, purify_ts_1.Just)(new Types_1.PrimitiveType(match[1], // typename such as bytes32
-                "bytes", // name
-                purify_ts_1.Maybe.fromNullable(size)));
-            }
-        }
-        // Other primitive types
-        if (type === "address" || type === "bool" || type === "string") {
-            return (0, purify_ts_1.Just)(new Types_1.PrimitiveType(type, // typeName
-            type, // name
-            purify_ts_1.Nothing));
-        }
-        // Not a primitive type
-        return purify_ts_1.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 ? (0, purify_ts_1.Just)(parseInt(size)) : purify_ts_1.Nothing);
-                const rootType = this.tryParsePrimitiveType(match[1]).mapOrDefault((just) => just, new Types_1.StructType(match[1]));
-                return (0, purify_ts_1.Just)(new Types_1.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 purify_ts_1.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) => (0, TypedDataEncoder_1.encodeTypedDataValue)(primitiveType, value).ifJust((encoded) => {
-                callback({
-                    path,
-                    type,
-                    value: new Types_1.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 Types_1.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));
-    }
-}
-exports.TypedDataParser = TypedDataParser;
-//# sourceMappingURL=TypedDataParser.js.map
+"use strict";var l=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var h=(u,t)=>{for(var e in t)l(u,e,{get:t[e],enumerable:!0})},V=(u,t,e,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of m(t))!T.call(u,i)&&i!==e&&l(u,i,{get:()=>t[i],enumerable:!(r=f(t,i))||r.enumerable});return u};var g=u=>V(l({},"__esModule",{value:!0}),u);var D={};h(D,{TypedDataParser:()=>v});module.exports=g(D);var a=require("purify-ts"),s=require("../../typed-data/model/Types"),p=require("./TypedDataEncoder");class v{structs;constructor(t){const e={};for(const[r,i]of Object.entries(t)){const o={};for(const n of i)o[n.name]=this.parseType(n.type);e[r]=o}this.structs=e}getStructDefinitions(){return this.structs}parse(t,e){if(!this.isRecord(e))return(0,a.Left)(new Error("Message is not a record"));const r=[{path:"",type:"",value:new s.TypedDataValueRoot(t)}];return this.visitValue(t,e,"",i=>r.push(i))?(0,a.Right)(r):(0,a.Left)(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 s.StructType(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?a.Nothing:(0,a.Just)(new s.PrimitiveType(e[1],e[3]?"uint":"int",(0,a.Just)(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)?a.Nothing:(0,a.Just)(new s.PrimitiveType(e[1],"bytes",a.Maybe.fromNullable(r)))}}return t==="address"||t==="bool"||t==="string"?(0,a.Just)(new s.PrimitiveType(t,t,a.Nothing)):a.Nothing}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(([,n])=>n?(0,a.Just)(parseInt(n)):a.Nothing),o=this.tryParsePrimitiveType(e[1]).mapOrDefault(n=>n,new s.StructType(e[1]));return(0,a.Just)(new s.ArrayType(t,o,e[1]+e[3],i[i.length-1],i))}}return a.Nothing}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(o=>(0,p.encodeTypedDataValue)(o,e).ifJust(n=>{i({path:r,type:t,value:new s.TypedDataValueField(n)})})).isJust()}tryVisitStructValue(t,e,r,i){const o=this.structs[t];if(o===void 0||!this.isRecord(e))return!1;for(const[n,y]of Object.entries(o)){const d=e[n];if(d===void 0)return!1;const c=r.length?`${r}.${n}`:n;if(!this.visitValue(y.typeName,d,`${c}`,i))return!1}return!0}tryVisitArrayValue(t,e,r,i){return Array.isArray(e)&&this.tryParseArrayType(t).filter(o=>o.count.mapOrDefault(n=>e.length==n,!0)).mapOrDefault(o=>{i({path:r,type:t,value:new s.TypedDataValueArray(e.length)});for(const n of e){const y=r.length?`${r}.[]`:"[]";if(!this.visitValue(o.rowType,n,`${y}`,i))return!1}return!0},!1)}}0&&(module.exports={TypedDataParser});
+//# sourceMappingURL=TypedDataParser.js.map