@qevm/hash 5.7.2 → 5.7.3

package/lib/typed-data.js

@@ -1,50 +1,86 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedDataEncoder = void 0;
-const address_1 = require("@qevm/address");
-const bignumber_1 = require("@qevm/bignumber");
-const bytes_1 = require("@qevm/bytes");
-const keccak256_1 = require("@ethersproject/keccak256");
-const properties_1 = require("@ethersproject/properties");
-const logger_1 = require("@ethersproject/logger");
-const _version_1 = require("./_version");
-const logger = new logger_1.Logger(_version_1.version);
-const id_1 = require("./id");
-const padding = new Uint8Array(32);
+var address_1 = require("@qevm/address");
+var bignumber_1 = require("@qevm/bignumber");
+var bytes_1 = require("@qevm/bytes");
+var keccak256_1 = require("@qevm/keccak256");
+var properties_1 = require("@ethersproject/properties");
+var logger_1 = require("@ethersproject/logger");
+var _version_1 = require("./_version");
+var logger = new logger_1.Logger(_version_1.version);
+var id_1 = require("./id");
+var padding = new Uint8Array(32);
 padding.fill(0);
-const NegativeOne = bignumber_1.BigNumber.from(-1);
-const Zero = bignumber_1.BigNumber.from(0);
-const One = bignumber_1.BigNumber.from(1);
-const MaxUint256 = bignumber_1.BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+var NegativeOne = bignumber_1.BigNumber.from(-1);
+var Zero = bignumber_1.BigNumber.from(0);
+var One = bignumber_1.BigNumber.from(1);
+var MaxUint256 = bignumber_1.BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 function hexPadRight(value) {
-    const bytes = (0, bytes_1.arrayify)(value);
-    const padOffset = bytes.length % 32;
+    var bytes = (0, bytes_1.arrayify)(value);
+    var padOffset = bytes.length % 32;
     if (padOffset) {
         return (0, bytes_1.hexConcat)([bytes, padding.slice(padOffset)]);
     }
     return (0, bytes_1.hexlify)(bytes);
 }
-const hexTrue = (0, bytes_1.hexZeroPad)(One.toHexString(), 32);
-const hexFalse = (0, bytes_1.hexZeroPad)(Zero.toHexString(), 32);
-const domainFieldTypes = {
+var hexTrue = (0, bytes_1.hexZeroPad)(One.toHexString(), 32);
+var hexFalse = (0, bytes_1.hexZeroPad)(Zero.toHexString(), 32);
+var domainFieldTypes = {
     name: "string",
     version: "string",
     chainId: "uint256",
     verifyingContract: "address",
     salt: "bytes32"
 };
-const domainFieldNames = [
+var domainFieldNames = [
     "name", "version", "chainId", "verifyingContract", "salt"
 ];
 function checkString(key) {
     return function (value) {
         if (typeof (value) !== "string") {
-            logger.throwArgumentError(`invalid domain value for ${JSON.stringify(key)}`, `domain.${key}`, value);
+            logger.throwArgumentError("invalid domain value for ".concat(JSON.stringify(key)), "domain.".concat(key), value);
         }
         return value;
     };
 }
-const domainChecks = {
+var domainChecks = {
     name: checkString("name"),
     version: checkString("version"),
     chainId: function (value) {
@@ -52,43 +88,43 @@ const domainChecks = {
             return bignumber_1.BigNumber.from(value).toString();
         }
         catch (error) { }
-        return logger.throwArgumentError(`invalid domain value for "chainId"`, "domain.chainId", value);
+        return logger.throwArgumentError("invalid domain value for \"chainId\"", "domain.chainId", value);
     },
     verifyingContract: function (value) {
         try {
             return (0, address_1.getAddress)(value).toLowerCase();
         }
         catch (error) { }
-        return logger.throwArgumentError(`invalid domain value "verifyingContract"`, "domain.verifyingContract", value);
+        return logger.throwArgumentError("invalid domain value \"verifyingContract\"", "domain.verifyingContract", value);
     },
     salt: function (value) {
         try {
-            const bytes = (0, bytes_1.arrayify)(value);
+            var bytes = (0, bytes_1.arrayify)(value);
             if (bytes.length !== 32) {
                 throw new Error("bad length");
             }
             return (0, bytes_1.hexlify)(bytes);
         }
         catch (error) { }
-        return logger.throwArgumentError(`invalid domain value "salt"`, "domain.salt", value);
+        return logger.throwArgumentError("invalid domain value \"salt\"", "domain.salt", value);
     }
 };
 function getBaseEncoder(type) {
     // intXX and uintXX
     {
-        const match = type.match(/^(u?)int(\d*)$/);
+        var match = type.match(/^(u?)int(\d*)$/);
         if (match) {
-            const signed = (match[1] === "");
-            const width = parseInt(match[2] || "256");
+            var signed = (match[1] === "");
+            var width = parseInt(match[2] || "256");
             if (width % 8 !== 0 || width > 256 || (match[2] && match[2] !== String(width))) {
                 logger.throwArgumentError("invalid numeric width", "type", type);
             }
-            const boundsUpper = MaxUint256.mask(signed ? (width - 1) : width);
-            const boundsLower = signed ? boundsUpper.add(One).mul(NegativeOne) : Zero;
+            var boundsUpper_1 = MaxUint256.mask(signed ? (width - 1) : width);
+            var boundsLower_1 = signed ? boundsUpper_1.add(One).mul(NegativeOne) : Zero;
             return function (value) {
-                const v = bignumber_1.BigNumber.from(value);
-                if (v.lt(boundsLower) || v.gt(boundsUpper)) {
-                    logger.throwArgumentError(`value out-of-bounds for ${type}`, "value", value);
+                var v = bignumber_1.BigNumber.from(value);
+                if (v.lt(boundsLower_1) || v.gt(boundsUpper_1)) {
+                    logger.throwArgumentError("value out-of-bounds for ".concat(type), "value", value);
                 }
                 return (0, bytes_1.hexZeroPad)(v.toTwos(256).toHexString(), 32);
             };
@@ -96,16 +132,16 @@ function getBaseEncoder(type) {
     }
     // bytesXX
     {
-        const match = type.match(/^bytes(\d+)$/);
+        var match = type.match(/^bytes(\d+)$/);
         if (match) {
-            const width = parseInt(match[1]);
-            if (width === 0 || width > 32 || match[1] !== String(width)) {
+            var width_1 = parseInt(match[1]);
+            if (width_1 === 0 || width_1 > 32 || match[1] !== String(width_1)) {
                 logger.throwArgumentError("invalid bytes width", "type", type);
             }
             return function (value) {
-                const bytes = (0, bytes_1.arrayify)(value);
-                if (bytes.length !== width) {
-                    logger.throwArgumentError(`invalid length for ${type}`, "value", value);
+                var bytes = (0, bytes_1.arrayify)(value);
+                if (bytes.length !== width_1) {
+                    logger.throwArgumentError("invalid length for ".concat(type), "value", value);
                 }
                 return hexPadRight(value);
             };
@@ -128,73 +164,79 @@ function getBaseEncoder(type) {
     return null;
 }
 function encodeType(name, fields) {
-    return `${name}(${fields.map(({ name, type }) => (type + " " + name)).join(",")})`;
+    return "".concat(name, "(").concat(fields.map(function (_a) {
+        var name = _a.name, type = _a.type;
+        return (type + " " + name);
+    }).join(","), ")");
 }
-class TypedDataEncoder {
-    constructor(types) {
+var TypedDataEncoder = /** @class */ (function () {
+    function TypedDataEncoder(types) {
         (0, properties_1.defineReadOnly)(this, "types", Object.freeze((0, properties_1.deepCopy)(types)));
         (0, properties_1.defineReadOnly)(this, "_encoderCache", {});
         (0, properties_1.defineReadOnly)(this, "_types", {});
         // Link struct types to their direct child structs
-        const links = {};
+        var links = {};
         // Link structs to structs which contain them as a child
-        const parents = {};
+        var parents = {};
         // Link all subtypes within a given struct
-        const subtypes = {};
-        Object.keys(types).forEach((type) => {
+        var subtypes = {};
+        Object.keys(types).forEach(function (type) {
             links[type] = {};
             parents[type] = [];
             subtypes[type] = {};
         });
-        for (const name in types) {
-            const uniqueNames = {};
-            types[name].forEach((field) => {
+        var _loop_1 = function (name_1) {
+            var uniqueNames = {};
+            types[name_1].forEach(function (field) {
                 // Check each field has a unique name
                 if (uniqueNames[field.name]) {
-                    logger.throwArgumentError(`duplicate variable name ${JSON.stringify(field.name)} in ${JSON.stringify(name)}`, "types", types);
+                    logger.throwArgumentError("duplicate variable name ".concat(JSON.stringify(field.name), " in ").concat(JSON.stringify(name_1)), "types", types);
                 }
                 uniqueNames[field.name] = true;
                 // Get the base type (drop any array specifiers)
-                const baseType = field.type.match(/^([^\x5b]*)(\x5b|$)/)[1];
-                if (baseType === name) {
-                    logger.throwArgumentError(`circular type reference to ${JSON.stringify(baseType)}`, "types", types);
+                var baseType = field.type.match(/^([^\x5b]*)(\x5b|$)/)[1];
+                if (baseType === name_1) {
+                    logger.throwArgumentError("circular type reference to ".concat(JSON.stringify(baseType)), "types", types);
                 }
                 // Is this a base encoding type?
-                const encoder = getBaseEncoder(baseType);
+                var encoder = getBaseEncoder(baseType);
                 if (encoder) {
                     return;
                 }
                 if (!parents[baseType]) {
-                    logger.throwArgumentError(`unknown type ${JSON.stringify(baseType)}`, "types", types);
+                    logger.throwArgumentError("unknown type ".concat(JSON.stringify(baseType)), "types", types);
                 }
                 // Add linkage
-                parents[baseType].push(name);
-                links[name][baseType] = true;
+                parents[baseType].push(name_1);
+                links[name_1][baseType] = true;
             });
+        };
+        for (var name_1 in types) {
+            _loop_1(name_1);
         }
         // Deduce the primary type
-        const primaryTypes = Object.keys(parents).filter((n) => (parents[n].length === 0));
+        var primaryTypes = Object.keys(parents).filter(function (n) { return (parents[n].length === 0); });
         if (primaryTypes.length === 0) {
             logger.throwArgumentError("missing primary type", "types", types);
         }
         else if (primaryTypes.length > 1) {
-            logger.throwArgumentError(`ambiguous primary types or unused types: ${primaryTypes.map((t) => (JSON.stringify(t))).join(", ")}`, "types", types);
+            logger.throwArgumentError("ambiguous primary types or unused types: ".concat(primaryTypes.map(function (t) { return (JSON.stringify(t)); }).join(", ")), "types", types);
         }
         (0, properties_1.defineReadOnly)(this, "primaryType", primaryTypes[0]);
         // Check for circular type references
         function checkCircular(type, found) {
             if (found[type]) {
-                logger.throwArgumentError(`circular type reference to ${JSON.stringify(type)}`, "types", types);
+                logger.throwArgumentError("circular type reference to ".concat(JSON.stringify(type)), "types", types);
             }
             found[type] = true;
-            Object.keys(links[type]).forEach((child) => {
+            Object.keys(links[type]).forEach(function (child) {
                 if (!parents[child]) {
                     return;
                 }
                 // Recursively check children
                 checkCircular(child, found);
                 // Mark all ancestors as having this decendant
-                Object.keys(found).forEach((subtype) => {
+                Object.keys(found).forEach(function (subtype) {
                     subtypes[subtype][child] = true;
                 });
             });
@@ -202,197 +244,224 @@ class TypedDataEncoder {
         }
         checkCircular(this.primaryType, {});
         // Compute each fully describe type
-        for (const name in subtypes) {
-            const st = Object.keys(subtypes[name]);
+        for (var name_2 in subtypes) {
+            var st = Object.keys(subtypes[name_2]);
             st.sort();
-            this._types[name] = encodeType(name, types[name]) + st.map((t) => encodeType(t, types[t])).join("");
+            this._types[name_2] = encodeType(name_2, types[name_2]) + st.map(function (t) { return encodeType(t, types[t]); }).join("");
         }
     }
-    getEncoder(type) {
-        let encoder = this._encoderCache[type];
+    TypedDataEncoder.prototype.getEncoder = function (type) {
+        var encoder = this._encoderCache[type];
         if (!encoder) {
             encoder = this._encoderCache[type] = this._getEncoder(type);
         }
         return encoder;
-    }
-    _getEncoder(type) {
+    };
+    TypedDataEncoder.prototype._getEncoder = function (type) {
+        var _this = this;
         // Basic encoder type (address, bool, uint256, etc)
         {
-            const encoder = getBaseEncoder(type);
+            var encoder = getBaseEncoder(type);
             if (encoder) {
                 return encoder;
             }
         }
         // Array
-        const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
+        var match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
         if (match) {
-            const subtype = match[1];
-            const subEncoder = this.getEncoder(subtype);
-            const length = parseInt(match[3]);
-            return (value) => {
-                if (length >= 0 && value.length !== length) {
+            var subtype_1 = match[1];
+            var subEncoder_1 = this.getEncoder(subtype_1);
+            var length_1 = parseInt(match[3]);
+            return function (value) {
+                if (length_1 >= 0 && value.length !== length_1) {
                     logger.throwArgumentError("array length mismatch; expected length ${ arrayLength }", "value", value);
                 }
-                let result = value.map(subEncoder);
-                if (this._types[subtype]) {
+                var result = value.map(subEncoder_1);
+                if (_this._types[subtype_1]) {
                     result = result.map(keccak256_1.keccak256);
                 }
                 return (0, keccak256_1.keccak256)((0, bytes_1.hexConcat)(result));
             };
         }
         // Struct
-        const fields = this.types[type];
+        var fields = this.types[type];
         if (fields) {
-            const encodedType = (0, id_1.id)(this._types[type]);
-            return (value) => {
-                const values = fields.map(({ name, type }) => {
-                    const result = this.getEncoder(type)(value[name]);
-                    if (this._types[type]) {
+            var encodedType_1 = (0, id_1.id)(this._types[type]);
+            return function (value) {
+                var values = fields.map(function (_a) {
+                    var name = _a.name, type = _a.type;
+                    var result = _this.getEncoder(type)(value[name]);
+                    if (_this._types[type]) {
                         return (0, keccak256_1.keccak256)(result);
                     }
                     return result;
                 });
-                values.unshift(encodedType);
+                values.unshift(encodedType_1);
                 return (0, bytes_1.hexConcat)(values);
             };
         }
-        return logger.throwArgumentError(`unknown type: ${type}`, "type", type);
-    }
-    encodeType(name) {
-        const result = this._types[name];
+        return logger.throwArgumentError("unknown type: ".concat(type), "type", type);
+    };
+    TypedDataEncoder.prototype.encodeType = function (name) {
+        var result = this._types[name];
         if (!result) {
-            logger.throwArgumentError(`unknown type: ${JSON.stringify(name)}`, "name", name);
+            logger.throwArgumentError("unknown type: ".concat(JSON.stringify(name)), "name", name);
         }
         return result;
-    }
-    encodeData(type, value) {
+    };
+    TypedDataEncoder.prototype.encodeData = function (type, value) {
         return this.getEncoder(type)(value);
-    }
-    hashStruct(name, value) {
+    };
+    TypedDataEncoder.prototype.hashStruct = function (name, value) {
         return (0, keccak256_1.keccak256)(this.encodeData(name, value));
-    }
-    encode(value) {
+    };
+    TypedDataEncoder.prototype.encode = function (value) {
         return this.encodeData(this.primaryType, value);
-    }
-    hash(value) {
+    };
+    TypedDataEncoder.prototype.hash = function (value) {
         return this.hashStruct(this.primaryType, value);
-    }
-    _visit(type, value, callback) {
+    };
+    TypedDataEncoder.prototype._visit = function (type, value, callback) {
+        var _this = this;
         // Basic encoder type (address, bool, uint256, etc)
         {
-            const encoder = getBaseEncoder(type);
+            var encoder = getBaseEncoder(type);
             if (encoder) {
                 return callback(type, value);
             }
         }
         // Array
-        const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
+        var match = type.match(/^(.*)(\x5b(\d*)\x5d)$/);
         if (match) {
-            const subtype = match[1];
-            const length = parseInt(match[3]);
-            if (length >= 0 && value.length !== length) {
+            var subtype_2 = match[1];
+            var length_2 = parseInt(match[3]);
+            if (length_2 >= 0 && value.length !== length_2) {
                 logger.throwArgumentError("array length mismatch; expected length ${ arrayLength }", "value", value);
             }
-            return value.map((v) => this._visit(subtype, v, callback));
+            return value.map(function (v) { return _this._visit(subtype_2, v, callback); });
         }
         // Struct
-        const fields = this.types[type];
+        var fields = this.types[type];
         if (fields) {
-            return fields.reduce((accum, { name, type }) => {
-                accum[name] = this._visit(type, value[name], callback);
+            return fields.reduce(function (accum, _a) {
+                var name = _a.name, type = _a.type;
+                accum[name] = _this._visit(type, value[name], callback);
                 return accum;
             }, {});
         }
-        return logger.throwArgumentError(`unknown type: ${type}`, "type", type);
-    }
-    visit(value, callback) {
+        return logger.throwArgumentError("unknown type: ".concat(type), "type", type);
+    };
+    TypedDataEncoder.prototype.visit = function (value, callback) {
         return this._visit(this.primaryType, value, callback);
-    }
-    static from(types) {
+    };
+    TypedDataEncoder.from = function (types) {
         return new TypedDataEncoder(types);
-    }
-    static getPrimaryType(types) {
+    };
+    TypedDataEncoder.getPrimaryType = function (types) {
         return TypedDataEncoder.from(types).primaryType;
-    }
-    static hashStruct(name, types, value) {
+    };
+    TypedDataEncoder.hashStruct = function (name, types, value) {
         return TypedDataEncoder.from(types).hashStruct(name, value);
-    }
-    static hashDomain(domain) {
-        const domainFields = [];
-        for (const name in domain) {
-            const type = domainFieldTypes[name];
+    };
+    TypedDataEncoder.hashDomain = function (domain) {
+        var domainFields = [];
+        for (var name_3 in domain) {
+            var type = domainFieldTypes[name_3];
             if (!type) {
-                logger.throwArgumentError(`invalid typed-data domain key: ${JSON.stringify(name)}`, "domain", domain);
+                logger.throwArgumentError("invalid typed-data domain key: ".concat(JSON.stringify(name_3)), "domain", domain);
             }
-            domainFields.push({ name, type });
+            domainFields.push({ name: name_3, type: type });
         }
-        domainFields.sort((a, b) => {
+        domainFields.sort(function (a, b) {
             return domainFieldNames.indexOf(a.name) - domainFieldNames.indexOf(b.name);
         });
         return TypedDataEncoder.hashStruct("EIP712Domain", { EIP712Domain: domainFields }, domain);
-    }
-    static encode(domain, types, value) {
+    };
+    TypedDataEncoder.encode = function (domain, types, value) {
         return (0, bytes_1.hexConcat)([
             "0x1901",
             TypedDataEncoder.hashDomain(domain),
             TypedDataEncoder.from(types).hash(value)
         ]);
-    }
-    static hash(domain, types, value) {
+    };
+    TypedDataEncoder.hash = function (domain, types, value) {
         return (0, keccak256_1.keccak256)(TypedDataEncoder.encode(domain, types, value));
-    }
+    };
     // Replaces all address types with ENS names with their looked up address
-    static async resolveNames(domain, types, value, resolveName) {
-        // Make a copy to isolate it from the object passed in
-        domain = (0, properties_1.shallowCopy)(domain);
-        // Look up all ENS names
-        const ensCache = {};
-        // Do we need to look up the domain's verifyingContract?
-        if (domain.verifyingContract && !(0, bytes_1.isHexString)(domain.verifyingContract, 20)) {
-            ensCache[domain.verifyingContract] = "0x";
-        }
-        // We are going to use the encoder to visit all the base values
-        const encoder = TypedDataEncoder.from(types);
-        // Get a list of all the addresses
-        encoder.visit(value, (type, value) => {
-            if (type === "address" && !(0, bytes_1.isHexString)(value, 20)) {
-                ensCache[value] = "0x";
-            }
-            return value;
-        });
-        // Lookup each name
-        for (const name in ensCache) {
-            ensCache[name] = await resolveName(name);
-        }
-        // Replace the domain verifyingContract if needed
-        if (domain.verifyingContract && ensCache[domain.verifyingContract]) {
-            domain.verifyingContract = ensCache[domain.verifyingContract];
-        }
-        // Replace all ENS names with their address
-        value = encoder.visit(value, (type, value) => {
-            if (type === "address" && ensCache[value]) {
-                return ensCache[value];
-            }
-            return value;
+    TypedDataEncoder.resolveNames = function (domain, types, value, resolveName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ensCache, encoder, _a, _b, _c, _i, name_4, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        // Make a copy to isolate it from the object passed in
+                        domain = (0, properties_1.shallowCopy)(domain);
+                        ensCache = {};
+                        // Do we need to look up the domain's verifyingContract?
+                        if (domain.verifyingContract && !(0, bytes_1.isHexString)(domain.verifyingContract, 20)) {
+                            ensCache[domain.verifyingContract] = "0x";
+                        }
+                        encoder = TypedDataEncoder.from(types);
+                        // Get a list of all the addresses
+                        encoder.visit(value, function (type, value) {
+                            if (type === "address" && !(0, bytes_1.isHexString)(value, 20)) {
+                                ensCache[value] = "0x";
+                            }
+                            return value;
+                        });
+                        _a = ensCache;
+                        _b = [];
+                        for (_c in _a)
+                            _b.push(_c);
+                        _i = 0;
+                        _f.label = 1;
+                    case 1:
+                        if (!(_i < _b.length)) return [3 /*break*/, 4];
+                        _c = _b[_i];
+                        if (!(_c in _a)) return [3 /*break*/, 3];
+                        name_4 = _c;
+                        _d = ensCache;
+                        _e = name_4;
+                        return [4 /*yield*/, resolveName(name_4)];
+                    case 2:
+                        _d[_e] = _f.sent();
+                        _f.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        // Replace the domain verifyingContract if needed
+                        if (domain.verifyingContract && ensCache[domain.verifyingContract]) {
+                            domain.verifyingContract = ensCache[domain.verifyingContract];
+                        }
+                        // Replace all ENS names with their address
+                        value = encoder.visit(value, function (type, value) {
+                            if (type === "address" && ensCache[value]) {
+                                return ensCache[value];
+                            }
+                            return value;
+                        });
+                        return [2 /*return*/, { domain: domain, value: value }];
+                }
+            });
         });
-        return { domain, value };
-    }
-    static getPayload(domain, types, value) {
+    };
+    TypedDataEncoder.getPayload = function (domain, types, value) {
         // Validate the domain fields
         TypedDataEncoder.hashDomain(domain);
         // Derive the EIP712Domain Struct reference type
-        const domainValues = {};
-        const domainTypes = [];
-        domainFieldNames.forEach((name) => {
-            const value = domain[name];
+        var domainValues = {};
+        var domainTypes = [];
+        domainFieldNames.forEach(function (name) {
+            var value = domain[name];
             if (value == null) {
                 return;
             }
             domainValues[name] = domainChecks[name](value);
-            domainTypes.push({ name, type: domainFieldTypes[name] });
+            domainTypes.push({ name: name, type: domainFieldTypes[name] });
         });
-        const encoder = TypedDataEncoder.from(types);
-        const typesWithDomain = (0, properties_1.shallowCopy)(types);
+        var encoder = TypedDataEncoder.from(types);
+        var typesWithDomain = (0, properties_1.shallowCopy)(types);
         if (typesWithDomain.EIP712Domain) {
             logger.throwArgumentError("types must not contain EIP712Domain type", "types.EIP712Domain", types);
         }
@@ -405,7 +474,7 @@ class TypedDataEncoder {
             types: typesWithDomain,
             domain: domainValues,
             primaryType: encoder.primaryType,
-            message: encoder.visit(value, (type, value) => {
+            message: encoder.visit(value, function (type, value) {
                 // bytes
                 if (type.match(/^bytes(\d*)/)) {
                     return (0, bytes_1.hexlify)((0, bytes_1.arrayify)(value));
@@ -421,14 +490,15 @@ class TypedDataEncoder {
                         return !!value;
                     case "string":
                         if (typeof (value) !== "string") {
-                            logger.throwArgumentError(`invalid string`, "value", value);
+                            logger.throwArgumentError("invalid string", "value", value);
                         }
                         return value;
                 }
                 return logger.throwArgumentError("unsupported type", "type", type);
             })
         };
-    }
-}
+    };
+    return TypedDataEncoder;
+}());
 exports.TypedDataEncoder = TypedDataEncoder;
 //# sourceMappingURL=typed-data.js.map