{"version":3,"sources":["webpack:///./node_modules/@ethersproject/hash/lib.esm/ens-normalize/decoder.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/ens-normalize/lib.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/ens-normalize/include.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/namehash.js","webpack:///./node_modules/@ethersproject/logger/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/id.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/inspect.js","webpack:///./node_modules/@ethersproject/keccak256/lib.esm/index.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/message.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/keystore.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/crowdsale.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/index.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/typed-data.js","webpack:///./node_modules/@ethersproject/hdnode/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/hdnode/lib.esm/index.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/utils.js","webpack:///./node_modules/@ethersproject/logger/lib.esm/index.js"],"names":["flat","array","depth","result","forEach","flatDeep","arr","call","val","Array","isArray","push","read_compressed_payload","bytes","v","pos","read_payload","u16","symbol_count","total","acc","i","skip","pos_payload","read_width","read_buffer","read_bit","FULL","Math","pow","HALF","QRTR","MASK","register","symbols","low","range","value","floor","start","end","mid","a","b","offset","map","x","decode_arithmetic","signed","read_ascending","n","next","read_deltas","read_member_array","lookup","vX","vN","read_counts","j","read_transposed","w","m","fill","read_linear_table","dx","dy","read_zero_terminated_array","length","ys","slice","_","j_dy","y","read_replacement_table","r","VALID","Set","IGNORED","MAPPED","ret","fromEntries","read_mapped_map","EMOJI_ROOT","sorted","sort","read","branches","keys","set","node","size","temp","valid","fe0f","save","check","read_emoji_trie","HYPHEN","UNDERSCORE","explode_cp","name","filter_fe0f","cps","filter","cp","ens_normalize_post_check","label","split","lastIndexOf","Error","every","err","message","ens_normalize","emoji_filter","input","reverse","output","emoji","consume_emoji_reversed","pop","has","toString","toUpperCase","s","normalize","nfc","String","fromCodePoint","eaten","_a","saved","stack","find","splice","logger","Zeros","Uint8Array","checkComponent","comp","ensNameSplit","comps","last","isValidName","error","namehash","throwArgumentError","dnsEncode","e","version","id","text","isCrowdsaleWallet","json","data","JSON","parse","encseed","ethaddr","isKeystoreWallet","parseInt","getJsonWalletAddress","address","keccak256","keccak_256","messagePrefix","hashMessage","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","rejected","done","then","apply","hasMnemonic","mnemonic","phrase","KeystoreAccount","isKeystoreAccount","_isKeystoreAccount","_getAccount","key","ciphertext","substring","toLowerCase","privateKey","iv","counter","Counter","aesCtr","ModeOfOperation","ctr","decrypt","_decrypt","throwError","errors","UNSUPPORTED_OPERATION","operation","mnemonicKey","account","mnemonicCiphertext","mnemonicIv","mnemonicCounter","mnemonicAesCtr","path","locale","entropy","fromMnemonic","derivePath","code","INVALID_ARGUMENT","argument","pbkdf2Sync","passwordBytes","salt","count","dkLen","prfFunc","pbkdf2","_computeKdfKey","password","pbkdf2Func","scryptFunc","progressCallback","kdf","N","p","prf","decryptSync","syncScrypt","this","scrypt","encrypt","options","srcMnemonic","client","uuidRandom","uuid","derivedKey","macPrefix","mac","crypto","cipher","cipherparams","kdfparams","dklen","now","Date","timestamp","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","gethFilename","stringify","isCrowdsaleAccount","_isCrowdsaleAccount","encryptedSeed","aesCbc","cbc","seed","padding","pkcs7","strip","seedHex","fromCharCode","seedHexBytes","decryptJsonWallet","decryptJsonWalletSync","NegativeOne","from","Zero","One","MaxUint256","hexTrue","toHexString","hexFalse","domainFieldTypes","chainId","verifyingContract","domainFieldNames","checkString","domainChecks","getBaseEncoder","type","match","width","boundsUpper","mask","boundsLower","add","mul","lt","gt","toTwos","padOffset","hexPadRight","encodeType","fields","join","TypedDataEncoder","constructor","types","Object","freeze","links","parents","subtypes","uniqueNames","field","baseType","primaryTypes","t","checkCircular","found","child","subtype","primaryType","st","_types","getEncoder","encoder","_encoderCache","_getEncoder","subEncoder","encodedType","values","unshift","encodeData","hashStruct","encode","hash","_visit","callback","reduce","accum","visit","static","domain","domainFields","indexOf","EIP712Domain","hashDomain","resolveName","ensCache","domainValues","domainTypes","typesWithDomain","MasterSecret","HardenedBit","getUpperMask","bits","getLowerMask","bytes32","base58check","sha2","getWordlist","wordlist","wordlists","words","_constructorGuard","defaultPath","constructorGuard","publicKey","parentFingerprint","chainCode","index","mnemonicOrPath","signingKey","compressedPublicKey","extendedKey","neuter","_derive","I","sha512","IL","IR","ki","Ki","mod","_addPoint","fingerprint","components","shift","component","seedArray","entropyToMnemonic","mnemonicToEntropy","_fromSeed","mnemonicToSeed","decode","NFKD","checkNormalize","ceil","getWordIndex","bit","entropyBits","checksumMask","indices","remainingBits","checksumBits","checksum","getWord","isValidMnemonic","getAccountPath","looseArrayify","hexString","zpad","getPassword","NFKC","searchPath","object","currentChild","matchingChild","uuidV4","randomBytes","_permanentCensorErrors","_censorErrors","LogLevels","debug","info","warning","off","_logLevel","_globalLogger","_normalizeError","missing","form","_checkNormalize","LogLevel","ErrorCode","HEX","Logger","defineProperty","enumerable","writable","_log","logLevel","args","level","console","log","levels","DEBUG","INFO","warn","WARNING","makeError","params","UNKNOWN_ERROR","messageDetails","hex","reason","url","NUMERIC_FAULT","fault","CALL_EXCEPTION","INSUFFICIENT_FUNDS","MISSING_NEW","NONCE_EXPIRED","REPLACEMENT_UNDERPRICED","TRANSACTION_REPLACED","UNPREDICTABLE_GAS_LIMIT","assert","condition","assertArgument","checkSafeUint53","checkArgumentCount","expectedCount","MISSING_ARGUMENT","UNEXPECTED_ARGUMENT","checkNew","target","kind","checkAbstract","censorship","permanent","globalLogger"],"mappings":"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","file":"js/chunk-vendors~602a6e35.4dbb17c2.js","sourcesContent":["/**\n * MIT License\n *\n * Copyright (c) 2021 Andrew Raffensperger\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n *\n * This is a near carbon-copy of the original source (link below) with the\n * TypeScript typings added and a few tweaks to make it ES3-compatible.\n *\n * See: https://github.com/adraffy/ens-normalize.js\n */\n// https://github.com/behnammodi/polyfill/blob/master/array.polyfill.js\nfunction flat(array, depth) {\n    if (depth == null) {\n        depth = 1;\n    }\n    const result = [];\n    const forEach = result.forEach;\n    const flatDeep = function (arr, depth) {\n        forEach.call(arr, function (val) {\n            if (depth > 0 && Array.isArray(val)) {\n                flatDeep(val, depth - 1);\n            }\n            else {\n                result.push(val);\n            }\n        });\n    };\n    flatDeep(array, depth);\n    return result;\n}\nfunction fromEntries(array) {\n    const result = {};\n    for (let i = 0; i < array.length; i++) {\n        const value = array[i];\n        result[value[0]] = value[1];\n    }\n    return result;\n}\nexport function decode_arithmetic(bytes) {\n    let pos = 0;\n    function u16() { return (bytes[pos++] << 8) | bytes[pos++]; }\n    // decode the frequency table\n    let symbol_count = u16();\n    let total = 1;\n    let acc = [0, 1]; // first symbol has frequency 1\n    for (let i = 1; i < symbol_count; i++) {\n        acc.push(total += u16());\n    }\n    // skip the sized-payload that the last 3 symbols index into\n    let skip = u16();\n    let pos_payload = pos;\n    pos += skip;\n    let read_width = 0;\n    let read_buffer = 0;\n    function read_bit() {\n        if (read_width == 0) {\n            // this will read beyond end of buffer\n            // but (undefined|0) => zero pad\n            read_buffer = (read_buffer << 8) | bytes[pos++];\n            read_width = 8;\n        }\n        return (read_buffer >> --read_width) & 1;\n    }\n    const N = 31;\n    const FULL = Math.pow(2, N);\n    const HALF = FULL >>> 1;\n    const QRTR = HALF >> 1;\n    const MASK = FULL - 1;\n    // fill register\n    let register = 0;\n    for (let i = 0; i < N; i++)\n        register = (register << 1) | read_bit();\n    let symbols = [];\n    let low = 0;\n    let range = FULL; // treat like a float\n    while (true) {\n        let value = Math.floor((((register - low + 1) * total) - 1) / range);\n        let start = 0;\n        let end = symbol_count;\n        while (end - start > 1) { // binary search\n            let mid = (start + end) >>> 1;\n            if (value < acc[mid]) {\n                end = mid;\n            }\n            else {\n                start = mid;\n            }\n        }\n        if (start == 0)\n            break; // first symbol is end mark\n        symbols.push(start);\n        let a = low + Math.floor(range * acc[start] / total);\n        let b = low + Math.floor(range * acc[start + 1] / total) - 1;\n        while (((a ^ b) & HALF) == 0) {\n            register = (register << 1) & MASK | read_bit();\n            a = (a << 1) & MASK;\n            b = (b << 1) & MASK | 1;\n        }\n        while (a & ~b & QRTR) {\n            register = (register & HALF) | ((register << 1) & (MASK >>> 1)) | read_bit();\n            a = (a << 1) ^ HALF;\n            b = ((b ^ HALF) << 1) | HALF | 1;\n        }\n        low = a;\n        range = 1 + b - a;\n    }\n    let offset = symbol_count - 4;\n    return symbols.map(x => {\n        switch (x - offset) {\n            case 3: return offset + 0x10100 + ((bytes[pos_payload++] << 16) | (bytes[pos_payload++] << 8) | bytes[pos_payload++]);\n            case 2: return offset + 0x100 + ((bytes[pos_payload++] << 8) | bytes[pos_payload++]);\n            case 1: return offset + bytes[pos_payload++];\n            default: return x - 1;\n        }\n    });\n}\n// returns an iterator which returns the next symbol\nexport function read_payload(v) {\n    let pos = 0;\n    return () => v[pos++];\n}\nexport function read_compressed_payload(bytes) {\n    return read_payload(decode_arithmetic(bytes));\n}\n// eg. [0,1,2,3...] => [0,-1,1,-2,...]\nexport function signed(i) {\n    return (i & 1) ? (~i >> 1) : (i >> 1);\n}\nfunction read_counts(n, next) {\n    let v = Array(n);\n    for (let i = 0; i < n; i++)\n        v[i] = 1 + next();\n    return v;\n}\nfunction read_ascending(n, next) {\n    let v = Array(n);\n    for (let i = 0, x = -1; i < n; i++)\n        v[i] = x += 1 + next();\n    return v;\n}\nfunction read_deltas(n, next) {\n    let v = Array(n);\n    for (let i = 0, x = 0; i < n; i++)\n        v[i] = x += signed(next());\n    return v;\n}\nexport function read_member_array(next, lookup) {\n    let v = read_ascending(next(), next);\n    let n = next();\n    let vX = read_ascending(n, next);\n    let vN = read_counts(n, next);\n    for (let i = 0; i < n; i++) {\n        for (let j = 0; j < vN[i]; j++) {\n            v.push(vX[i] + j);\n        }\n    }\n    return lookup ? v.map(x => lookup[x]) : v;\n}\n// returns array of \n// [x, ys] => single replacement rule\n// [x, ys, n, dx, dx] => linear map\nexport function read_mapped_map(next) {\n    let ret = [];\n    while (true) {\n        let w = next();\n        if (w == 0)\n            break;\n        ret.push(read_linear_table(w, next));\n    }\n    while (true) {\n        let w = next() - 1;\n        if (w < 0)\n            break;\n        ret.push(read_replacement_table(w, next));\n    }\n    return fromEntries(flat(ret));\n}\nexport function read_zero_terminated_array(next) {\n    let v = [];\n    while (true) {\n        let i = next();\n        if (i == 0)\n            break;\n        v.push(i);\n    }\n    return v;\n}\nfunction read_transposed(n, w, next) {\n    let m = Array(n).fill(undefined).map(() => []);\n    for (let i = 0; i < w; i++) {\n        read_deltas(n, next).forEach((x, j) => m[j].push(x));\n    }\n    return m;\n}\nfunction read_linear_table(w, next) {\n    let dx = 1 + next();\n    let dy = next();\n    let vN = read_zero_terminated_array(next);\n    let m = read_transposed(vN.length, 1 + w, next);\n    return flat(m.map((v, i) => {\n        const x = v[0], ys = v.slice(1);\n        //let [x, ...ys] = v;\n        //return Array(vN[i]).fill().map((_, j) => {\n        return Array(vN[i]).fill(undefined).map((_, j) => {\n            let j_dy = j * dy;\n            return [x + j * dx, ys.map(y => y + j_dy)];\n        });\n    }));\n}\nfunction read_replacement_table(w, next) {\n    let n = 1 + next();\n    let m = read_transposed(n, 1 + w, next);\n    return m.map(v => [v[0], v.slice(1)]);\n}\nexport function read_emoji_trie(next) {\n    let sorted = read_member_array(next).sort((a, b) => a - b);\n    return read();\n    function read() {\n        let branches = [];\n        while (true) {\n            let keys = read_member_array(next, sorted);\n            if (keys.length == 0)\n                break;\n            branches.push({ set: new Set(keys), node: read() });\n        }\n        branches.sort((a, b) => b.set.size - a.set.size); // sort by likelihood\n        let temp = next();\n        let valid = temp % 3;\n        temp = (temp / 3) | 0;\n        let fe0f = !!(temp & 1);\n        temp >>= 1;\n        let save = temp == 1;\n        let check = temp == 2;\n        return { branches, valid, fe0f, save, check };\n    }\n}\n//# sourceMappingURL=decoder.js.map","/**\n * MIT License\n *\n * Copyright (c) 2021 Andrew Raffensperger\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n *\n * This is a near carbon-copy of the original source (link below) with the\n * TypeScript typings added and a few tweaks to make it ES3-compatible.\n *\n * See: https://github.com/adraffy/ens-normalize.js\n */\nimport { toUtf8CodePoints } from \"@ethersproject/strings\";\nimport { getData } from './include.js';\nconst r = getData();\nimport { read_member_array, read_mapped_map, read_emoji_trie } from './decoder.js';\n// @TODO: This should be lazily loaded\nconst VALID = new Set(read_member_array(r));\nconst IGNORED = new Set(read_member_array(r));\nconst MAPPED = read_mapped_map(r);\nconst EMOJI_ROOT = read_emoji_trie(r);\n//const NFC_CHECK = new Set(read_member_array(r, Array.from(VALID.values()).sort((a, b) => a - b)));\n//const STOP = 0x2E;\nconst HYPHEN = 0x2D;\nconst UNDERSCORE = 0x5F;\nfunction explode_cp(name) {\n    return toUtf8CodePoints(name);\n}\nfunction filter_fe0f(cps) {\n    return cps.filter(cp => cp != 0xFE0F);\n}\nexport function ens_normalize_post_check(name) {\n    for (let label of name.split('.')) {\n        let cps = explode_cp(label);\n        try {\n            for (let i = cps.lastIndexOf(UNDERSCORE) - 1; i >= 0; i--) {\n                if (cps[i] !== UNDERSCORE) {\n                    throw new Error(`underscore only allowed at start`);\n                }\n            }\n            if (cps.length >= 4 && cps.every(cp => cp < 0x80) && cps[2] === HYPHEN && cps[3] === HYPHEN) {\n                throw new Error(`invalid label extension`);\n            }\n        }\n        catch (err) {\n            throw new Error(`Invalid label \"${label}\": ${err.message}`);\n        }\n    }\n    return name;\n}\nexport function ens_normalize(name) {\n    return ens_normalize_post_check(normalize(name, filter_fe0f));\n}\nfunction normalize(name, emoji_filter) {\n    let input = explode_cp(name).reverse(); // flip for pop\n    let output = [];\n    while (input.length) {\n        let emoji = consume_emoji_reversed(input);\n        if (emoji) {\n            output.push(...emoji_filter(emoji));\n            continue;\n        }\n        let cp = input.pop();\n        if (VALID.has(cp)) {\n            output.push(cp);\n            continue;\n        }\n        if (IGNORED.has(cp)) {\n            continue;\n        }\n        let cps = MAPPED[cp];\n        if (cps) {\n            output.push(...cps);\n            continue;\n        }\n        throw new Error(`Disallowed codepoint: 0x${cp.toString(16).toUpperCase()}`);\n    }\n    return ens_normalize_post_check(nfc(String.fromCodePoint(...output)));\n}\nfunction nfc(s) {\n    return s.normalize('NFC');\n}\nfunction consume_emoji_reversed(cps, eaten) {\n    var _a;\n    let node = EMOJI_ROOT;\n    let emoji;\n    let saved;\n    let stack = [];\n    let pos = cps.length;\n    if (eaten)\n        eaten.length = 0; // clear input buffer (if needed)\n    while (pos) {\n        let cp = cps[--pos];\n        node = (_a = node.branches.find(x => x.set.has(cp))) === null || _a === void 0 ? void 0 : _a.node;\n        if (!node)\n            break;\n        if (node.save) { // remember\n            saved = cp;\n        }\n        else if (node.check) { // check exclusion\n            if (cp === saved)\n                break;\n        }\n        stack.push(cp);\n        if (node.fe0f) {\n            stack.push(0xFE0F);\n            if (pos > 0 && cps[pos - 1] == 0xFE0F)\n                pos--; // consume optional FE0F\n        }\n        if (node.valid) { // this is a valid emoji (so far)\n            emoji = stack.slice(); // copy stack\n            if (node.valid == 2)\n                emoji.splice(1, 1); // delete FE0F at position 1 (RGI ZWJ don't follow spec!)\n            if (eaten)\n                eaten.push(...cps.slice(pos).reverse()); // copy input (if needed)\n            cps.length = pos; // truncate\n        }\n    }\n    return emoji;\n}\n//# sourceMappingURL=lib.js.map","/**\n * MIT License\n *\n * Copyright (c) 2021 Andrew Raffensperger\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n *\n * This is a near carbon-copy of the original source (link below) with the\n * TypeScript typings added and a few tweaks to make it ES3-compatible.\n *\n * See: https://github.com/adraffy/ens-normalize.js\n */\nimport { decode } from \"@ethersproject/base64\";\nimport { read_compressed_payload } from './decoder.js';\nexport function getData() {\n    return read_compressed_payload(decode('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'));\n}\n//# sourceMappingURL=include.js.map","import { concat, hexlify } from \"@ethersproject/bytes\";\nimport { toUtf8Bytes, toUtf8String } from \"@ethersproject/strings\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { ens_normalize } from \"./ens-normalize/lib\";\nconst Zeros = new Uint8Array(32);\nZeros.fill(0);\nfunction checkComponent(comp) {\n    if (comp.length === 0) {\n        throw new Error(\"invalid ENS name; empty component\");\n    }\n    return comp;\n}\nfunction ensNameSplit(name) {\n    const bytes = toUtf8Bytes(ens_normalize(name));\n    const comps = [];\n    if (name.length === 0) {\n        return comps;\n    }\n    let last = 0;\n    for (let i = 0; i < bytes.length; i++) {\n        const d = bytes[i];\n        // A separator (i.e. \".\"); copy this component\n        if (d === 0x2e) {\n            comps.push(checkComponent(bytes.slice(last, i)));\n            last = i + 1;\n        }\n    }\n    // There was a stray separator at the end of the name\n    if (last >= bytes.length) {\n        throw new Error(\"invalid ENS name; empty component\");\n    }\n    comps.push(checkComponent(bytes.slice(last)));\n    return comps;\n}\nexport function ensNormalize(name) {\n    return ensNameSplit(name).map((comp) => toUtf8String(comp)).join(\".\");\n}\nexport function isValidName(name) {\n    try {\n        return (ensNameSplit(name).length !== 0);\n    }\n    catch (error) { }\n    return false;\n}\nexport function namehash(name) {\n    /* istanbul ignore if */\n    if (typeof (name) !== \"string\") {\n        logger.throwArgumentError(\"invalid ENS name; not a string\", \"name\", name);\n    }\n    let result = Zeros;\n    const comps = ensNameSplit(name);\n    while (comps.length) {\n        result = keccak256(concat([result, keccak256(comps.pop())]));\n    }\n    return hexlify(result);\n}\nexport function dnsEncode(name) {\n    return hexlify(concat(ensNameSplit(name).map((comp) => {\n        // DNS does not allow components over 63 bytes in length\n        if (comp.length > 63) {\n            throw new Error(\"invalid DNS encoded entry; length exceeds 63 bytes\");\n        }\n        const bytes = new Uint8Array(comp.length + 1);\n        bytes.set(comp, 1);\n        bytes[0] = bytes.length - 1;\n        return bytes;\n    }))) + \"00\";\n}\n//# sourceMappingURL=namehash.js.map","export const version = \"logger/5.7.0\";\n//# sourceMappingURL=_version.js.map","import { keccak256 } from \"@ethersproject/keccak256\";\nimport { toUtf8Bytes } from \"@ethersproject/strings\";\nexport function id(text) {\n    return keccak256(toUtf8Bytes(text));\n}\n//# sourceMappingURL=id.js.map","export const version = \"json-wallets/5.7.0\";\n//# sourceMappingURL=_version.js.map","export const version = \"hash/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { getAddress } from \"@ethersproject/address\";\nexport function isCrowdsaleWallet(json) {\n    let data = null;\n    try {\n        data = JSON.parse(json);\n    }\n    catch (error) {\n        return false;\n    }\n    return (data.encseed && data.ethaddr);\n}\nexport function isKeystoreWallet(json) {\n    let data = null;\n    try {\n        data = JSON.parse(json);\n    }\n    catch (error) {\n        return false;\n    }\n    if (!data.version || parseInt(data.version) !== data.version || parseInt(data.version) !== 3) {\n        return false;\n    }\n    // @TODO: Put more checks to make sure it has kdf, iv and all that good stuff\n    return true;\n}\n//export function isJsonWallet(json: string): boolean {\n//    return (isSecretStorageWallet(json) || isCrowdsaleWallet(json));\n//}\nexport function getJsonWalletAddress(json) {\n    if (isCrowdsaleWallet(json)) {\n        try {\n            return getAddress(JSON.parse(json).ethaddr);\n        }\n        catch (error) {\n            return null;\n        }\n    }\n    if (isKeystoreWallet(json)) {\n        try {\n            return getAddress(JSON.parse(json).address);\n        }\n        catch (error) {\n            return null;\n        }\n    }\n    return null;\n}\n//# sourceMappingURL=inspect.js.map","\"use strict\";\nimport sha3 from \"js-sha3\";\nimport { arrayify } from \"@ethersproject/bytes\";\nexport function keccak256(data) {\n    return '0x' + sha3.keccak_256(arrayify(data));\n}\n//# sourceMappingURL=index.js.map","import { concat } from \"@ethersproject/bytes\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { toUtf8Bytes } from \"@ethersproject/strings\";\nexport const messagePrefix = \"\\x19Ethereum Signed Message:\\n\";\nexport function hashMessage(message) {\n    if (typeof (message) === \"string\") {\n        message = toUtf8Bytes(message);\n    }\n    return keccak256(concat([\n        toUtf8Bytes(messagePrefix),\n        toUtf8Bytes(String(message.length)),\n        message\n    ]));\n}\n//# sourceMappingURL=message.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport aes from \"aes-js\";\nimport scrypt from \"scrypt-js\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { arrayify, concat, hexlify } from \"@ethersproject/bytes\";\nimport { defaultPath, entropyToMnemonic, HDNode, mnemonicToEntropy } from \"@ethersproject/hdnode\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { pbkdf2 as _pbkdf2 } from \"@ethersproject/pbkdf2\";\nimport { randomBytes } from \"@ethersproject/random\";\nimport { Description } from \"@ethersproject/properties\";\nimport { computeAddress } from \"@ethersproject/transactions\";\nimport { getPassword, looseArrayify, searchPath, uuidV4, zpad } from \"./utils\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n// Exported Types\nfunction hasMnemonic(value) {\n    return (value != null && value.mnemonic && value.mnemonic.phrase);\n}\nexport class KeystoreAccount extends Description {\n    isKeystoreAccount(value) {\n        return !!(value && value._isKeystoreAccount);\n    }\n}\nfunction _decrypt(data, key, ciphertext) {\n    const cipher = searchPath(data, \"crypto/cipher\");\n    if (cipher === \"aes-128-ctr\") {\n        const iv = looseArrayify(searchPath(data, \"crypto/cipherparams/iv\"));\n        const counter = new aes.Counter(iv);\n        const aesCtr = new aes.ModeOfOperation.ctr(key, counter);\n        return arrayify(aesCtr.decrypt(ciphertext));\n    }\n    return null;\n}\nfunction _getAccount(data, key) {\n    const ciphertext = looseArrayify(searchPath(data, \"crypto/ciphertext\"));\n    const computedMAC = hexlify(keccak256(concat([key.slice(16, 32), ciphertext]))).substring(2);\n    if (computedMAC !== searchPath(data, \"crypto/mac\").toLowerCase()) {\n        throw new Error(\"invalid password\");\n    }\n    const privateKey = _decrypt(data, key.slice(0, 16), ciphertext);\n    if (!privateKey) {\n        logger.throwError(\"unsupported cipher\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"decrypt\"\n        });\n    }\n    const mnemonicKey = key.slice(32, 64);\n    const address = computeAddress(privateKey);\n    if (data.address) {\n        let check = data.address.toLowerCase();\n        if (check.substring(0, 2) !== \"0x\") {\n            check = \"0x\" + check;\n        }\n        if (getAddress(check) !== address) {\n            throw new Error(\"address mismatch\");\n        }\n    }\n    const account = {\n        _isKeystoreAccount: true,\n        address: address,\n        privateKey: hexlify(privateKey)\n    };\n    // Version 0.1 x-ethers metadata must contain an encrypted mnemonic phrase\n    if (searchPath(data, \"x-ethers/version\") === \"0.1\") {\n        const mnemonicCiphertext = looseArrayify(searchPath(data, \"x-ethers/mnemonicCiphertext\"));\n        const mnemonicIv = looseArrayify(searchPath(data, \"x-ethers/mnemonicCounter\"));\n        const mnemonicCounter = new aes.Counter(mnemonicIv);\n        const mnemonicAesCtr = new aes.ModeOfOperation.ctr(mnemonicKey, mnemonicCounter);\n        const path = searchPath(data, \"x-ethers/path\") || defaultPath;\n        const locale = searchPath(data, \"x-ethers/locale\") || \"en\";\n        const entropy = arrayify(mnemonicAesCtr.decrypt(mnemonicCiphertext));\n        try {\n            const mnemonic = entropyToMnemonic(entropy, locale);\n            const node = HDNode.fromMnemonic(mnemonic, null, locale).derivePath(path);\n            if (node.privateKey != account.privateKey) {\n                throw new Error(\"mnemonic mismatch\");\n            }\n            account.mnemonic = node.mnemonic;\n        }\n        catch (error) {\n            // If we don't have the locale wordlist installed to\n            // read this mnemonic, just bail and don't set the\n            // mnemonic\n            if (error.code !== Logger.errors.INVALID_ARGUMENT || error.argument !== \"wordlist\") {\n                throw error;\n            }\n        }\n    }\n    return new KeystoreAccount(account);\n}\nfunction pbkdf2Sync(passwordBytes, salt, count, dkLen, prfFunc) {\n    return arrayify(_pbkdf2(passwordBytes, salt, count, dkLen, prfFunc));\n}\nfunction pbkdf2(passwordBytes, salt, count, dkLen, prfFunc) {\n    return Promise.resolve(pbkdf2Sync(passwordBytes, salt, count, dkLen, prfFunc));\n}\nfunction _computeKdfKey(data, password, pbkdf2Func, scryptFunc, progressCallback) {\n    const passwordBytes = getPassword(password);\n    const kdf = searchPath(data, \"crypto/kdf\");\n    if (kdf && typeof (kdf) === \"string\") {\n        const throwError = function (name, value) {\n            return logger.throwArgumentError(\"invalid key-derivation function parameters\", name, value);\n        };\n        if (kdf.toLowerCase() === \"scrypt\") {\n            const salt = looseArrayify(searchPath(data, \"crypto/kdfparams/salt\"));\n            const N = parseInt(searchPath(data, \"crypto/kdfparams/n\"));\n            const r = parseInt(searchPath(data, \"crypto/kdfparams/r\"));\n            const p = parseInt(searchPath(data, \"crypto/kdfparams/p\"));\n            // Check for all required parameters\n            if (!N || !r || !p) {\n                throwError(\"kdf\", kdf);\n            }\n            // Make sure N is a power of 2\n            if ((N & (N - 1)) !== 0) {\n                throwError(\"N\", N);\n            }\n            const dkLen = parseInt(searchPath(data, \"crypto/kdfparams/dklen\"));\n            if (dkLen !== 32) {\n                throwError(\"dklen\", dkLen);\n            }\n            return scryptFunc(passwordBytes, salt, N, r, p, 64, progressCallback);\n        }\n        else if (kdf.toLowerCase() === \"pbkdf2\") {\n            const salt = looseArrayify(searchPath(data, \"crypto/kdfparams/salt\"));\n            let prfFunc = null;\n            const prf = searchPath(data, \"crypto/kdfparams/prf\");\n            if (prf === \"hmac-sha256\") {\n                prfFunc = \"sha256\";\n            }\n            else if (prf === \"hmac-sha512\") {\n                prfFunc = \"sha512\";\n            }\n            else {\n                throwError(\"prf\", prf);\n            }\n            const count = parseInt(searchPath(data, \"crypto/kdfparams/c\"));\n            const dkLen = parseInt(searchPath(data, \"crypto/kdfparams/dklen\"));\n            if (dkLen !== 32) {\n                throwError(\"dklen\", dkLen);\n            }\n            return pbkdf2Func(passwordBytes, salt, count, dkLen, prfFunc);\n        }\n    }\n    return logger.throwArgumentError(\"unsupported key-derivation function\", \"kdf\", kdf);\n}\nexport function decryptSync(json, password) {\n    const data = JSON.parse(json);\n    const key = _computeKdfKey(data, password, pbkdf2Sync, scrypt.syncScrypt);\n    return _getAccount(data, key);\n}\nexport function decrypt(json, password, progressCallback) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const data = JSON.parse(json);\n        const key = yield _computeKdfKey(data, password, pbkdf2, scrypt.scrypt, progressCallback);\n        return _getAccount(data, key);\n    });\n}\nexport function encrypt(account, password, options, progressCallback) {\n    try {\n        // Check the address matches the private key\n        if (getAddress(account.address) !== computeAddress(account.privateKey)) {\n            throw new Error(\"address/privateKey mismatch\");\n        }\n        // Check the mnemonic (if any) matches the private key\n        if (hasMnemonic(account)) {\n            const mnemonic = account.mnemonic;\n            const node = HDNode.fromMnemonic(mnemonic.phrase, null, mnemonic.locale).derivePath(mnemonic.path || defaultPath);\n            if (node.privateKey != account.privateKey) {\n                throw new Error(\"mnemonic mismatch\");\n            }\n        }\n    }\n    catch (e) {\n        return Promise.reject(e);\n    }\n    // The options are optional, so adjust the call as needed\n    if (typeof (options) === \"function\" && !progressCallback) {\n        progressCallback = options;\n        options = {};\n    }\n    if (!options) {\n        options = {};\n    }\n    const privateKey = arrayify(account.privateKey);\n    const passwordBytes = getPassword(password);\n    let entropy = null;\n    let path = null;\n    let locale = null;\n    if (hasMnemonic(account)) {\n        const srcMnemonic = account.mnemonic;\n        entropy = arrayify(mnemonicToEntropy(srcMnemonic.phrase, srcMnemonic.locale || \"en\"));\n        path = srcMnemonic.path || defaultPath;\n        locale = srcMnemonic.locale || \"en\";\n    }\n    let client = options.client;\n    if (!client) {\n        client = \"ethers.js\";\n    }\n    // Check/generate the salt\n    let salt = null;\n    if (options.salt) {\n        salt = arrayify(options.salt);\n    }\n    else {\n        salt = randomBytes(32);\n        ;\n    }\n    // Override initialization vector\n    let iv = null;\n    if (options.iv) {\n        iv = arrayify(options.iv);\n        if (iv.length !== 16) {\n            throw new Error(\"invalid iv\");\n        }\n    }\n    else {\n        iv = randomBytes(16);\n    }\n    // Override the uuid\n    let uuidRandom = null;\n    if (options.uuid) {\n        uuidRandom = arrayify(options.uuid);\n        if (uuidRandom.length !== 16) {\n            throw new Error(\"invalid uuid\");\n        }\n    }\n    else {\n        uuidRandom = randomBytes(16);\n    }\n    // Override the scrypt password-based key derivation function parameters\n    let N = (1 << 17), r = 8, p = 1;\n    if (options.scrypt) {\n        if (options.scrypt.N) {\n            N = options.scrypt.N;\n        }\n        if (options.scrypt.r) {\n            r = options.scrypt.r;\n        }\n        if (options.scrypt.p) {\n            p = options.scrypt.p;\n        }\n    }\n    // We take 64 bytes:\n    //   - 32 bytes   As normal for the Web3 secret storage (derivedKey, macPrefix)\n    //   - 32 bytes   AES key to encrypt mnemonic with (required here to be Ethers Wallet)\n    return scrypt.scrypt(passwordBytes, salt, N, r, p, 64, progressCallback).then((key) => {\n        key = arrayify(key);\n        // This will be used to encrypt the wallet (as per Web3 secret storage)\n        const derivedKey = key.slice(0, 16);\n        const macPrefix = key.slice(16, 32);\n        // This will be used to encrypt the mnemonic phrase (if any)\n        const mnemonicKey = key.slice(32, 64);\n        // Encrypt the private key\n        const counter = new aes.Counter(iv);\n        const aesCtr = new aes.ModeOfOperation.ctr(derivedKey, counter);\n        const ciphertext = arrayify(aesCtr.encrypt(privateKey));\n        // Compute the message authentication code, used to check the password\n        const mac = keccak256(concat([macPrefix, ciphertext]));\n        // See: https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition\n        const data = {\n            address: account.address.substring(2).toLowerCase(),\n            id: uuidV4(uuidRandom),\n            version: 3,\n            crypto: {\n                cipher: \"aes-128-ctr\",\n                cipherparams: {\n                    iv: hexlify(iv).substring(2),\n                },\n                ciphertext: hexlify(ciphertext).substring(2),\n                kdf: \"scrypt\",\n                kdfparams: {\n                    salt: hexlify(salt).substring(2),\n                    n: N,\n                    dklen: 32,\n                    p: p,\n                    r: r\n                },\n                mac: mac.substring(2)\n            }\n        };\n        // If we have a mnemonic, encrypt it into the JSON wallet\n        if (entropy) {\n            const mnemonicIv = randomBytes(16);\n            const mnemonicCounter = new aes.Counter(mnemonicIv);\n            const mnemonicAesCtr = new aes.ModeOfOperation.ctr(mnemonicKey, mnemonicCounter);\n            const mnemonicCiphertext = arrayify(mnemonicAesCtr.encrypt(entropy));\n            const now = new Date();\n            const timestamp = (now.getUTCFullYear() + \"-\" +\n                zpad(now.getUTCMonth() + 1, 2) + \"-\" +\n                zpad(now.getUTCDate(), 2) + \"T\" +\n                zpad(now.getUTCHours(), 2) + \"-\" +\n                zpad(now.getUTCMinutes(), 2) + \"-\" +\n                zpad(now.getUTCSeconds(), 2) + \".0Z\");\n            data[\"x-ethers\"] = {\n                client: client,\n                gethFilename: (\"UTC--\" + timestamp + \"--\" + data.address),\n                mnemonicCounter: hexlify(mnemonicIv).substring(2),\n                mnemonicCiphertext: hexlify(mnemonicCiphertext).substring(2),\n                path: path,\n                locale: locale,\n                version: \"0.1\"\n            };\n        }\n        return JSON.stringify(data);\n    });\n}\n//# sourceMappingURL=keystore.js.map","\"use strict\";\nimport aes from \"aes-js\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { pbkdf2 } from \"@ethersproject/pbkdf2\";\nimport { toUtf8Bytes } from \"@ethersproject/strings\";\nimport { Description } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { getPassword, looseArrayify, searchPath } from \"./utils\";\nexport class CrowdsaleAccount extends Description {\n    isCrowdsaleAccount(value) {\n        return !!(value && value._isCrowdsaleAccount);\n    }\n}\n// See: https://github.com/ethereum/pyethsaletool\nexport function decrypt(json, password) {\n    const data = JSON.parse(json);\n    password = getPassword(password);\n    // Ethereum Address\n    const ethaddr = getAddress(searchPath(data, \"ethaddr\"));\n    // Encrypted Seed\n    const encseed = looseArrayify(searchPath(data, \"encseed\"));\n    if (!encseed || (encseed.length % 16) !== 0) {\n        logger.throwArgumentError(\"invalid encseed\", \"json\", json);\n    }\n    const key = arrayify(pbkdf2(password, password, 2000, 32, \"sha256\")).slice(0, 16);\n    const iv = encseed.slice(0, 16);\n    const encryptedSeed = encseed.slice(16);\n    // Decrypt the seed\n    const aesCbc = new aes.ModeOfOperation.cbc(key, iv);\n    const seed = aes.padding.pkcs7.strip(arrayify(aesCbc.decrypt(encryptedSeed)));\n    // This wallet format is weird... Convert the binary encoded hex to a string.\n    let seedHex = \"\";\n    for (let i = 0; i < seed.length; i++) {\n        seedHex += String.fromCharCode(seed[i]);\n    }\n    const seedHexBytes = toUtf8Bytes(seedHex);\n    const privateKey = keccak256(seedHexBytes);\n    return new CrowdsaleAccount({\n        _isCrowdsaleAccount: true,\n        address: ethaddr,\n        privateKey: privateKey\n    });\n}\n//# sourceMappingURL=crowdsale.js.map","\"use strict\";\nimport { decrypt as decryptCrowdsale } from \"./crowdsale\";\nimport { getJsonWalletAddress, isCrowdsaleWallet, isKeystoreWallet } from \"./inspect\";\nimport { decrypt as decryptKeystore, decryptSync as decryptKeystoreSync, encrypt as encryptKeystore } from \"./keystore\";\nfunction decryptJsonWallet(json, password, progressCallback) {\n    if (isCrowdsaleWallet(json)) {\n        if (progressCallback) {\n            progressCallback(0);\n        }\n        const account = decryptCrowdsale(json, password);\n        if (progressCallback) {\n            progressCallback(1);\n        }\n        return Promise.resolve(account);\n    }\n    if (isKeystoreWallet(json)) {\n        return decryptKeystore(json, password, progressCallback);\n    }\n    return Promise.reject(new Error(\"invalid JSON wallet\"));\n}\nfunction decryptJsonWalletSync(json, password) {\n    if (isCrowdsaleWallet(json)) {\n        return decryptCrowdsale(json, password);\n    }\n    if (isKeystoreWallet(json)) {\n        return decryptKeystoreSync(json, password);\n    }\n    throw new Error(\"invalid JSON wallet\");\n}\nexport { decryptCrowdsale, decryptKeystore, decryptKeystoreSync, encryptKeystore, isCrowdsaleWallet, isKeystoreWallet, getJsonWalletAddress, decryptJsonWallet, decryptJsonWalletSync, };\n//# sourceMappingURL=index.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { getAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, hexConcat, hexlify, hexZeroPad, isHexString } from \"@ethersproject/bytes\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { deepCopy, defineReadOnly, shallowCopy } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { id } from \"./id\";\nconst padding = new Uint8Array(32);\npadding.fill(0);\nconst NegativeOne = BigNumber.from(-1);\nconst Zero = BigNumber.from(0);\nconst One = BigNumber.from(1);\nconst MaxUint256 = BigNumber.from(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\nfunction hexPadRight(value) {\n    const bytes = arrayify(value);\n    const padOffset = bytes.length % 32;\n    if (padOffset) {\n        return hexConcat([bytes, padding.slice(padOffset)]);\n    }\n    return hexlify(bytes);\n}\nconst hexTrue = hexZeroPad(One.toHexString(), 32);\nconst hexFalse = hexZeroPad(Zero.toHexString(), 32);\nconst domainFieldTypes = {\n    name: \"string\",\n    version: \"string\",\n    chainId: \"uint256\",\n    verifyingContract: \"address\",\n    salt: \"bytes32\"\n};\nconst domainFieldNames = [\n    \"name\", \"version\", \"chainId\", \"verifyingContract\", \"salt\"\n];\nfunction checkString(key) {\n    return function (value) {\n        if (typeof (value) !== \"string\") {\n            logger.throwArgumentError(`invalid domain value for ${JSON.stringify(key)}`, `domain.${key}`, value);\n        }\n        return value;\n    };\n}\nconst domainChecks = {\n    name: checkString(\"name\"),\n    version: checkString(\"version\"),\n    chainId: function (value) {\n        try {\n            return BigNumber.from(value).toString();\n        }\n        catch (error) { }\n        return logger.throwArgumentError(`invalid domain value for \"chainId\"`, \"domain.chainId\", value);\n    },\n    verifyingContract: function (value) {\n        try {\n            return getAddress(value).toLowerCase();\n        }\n        catch (error) { }\n        return logger.throwArgumentError(`invalid domain value \"verifyingContract\"`, \"domain.verifyingContract\", value);\n    },\n    salt: function (value) {\n        try {\n            const bytes = arrayify(value);\n            if (bytes.length !== 32) {\n                throw new Error(\"bad length\");\n            }\n            return hexlify(bytes);\n        }\n        catch (error) { }\n        return logger.throwArgumentError(`invalid domain value \"salt\"`, \"domain.salt\", value);\n    }\n};\nfunction getBaseEncoder(type) {\n    // intXX and uintXX\n    {\n        const match = type.match(/^(u?)int(\\d*)$/);\n        if (match) {\n            const signed = (match[1] === \"\");\n            const width = parseInt(match[2] || \"256\");\n            if (width % 8 !== 0 || width > 256 || (match[2] && match[2] !== String(width))) {\n                logger.throwArgumentError(\"invalid numeric width\", \"type\", type);\n            }\n            const boundsUpper = MaxUint256.mask(signed ? (width - 1) : width);\n            const boundsLower = signed ? boundsUpper.add(One).mul(NegativeOne) : Zero;\n            return function (value) {\n                const v = BigNumber.from(value);\n                if (v.lt(boundsLower) || v.gt(boundsUpper)) {\n                    logger.throwArgumentError(`value out-of-bounds for ${type}`, \"value\", value);\n                }\n                return hexZeroPad(v.toTwos(256).toHexString(), 32);\n            };\n        }\n    }\n    // bytesXX\n    {\n        const match = type.match(/^bytes(\\d+)$/);\n        if (match) {\n            const width = parseInt(match[1]);\n            if (width === 0 || width > 32 || match[1] !== String(width)) {\n                logger.throwArgumentError(\"invalid bytes width\", \"type\", type);\n            }\n            return function (value) {\n                const bytes = arrayify(value);\n                if (bytes.length !== width) {\n                    logger.throwArgumentError(`invalid length for ${type}`, \"value\", value);\n                }\n                return hexPadRight(value);\n            };\n        }\n    }\n    switch (type) {\n        case \"address\": return function (value) {\n            return hexZeroPad(getAddress(value), 32);\n        };\n        case \"bool\": return function (value) {\n            return ((!value) ? hexFalse : hexTrue);\n        };\n        case \"bytes\": return function (value) {\n            return keccak256(value);\n        };\n        case \"string\": return function (value) {\n            return id(value);\n        };\n    }\n    return null;\n}\nfunction encodeType(name, fields) {\n    return `${name}(${fields.map(({ name, type }) => (type + \" \" + name)).join(\",\")})`;\n}\nexport class TypedDataEncoder {\n    constructor(types) {\n        defineReadOnly(this, \"types\", Object.freeze(deepCopy(types)));\n        defineReadOnly(this, \"_encoderCache\", {});\n        defineReadOnly(this, \"_types\", {});\n        // Link struct types to their direct child structs\n        const links = {};\n        // Link structs to structs which contain them as a child\n        const parents = {};\n        // Link all subtypes within a given struct\n        const subtypes = {};\n        Object.keys(types).forEach((type) => {\n            links[type] = {};\n            parents[type] = [];\n            subtypes[type] = {};\n        });\n        for (const name in types) {\n            const uniqueNames = {};\n            types[name].forEach((field) => {\n                // Check each field has a unique name\n                if (uniqueNames[field.name]) {\n                    logger.throwArgumentError(`duplicate variable name ${JSON.stringify(field.name)} in ${JSON.stringify(name)}`, \"types\", types);\n                }\n                uniqueNames[field.name] = true;\n                // Get the base type (drop any array specifiers)\n                const baseType = field.type.match(/^([^\\x5b]*)(\\x5b|$)/)[1];\n                if (baseType === name) {\n                    logger.throwArgumentError(`circular type reference to ${JSON.stringify(baseType)}`, \"types\", types);\n                }\n                // Is this a base encoding type?\n                const encoder = getBaseEncoder(baseType);\n                if (encoder) {\n                    return;\n                }\n                if (!parents[baseType]) {\n                    logger.throwArgumentError(`unknown type ${JSON.stringify(baseType)}`, \"types\", types);\n                }\n                // Add linkage\n                parents[baseType].push(name);\n                links[name][baseType] = true;\n            });\n        }\n        // Deduce the primary type\n        const primaryTypes = Object.keys(parents).filter((n) => (parents[n].length === 0));\n        if (primaryTypes.length === 0) {\n            logger.throwArgumentError(\"missing primary type\", \"types\", types);\n        }\n        else if (primaryTypes.length > 1) {\n            logger.throwArgumentError(`ambiguous primary types or unused types: ${primaryTypes.map((t) => (JSON.stringify(t))).join(\", \")}`, \"types\", types);\n        }\n        defineReadOnly(this, \"primaryType\", primaryTypes[0]);\n        // Check for circular type references\n        function checkCircular(type, found) {\n            if (found[type]) {\n                logger.throwArgumentError(`circular type reference to ${JSON.stringify(type)}`, \"types\", types);\n            }\n            found[type] = true;\n            Object.keys(links[type]).forEach((child) => {\n                if (!parents[child]) {\n                    return;\n                }\n                // Recursively check children\n                checkCircular(child, found);\n                // Mark all ancestors as having this decendant\n                Object.keys(found).forEach((subtype) => {\n                    subtypes[subtype][child] = true;\n                });\n            });\n            delete found[type];\n        }\n        checkCircular(this.primaryType, {});\n        // Compute each fully describe type\n        for (const name in subtypes) {\n            const st = Object.keys(subtypes[name]);\n            st.sort();\n            this._types[name] = encodeType(name, types[name]) + st.map((t) => encodeType(t, types[t])).join(\"\");\n        }\n    }\n    getEncoder(type) {\n        let encoder = this._encoderCache[type];\n        if (!encoder) {\n            encoder = this._encoderCache[type] = this._getEncoder(type);\n        }\n        return encoder;\n    }\n    _getEncoder(type) {\n        // Basic encoder type (address, bool, uint256, etc)\n        {\n            const encoder = getBaseEncoder(type);\n            if (encoder) {\n                return encoder;\n            }\n        }\n        // Array\n        const match = type.match(/^(.*)(\\x5b(\\d*)\\x5d)$/);\n        if (match) {\n            const subtype = match[1];\n            const subEncoder = this.getEncoder(subtype);\n            const length = parseInt(match[3]);\n            return (value) => {\n                if (length >= 0 && value.length !== length) {\n                    logger.throwArgumentError(\"array length mismatch; expected length ${ arrayLength }\", \"value\", value);\n                }\n                let result = value.map(subEncoder);\n                if (this._types[subtype]) {\n                    result = result.map(keccak256);\n                }\n                return keccak256(hexConcat(result));\n            };\n        }\n        // Struct\n        const fields = this.types[type];\n        if (fields) {\n            const encodedType = id(this._types[type]);\n            return (value) => {\n                const values = fields.map(({ name, type }) => {\n                    const result = this.getEncoder(type)(value[name]);\n                    if (this._types[type]) {\n                        return keccak256(result);\n                    }\n                    return result;\n                });\n                values.unshift(encodedType);\n                return hexConcat(values);\n            };\n        }\n        return logger.throwArgumentError(`unknown type: ${type}`, \"type\", type);\n    }\n    encodeType(name) {\n        const result = this._types[name];\n        if (!result) {\n            logger.throwArgumentError(`unknown type: ${JSON.stringify(name)}`, \"name\", name);\n        }\n        return result;\n    }\n    encodeData(type, value) {\n        return this.getEncoder(type)(value);\n    }\n    hashStruct(name, value) {\n        return keccak256(this.encodeData(name, value));\n    }\n    encode(value) {\n        return this.encodeData(this.primaryType, value);\n    }\n    hash(value) {\n        return this.hashStruct(this.primaryType, value);\n    }\n    _visit(type, value, callback) {\n        // Basic encoder type (address, bool, uint256, etc)\n        {\n            const encoder = getBaseEncoder(type);\n            if (encoder) {\n                return callback(type, value);\n            }\n        }\n        // Array\n        const match = type.match(/^(.*)(\\x5b(\\d*)\\x5d)$/);\n        if (match) {\n            const subtype = match[1];\n            const length = parseInt(match[3]);\n            if (length >= 0 && value.length !== length) {\n                logger.throwArgumentError(\"array length mismatch; expected length ${ arrayLength }\", \"value\", value);\n            }\n            return value.map((v) => this._visit(subtype, v, callback));\n        }\n        // Struct\n        const fields = this.types[type];\n        if (fields) {\n            return fields.reduce((accum, { name, type }) => {\n                accum[name] = this._visit(type, value[name], callback);\n                return accum;\n            }, {});\n        }\n        return logger.throwArgumentError(`unknown type: ${type}`, \"type\", type);\n    }\n    visit(value, callback) {\n        return this._visit(this.primaryType, value, callback);\n    }\n    static from(types) {\n        return new TypedDataEncoder(types);\n    }\n    static getPrimaryType(types) {\n        return TypedDataEncoder.from(types).primaryType;\n    }\n    static hashStruct(name, types, value) {\n        return TypedDataEncoder.from(types).hashStruct(name, value);\n    }\n    static hashDomain(domain) {\n        const domainFields = [];\n        for (const name in domain) {\n            const type = domainFieldTypes[name];\n            if (!type) {\n                logger.throwArgumentError(`invalid typed-data domain key: ${JSON.stringify(name)}`, \"domain\", domain);\n            }\n            domainFields.push({ name, type });\n        }\n        domainFields.sort((a, b) => {\n            return domainFieldNames.indexOf(a.name) - domainFieldNames.indexOf(b.name);\n        });\n        return TypedDataEncoder.hashStruct(\"EIP712Domain\", { EIP712Domain: domainFields }, domain);\n    }\n    static encode(domain, types, value) {\n        return hexConcat([\n            \"0x1901\",\n            TypedDataEncoder.hashDomain(domain),\n            TypedDataEncoder.from(types).hash(value)\n        ]);\n    }\n    static hash(domain, types, value) {\n        return keccak256(TypedDataEncoder.encode(domain, types, value));\n    }\n    // Replaces all address types with ENS names with their looked up address\n    static resolveNames(domain, types, value, resolveName) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Make a copy to isolate it from the object passed in\n            domain = shallowCopy(domain);\n            // Look up all ENS names\n            const ensCache = {};\n            // Do we need to look up the domain's verifyingContract?\n            if (domain.verifyingContract && !isHexString(domain.verifyingContract, 20)) {\n                ensCache[domain.verifyingContract] = \"0x\";\n            }\n            // We are going to use the encoder to visit all the base values\n            const encoder = TypedDataEncoder.from(types);\n            // Get a list of all the addresses\n            encoder.visit(value, (type, value) => {\n                if (type === \"address\" && !isHexString(value, 20)) {\n                    ensCache[value] = \"0x\";\n                }\n                return value;\n            });\n            // Lookup each name\n            for (const name in ensCache) {\n                ensCache[name] = yield resolveName(name);\n            }\n            // Replace the domain verifyingContract if needed\n            if (domain.verifyingContract && ensCache[domain.verifyingContract]) {\n                domain.verifyingContract = ensCache[domain.verifyingContract];\n            }\n            // Replace all ENS names with their address\n            value = encoder.visit(value, (type, value) => {\n                if (type === \"address\" && ensCache[value]) {\n                    return ensCache[value];\n                }\n                return value;\n            });\n            return { domain, value };\n        });\n    }\n    static getPayload(domain, types, value) {\n        // Validate the domain fields\n        TypedDataEncoder.hashDomain(domain);\n        // Derive the EIP712Domain Struct reference type\n        const domainValues = {};\n        const domainTypes = [];\n        domainFieldNames.forEach((name) => {\n            const value = domain[name];\n            if (value == null) {\n                return;\n            }\n            domainValues[name] = domainChecks[name](value);\n            domainTypes.push({ name, type: domainFieldTypes[name] });\n        });\n        const encoder = TypedDataEncoder.from(types);\n        const typesWithDomain = shallowCopy(types);\n        if (typesWithDomain.EIP712Domain) {\n            logger.throwArgumentError(\"types must not contain EIP712Domain type\", \"types.EIP712Domain\", types);\n        }\n        else {\n            typesWithDomain.EIP712Domain = domainTypes;\n        }\n        // Validate the data structures and types\n        encoder.encode(value);\n        return {\n            types: typesWithDomain,\n            domain: domainValues,\n            primaryType: encoder.primaryType,\n            message: encoder.visit(value, (type, value) => {\n                // bytes\n                if (type.match(/^bytes(\\d*)/)) {\n                    return hexlify(arrayify(value));\n                }\n                // uint or int\n                if (type.match(/^u?int/)) {\n                    return BigNumber.from(value).toString();\n                }\n                switch (type) {\n                    case \"address\":\n                        return value.toLowerCase();\n                    case \"bool\":\n                        return !!value;\n                    case \"string\":\n                        if (typeof (value) !== \"string\") {\n                            logger.throwArgumentError(`invalid string`, \"value\", value);\n                        }\n                        return value;\n                }\n                return logger.throwArgumentError(\"unsupported type\", \"type\", type);\n            })\n        };\n    }\n}\n//# sourceMappingURL=typed-data.js.map","export const version = \"hdnode/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { Base58 } from \"@ethersproject/basex\";\nimport { arrayify, concat, hexDataSlice, hexZeroPad, hexlify } from \"@ethersproject/bytes\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { toUtf8Bytes, UnicodeNormalizationForm } from \"@ethersproject/strings\";\nimport { pbkdf2 } from \"@ethersproject/pbkdf2\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { SigningKey } from \"@ethersproject/signing-key\";\nimport { computeHmac, ripemd160, sha256, SupportedAlgorithm } from \"@ethersproject/sha2\";\nimport { computeAddress } from \"@ethersproject/transactions\";\nimport { wordlists } from \"@ethersproject/wordlists\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nconst N = BigNumber.from(\"0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141\");\n// \"Bitcoin seed\"\nconst MasterSecret = toUtf8Bytes(\"Bitcoin seed\");\nconst HardenedBit = 0x80000000;\n// Returns a byte with the MSB bits set\nfunction getUpperMask(bits) {\n    return ((1 << bits) - 1) << (8 - bits);\n}\n// Returns a byte with the LSB bits set\nfunction getLowerMask(bits) {\n    return (1 << bits) - 1;\n}\nfunction bytes32(value) {\n    return hexZeroPad(hexlify(value), 32);\n}\nfunction base58check(data) {\n    return Base58.encode(concat([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));\n}\nfunction getWordlist(wordlist) {\n    if (wordlist == null) {\n        return wordlists[\"en\"];\n    }\n    if (typeof (wordlist) === \"string\") {\n        const words = wordlists[wordlist];\n        if (words == null) {\n            logger.throwArgumentError(\"unknown locale\", \"wordlist\", wordlist);\n        }\n        return words;\n    }\n    return wordlist;\n}\nconst _constructorGuard = {};\nexport const defaultPath = \"m/44'/60'/0'/0/0\";\n;\nexport class HDNode {\n    /**\n     *  This constructor should not be called directly.\n     *\n     *  Please use:\n     *   - fromMnemonic\n     *   - fromSeed\n     */\n    constructor(constructorGuard, privateKey, publicKey, parentFingerprint, chainCode, index, depth, mnemonicOrPath) {\n        /* istanbul ignore if */\n        if (constructorGuard !== _constructorGuard) {\n            throw new Error(\"HDNode constructor cannot be called directly\");\n        }\n        if (privateKey) {\n            const signingKey = new SigningKey(privateKey);\n            defineReadOnly(this, \"privateKey\", signingKey.privateKey);\n            defineReadOnly(this, \"publicKey\", signingKey.compressedPublicKey);\n        }\n        else {\n            defineReadOnly(this, \"privateKey\", null);\n            defineReadOnly(this, \"publicKey\", hexlify(publicKey));\n        }\n        defineReadOnly(this, \"parentFingerprint\", parentFingerprint);\n        defineReadOnly(this, \"fingerprint\", hexDataSlice(ripemd160(sha256(this.publicKey)), 0, 4));\n        defineReadOnly(this, \"address\", computeAddress(this.publicKey));\n        defineReadOnly(this, \"chainCode\", chainCode);\n        defineReadOnly(this, \"index\", index);\n        defineReadOnly(this, \"depth\", depth);\n        if (mnemonicOrPath == null) {\n            // From a source that does not preserve the path (e.g. extended keys)\n            defineReadOnly(this, \"mnemonic\", null);\n            defineReadOnly(this, \"path\", null);\n        }\n        else if (typeof (mnemonicOrPath) === \"string\") {\n            // From a source that does not preserve the mnemonic (e.g. neutered)\n            defineReadOnly(this, \"mnemonic\", null);\n            defineReadOnly(this, \"path\", mnemonicOrPath);\n        }\n        else {\n            // From a fully qualified source\n            defineReadOnly(this, \"mnemonic\", mnemonicOrPath);\n            defineReadOnly(this, \"path\", mnemonicOrPath.path);\n        }\n    }\n    get extendedKey() {\n        // We only support the mainnet values for now, but if anyone needs\n        // testnet values, let me know. I believe current sentiment is that\n        // we should always use mainnet, and use BIP-44 to derive the network\n        //   - Mainnet: public=0x0488B21E, private=0x0488ADE4\n        //   - Testnet: public=0x043587CF, private=0x04358394\n        if (this.depth >= 256) {\n            throw new Error(\"Depth too large!\");\n        }\n        return base58check(concat([\n            ((this.privateKey != null) ? \"0x0488ADE4\" : \"0x0488B21E\"),\n            hexlify(this.depth),\n            this.parentFingerprint,\n            hexZeroPad(hexlify(this.index), 4),\n            this.chainCode,\n            ((this.privateKey != null) ? concat([\"0x00\", this.privateKey]) : this.publicKey),\n        ]));\n    }\n    neuter() {\n        return new HDNode(_constructorGuard, null, this.publicKey, this.parentFingerprint, this.chainCode, this.index, this.depth, this.path);\n    }\n    _derive(index) {\n        if (index > 0xffffffff) {\n            throw new Error(\"invalid index - \" + String(index));\n        }\n        // Base path\n        let path = this.path;\n        if (path) {\n            path += \"/\" + (index & ~HardenedBit);\n        }\n        const data = new Uint8Array(37);\n        if (index & HardenedBit) {\n            if (!this.privateKey) {\n                throw new Error(\"cannot derive child of neutered node\");\n            }\n            // Data = 0x00 || ser_256(k_par)\n            data.set(arrayify(this.privateKey), 1);\n            // Hardened path\n            if (path) {\n                path += \"'\";\n            }\n        }\n        else {\n            // Data = ser_p(point(k_par))\n            data.set(arrayify(this.publicKey));\n        }\n        // Data += ser_32(i)\n        for (let i = 24; i >= 0; i -= 8) {\n            data[33 + (i >> 3)] = ((index >> (24 - i)) & 0xff);\n        }\n        const I = arrayify(computeHmac(SupportedAlgorithm.sha512, this.chainCode, data));\n        const IL = I.slice(0, 32);\n        const IR = I.slice(32);\n        // The private key\n        let ki = null;\n        // The public key\n        let Ki = null;\n        if (this.privateKey) {\n            ki = bytes32(BigNumber.from(IL).add(this.privateKey).mod(N));\n        }\n        else {\n            const ek = new SigningKey(hexlify(IL));\n            Ki = ek._addPoint(this.publicKey);\n        }\n        let mnemonicOrPath = path;\n        const srcMnemonic = this.mnemonic;\n        if (srcMnemonic) {\n            mnemonicOrPath = Object.freeze({\n                phrase: srcMnemonic.phrase,\n                path: path,\n                locale: (srcMnemonic.locale || \"en\")\n            });\n        }\n        return new HDNode(_constructorGuard, ki, Ki, this.fingerprint, bytes32(IR), index, this.depth + 1, mnemonicOrPath);\n    }\n    derivePath(path) {\n        const components = path.split(\"/\");\n        if (components.length === 0 || (components[0] === \"m\" && this.depth !== 0)) {\n            throw new Error(\"invalid path - \" + path);\n        }\n        if (components[0] === \"m\") {\n            components.shift();\n        }\n        let result = this;\n        for (let i = 0; i < components.length; i++) {\n            const component = components[i];\n            if (component.match(/^[0-9]+'$/)) {\n                const index = parseInt(component.substring(0, component.length - 1));\n                if (index >= HardenedBit) {\n                    throw new Error(\"invalid path index - \" + component);\n                }\n                result = result._derive(HardenedBit + index);\n            }\n            else if (component.match(/^[0-9]+$/)) {\n                const index = parseInt(component);\n                if (index >= HardenedBit) {\n                    throw new Error(\"invalid path index - \" + component);\n                }\n                result = result._derive(index);\n            }\n            else {\n                throw new Error(\"invalid path component - \" + component);\n            }\n        }\n        return result;\n    }\n    static _fromSeed(seed, mnemonic) {\n        const seedArray = arrayify(seed);\n        if (seedArray.length < 16 || seedArray.length > 64) {\n            throw new Error(\"invalid seed\");\n        }\n        const I = arrayify(computeHmac(SupportedAlgorithm.sha512, MasterSecret, seedArray));\n        return new HDNode(_constructorGuard, bytes32(I.slice(0, 32)), null, \"0x00000000\", bytes32(I.slice(32)), 0, 0, mnemonic);\n    }\n    static fromMnemonic(mnemonic, password, wordlist) {\n        // If a locale name was passed in, find the associated wordlist\n        wordlist = getWordlist(wordlist);\n        // Normalize the case and spacing in the mnemonic (throws if the mnemonic is invalid)\n        mnemonic = entropyToMnemonic(mnemonicToEntropy(mnemonic, wordlist), wordlist);\n        return HDNode._fromSeed(mnemonicToSeed(mnemonic, password), {\n            phrase: mnemonic,\n            path: \"m\",\n            locale: wordlist.locale\n        });\n    }\n    static fromSeed(seed) {\n        return HDNode._fromSeed(seed, null);\n    }\n    static fromExtendedKey(extendedKey) {\n        const bytes = Base58.decode(extendedKey);\n        if (bytes.length !== 82 || base58check(bytes.slice(0, 78)) !== extendedKey) {\n            logger.throwArgumentError(\"invalid extended key\", \"extendedKey\", \"[REDACTED]\");\n        }\n        const depth = bytes[4];\n        const parentFingerprint = hexlify(bytes.slice(5, 9));\n        const index = parseInt(hexlify(bytes.slice(9, 13)).substring(2), 16);\n        const chainCode = hexlify(bytes.slice(13, 45));\n        const key = bytes.slice(45, 78);\n        switch (hexlify(bytes.slice(0, 4))) {\n            // Public Key\n            case \"0x0488b21e\":\n            case \"0x043587cf\":\n                return new HDNode(_constructorGuard, null, hexlify(key), parentFingerprint, chainCode, index, depth, null);\n            // Private Key\n            case \"0x0488ade4\":\n            case \"0x04358394 \":\n                if (key[0] !== 0) {\n                    break;\n                }\n                return new HDNode(_constructorGuard, hexlify(key.slice(1)), null, parentFingerprint, chainCode, index, depth, null);\n        }\n        return logger.throwArgumentError(\"invalid extended key\", \"extendedKey\", \"[REDACTED]\");\n    }\n}\nexport function mnemonicToSeed(mnemonic, password) {\n    if (!password) {\n        password = \"\";\n    }\n    const salt = toUtf8Bytes(\"mnemonic\" + password, UnicodeNormalizationForm.NFKD);\n    return pbkdf2(toUtf8Bytes(mnemonic, UnicodeNormalizationForm.NFKD), salt, 2048, 64, \"sha512\");\n}\nexport function mnemonicToEntropy(mnemonic, wordlist) {\n    wordlist = getWordlist(wordlist);\n    logger.checkNormalize();\n    const words = wordlist.split(mnemonic);\n    if ((words.length % 3) !== 0) {\n        throw new Error(\"invalid mnemonic\");\n    }\n    const entropy = arrayify(new Uint8Array(Math.ceil(11 * words.length / 8)));\n    let offset = 0;\n    for (let i = 0; i < words.length; i++) {\n        let index = wordlist.getWordIndex(words[i].normalize(\"NFKD\"));\n        if (index === -1) {\n            throw new Error(\"invalid mnemonic\");\n        }\n        for (let bit = 0; bit < 11; bit++) {\n            if (index & (1 << (10 - bit))) {\n                entropy[offset >> 3] |= (1 << (7 - (offset % 8)));\n            }\n            offset++;\n        }\n    }\n    const entropyBits = 32 * words.length / 3;\n    const checksumBits = words.length / 3;\n    const checksumMask = getUpperMask(checksumBits);\n    const checksum = arrayify(sha256(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;\n    if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {\n        throw new Error(\"invalid checksum\");\n    }\n    return hexlify(entropy.slice(0, entropyBits / 8));\n}\nexport function entropyToMnemonic(entropy, wordlist) {\n    wordlist = getWordlist(wordlist);\n    entropy = arrayify(entropy);\n    if ((entropy.length % 4) !== 0 || entropy.length < 16 || entropy.length > 32) {\n        throw new Error(\"invalid entropy\");\n    }\n    const indices = [0];\n    let remainingBits = 11;\n    for (let i = 0; i < entropy.length; i++) {\n        // Consume the whole byte (with still more to go)\n        if (remainingBits > 8) {\n            indices[indices.length - 1] <<= 8;\n            indices[indices.length - 1] |= entropy[i];\n            remainingBits -= 8;\n            // This byte will complete an 11-bit index\n        }\n        else {\n            indices[indices.length - 1] <<= remainingBits;\n            indices[indices.length - 1] |= entropy[i] >> (8 - remainingBits);\n            // Start the next word\n            indices.push(entropy[i] & getLowerMask(8 - remainingBits));\n            remainingBits += 3;\n        }\n    }\n    // Compute the checksum bits\n    const checksumBits = entropy.length / 4;\n    const checksum = arrayify(sha256(entropy))[0] & getUpperMask(checksumBits);\n    // Shift the checksum into the word indices\n    indices[indices.length - 1] <<= checksumBits;\n    indices[indices.length - 1] |= (checksum >> (8 - checksumBits));\n    return wordlist.join(indices.map((index) => wordlist.getWord(index)));\n}\nexport function isValidMnemonic(mnemonic, wordlist) {\n    try {\n        mnemonicToEntropy(mnemonic, wordlist);\n        return true;\n    }\n    catch (error) { }\n    return false;\n}\nexport function getAccountPath(index) {\n    if (typeof (index) !== \"number\" || index < 0 || index >= HardenedBit || index % 1) {\n        logger.throwArgumentError(\"invalid account index\", \"index\", index);\n    }\n    return `m/44'/60'/${index}'/0/0`;\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\nimport { arrayify, hexlify } from \"@ethersproject/bytes\";\nimport { toUtf8Bytes, UnicodeNormalizationForm } from '@ethersproject/strings';\nexport function looseArrayify(hexString) {\n    if (typeof (hexString) === 'string' && hexString.substring(0, 2) !== '0x') {\n        hexString = '0x' + hexString;\n    }\n    return arrayify(hexString);\n}\nexport function zpad(value, length) {\n    value = String(value);\n    while (value.length < length) {\n        value = '0' + value;\n    }\n    return value;\n}\nexport function getPassword(password) {\n    if (typeof (password) === 'string') {\n        return toUtf8Bytes(password, UnicodeNormalizationForm.NFKC);\n    }\n    return arrayify(password);\n}\nexport function searchPath(object, path) {\n    let currentChild = object;\n    const comps = path.toLowerCase().split('/');\n    for (let i = 0; i < comps.length; i++) {\n        // Search for a child object with a case-insensitive matching key\n        let matchingChild = null;\n        for (const key in currentChild) {\n            if (key.toLowerCase() === comps[i]) {\n                matchingChild = currentChild[key];\n                break;\n            }\n        }\n        // Didn't find one. :'(\n        if (matchingChild === null) {\n            return null;\n        }\n        // Now check this child...\n        currentChild = matchingChild;\n    }\n    return currentChild;\n}\n// See: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)\nexport function uuidV4(randomBytes) {\n    const bytes = arrayify(randomBytes);\n    // Section: 4.1.3:\n    // - time_hi_and_version[12:16] = 0b0100\n    bytes[6] = (bytes[6] & 0x0f) | 0x40;\n    // Section 4.4\n    // - clock_seq_hi_and_reserved[6] = 0b0\n    // - clock_seq_hi_and_reserved[7] = 0b1\n    bytes[8] = (bytes[8] & 0x3f) | 0x80;\n    const value = hexlify(bytes);\n    return [\n        value.substring(2, 10),\n        value.substring(10, 14),\n        value.substring(14, 18),\n        value.substring(18, 22),\n        value.substring(22, 34),\n    ].join(\"-\");\n}\n//# sourceMappingURL=utils.js.map","\"use strict\";\nlet _permanentCensorErrors = false;\nlet _censorErrors = false;\nconst LogLevels = { debug: 1, \"default\": 2, info: 2, warning: 3, error: 4, off: 5 };\nlet _logLevel = LogLevels[\"default\"];\nimport { version } from \"./_version\";\nlet _globalLogger = null;\nfunction _checkNormalize() {\n    try {\n        const missing = [];\n        // Make sure all forms of normalization are supported\n        [\"NFD\", \"NFC\", \"NFKD\", \"NFKC\"].forEach((form) => {\n            try {\n                if (\"test\".normalize(form) !== \"test\") {\n                    throw new Error(\"bad normalize\");\n                }\n                ;\n            }\n            catch (error) {\n                missing.push(form);\n            }\n        });\n        if (missing.length) {\n            throw new Error(\"missing \" + missing.join(\", \"));\n        }\n        if (String.fromCharCode(0xe9).normalize(\"NFD\") !== String.fromCharCode(0x65, 0x0301)) {\n            throw new Error(\"broken implementation\");\n        }\n    }\n    catch (error) {\n        return error.message;\n    }\n    return null;\n}\nconst _normalizeError = _checkNormalize();\nexport var LogLevel;\n(function (LogLevel) {\n    LogLevel[\"DEBUG\"] = \"DEBUG\";\n    LogLevel[\"INFO\"] = \"INFO\";\n    LogLevel[\"WARNING\"] = \"WARNING\";\n    LogLevel[\"ERROR\"] = \"ERROR\";\n    LogLevel[\"OFF\"] = \"OFF\";\n})(LogLevel || (LogLevel = {}));\nexport var ErrorCode;\n(function (ErrorCode) {\n    ///////////////////\n    // Generic Errors\n    // Unknown Error\n    ErrorCode[\"UNKNOWN_ERROR\"] = \"UNKNOWN_ERROR\";\n    // Not Implemented\n    ErrorCode[\"NOT_IMPLEMENTED\"] = \"NOT_IMPLEMENTED\";\n    // Unsupported Operation\n    //   - operation\n    ErrorCode[\"UNSUPPORTED_OPERATION\"] = \"UNSUPPORTED_OPERATION\";\n    // Network Error (i.e. Ethereum Network, such as an invalid chain ID)\n    //   - event (\"noNetwork\" is not re-thrown in provider.ready; otherwise thrown)\n    ErrorCode[\"NETWORK_ERROR\"] = \"NETWORK_ERROR\";\n    // Some sort of bad response from the server\n    ErrorCode[\"SERVER_ERROR\"] = \"SERVER_ERROR\";\n    // Timeout\n    ErrorCode[\"TIMEOUT\"] = \"TIMEOUT\";\n    ///////////////////\n    // Operational  Errors\n    // Buffer Overrun\n    ErrorCode[\"BUFFER_OVERRUN\"] = \"BUFFER_OVERRUN\";\n    // Numeric Fault\n    //   - operation: the operation being executed\n    //   - fault: the reason this faulted\n    ErrorCode[\"NUMERIC_FAULT\"] = \"NUMERIC_FAULT\";\n    ///////////////////\n    // Argument Errors\n    // Missing new operator to an object\n    //  - name: The name of the class\n    ErrorCode[\"MISSING_NEW\"] = \"MISSING_NEW\";\n    // Invalid argument (e.g. value is incompatible with type) to a function:\n    //   - argument: The argument name that was invalid\n    //   - value: The value of the argument\n    ErrorCode[\"INVALID_ARGUMENT\"] = \"INVALID_ARGUMENT\";\n    // Missing argument to a function:\n    //   - count: The number of arguments received\n    //   - expectedCount: The number of arguments expected\n    ErrorCode[\"MISSING_ARGUMENT\"] = \"MISSING_ARGUMENT\";\n    // Too many arguments\n    //   - count: The number of arguments received\n    //   - expectedCount: The number of arguments expected\n    ErrorCode[\"UNEXPECTED_ARGUMENT\"] = \"UNEXPECTED_ARGUMENT\";\n    ///////////////////\n    // Blockchain Errors\n    // Call exception\n    //  - transaction: the transaction\n    //  - address?: the contract address\n    //  - args?: The arguments passed into the function\n    //  - method?: The Solidity method signature\n    //  - errorSignature?: The EIP848 error signature\n    //  - errorArgs?: The EIP848 error parameters\n    //  - reason: The reason (only for EIP848 \"Error(string)\")\n    ErrorCode[\"CALL_EXCEPTION\"] = \"CALL_EXCEPTION\";\n    // Insufficient funds (< value + gasLimit * gasPrice)\n    //   - transaction: the transaction attempted\n    ErrorCode[\"INSUFFICIENT_FUNDS\"] = \"INSUFFICIENT_FUNDS\";\n    // Nonce has already been used\n    //   - transaction: the transaction attempted\n    ErrorCode[\"NONCE_EXPIRED\"] = \"NONCE_EXPIRED\";\n    // The replacement fee for the transaction is too low\n    //   - transaction: the transaction attempted\n    ErrorCode[\"REPLACEMENT_UNDERPRICED\"] = \"REPLACEMENT_UNDERPRICED\";\n    // The gas limit could not be estimated\n    //   - transaction: the transaction passed to estimateGas\n    ErrorCode[\"UNPREDICTABLE_GAS_LIMIT\"] = \"UNPREDICTABLE_GAS_LIMIT\";\n    // The transaction was replaced by one with a higher gas price\n    //   - reason: \"cancelled\", \"replaced\" or \"repriced\"\n    //   - cancelled: true if reason == \"cancelled\" or reason == \"replaced\")\n    //   - hash: original transaction hash\n    //   - replacement: the full TransactionsResponse for the replacement\n    //   - receipt: the receipt of the replacement\n    ErrorCode[\"TRANSACTION_REPLACED\"] = \"TRANSACTION_REPLACED\";\n    ///////////////////\n    // Interaction Errors\n    // The user rejected the action, such as signing a message or sending\n    // a transaction\n    ErrorCode[\"ACTION_REJECTED\"] = \"ACTION_REJECTED\";\n})(ErrorCode || (ErrorCode = {}));\n;\nconst HEX = \"0123456789abcdef\";\nexport class Logger {\n    constructor(version) {\n        Object.defineProperty(this, \"version\", {\n            enumerable: true,\n            value: version,\n            writable: false\n        });\n    }\n    _log(logLevel, args) {\n        const level = logLevel.toLowerCase();\n        if (LogLevels[level] == null) {\n            this.throwArgumentError(\"invalid log level name\", \"logLevel\", logLevel);\n        }\n        if (_logLevel > LogLevels[level]) {\n            return;\n        }\n        console.log.apply(console, args);\n    }\n    debug(...args) {\n        this._log(Logger.levels.DEBUG, args);\n    }\n    info(...args) {\n        this._log(Logger.levels.INFO, args);\n    }\n    warn(...args) {\n        this._log(Logger.levels.WARNING, args);\n    }\n    makeError(message, code, params) {\n        // Errors are being censored\n        if (_censorErrors) {\n            return this.makeError(\"censored error\", code, {});\n        }\n        if (!code) {\n            code = Logger.errors.UNKNOWN_ERROR;\n        }\n        if (!params) {\n            params = {};\n        }\n        const messageDetails = [];\n        Object.keys(params).forEach((key) => {\n            const value = params[key];\n            try {\n                if (value instanceof Uint8Array) {\n                    let hex = \"\";\n                    for (let i = 0; i < value.length; i++) {\n                        hex += HEX[value[i] >> 4];\n                        hex += HEX[value[i] & 0x0f];\n                    }\n                    messageDetails.push(key + \"=Uint8Array(0x\" + hex + \")\");\n                }\n                else {\n                    messageDetails.push(key + \"=\" + JSON.stringify(value));\n                }\n            }\n            catch (error) {\n                messageDetails.push(key + \"=\" + JSON.stringify(params[key].toString()));\n            }\n        });\n        messageDetails.push(`code=${code}`);\n        messageDetails.push(`version=${this.version}`);\n        const reason = message;\n        let url = \"\";\n        switch (code) {\n            case ErrorCode.NUMERIC_FAULT: {\n                url = \"NUMERIC_FAULT\";\n                const fault = message;\n                switch (fault) {\n                    case \"overflow\":\n                    case \"underflow\":\n                    case \"division-by-zero\":\n                        url += \"-\" + fault;\n                        break;\n                    case \"negative-power\":\n                    case \"negative-width\":\n                        url += \"-unsupported\";\n                        break;\n                    case \"unbound-bitwise-result\":\n                        url += \"-unbound-result\";\n                        break;\n                }\n                break;\n            }\n            case ErrorCode.CALL_EXCEPTION:\n            case ErrorCode.INSUFFICIENT_FUNDS:\n            case ErrorCode.MISSING_NEW:\n            case ErrorCode.NONCE_EXPIRED:\n            case ErrorCode.REPLACEMENT_UNDERPRICED:\n            case ErrorCode.TRANSACTION_REPLACED:\n            case ErrorCode.UNPREDICTABLE_GAS_LIMIT:\n                url = code;\n                break;\n        }\n        if (url) {\n            message += \" [ See: https:/\\/links.ethers.org/v5-errors-\" + url + \" ]\";\n        }\n        if (messageDetails.length) {\n            message += \" (\" + messageDetails.join(\", \") + \")\";\n        }\n        // @TODO: Any??\n        const error = new Error(message);\n        error.reason = reason;\n        error.code = code;\n        Object.keys(params).forEach(function (key) {\n            error[key] = params[key];\n        });\n        return error;\n    }\n    throwError(message, code, params) {\n        throw this.makeError(message, code, params);\n    }\n    throwArgumentError(message, name, value) {\n        return this.throwError(message, Logger.errors.INVALID_ARGUMENT, {\n            argument: name,\n            value: value\n        });\n    }\n    assert(condition, message, code, params) {\n        if (!!condition) {\n            return;\n        }\n        this.throwError(message, code, params);\n    }\n    assertArgument(condition, message, name, value) {\n        if (!!condition) {\n            return;\n        }\n        this.throwArgumentError(message, name, value);\n    }\n    checkNormalize(message) {\n        if (message == null) {\n            message = \"platform missing String.prototype.normalize\";\n        }\n        if (_normalizeError) {\n            this.throwError(\"platform missing String.prototype.normalize\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"String.prototype.normalize\", form: _normalizeError\n            });\n        }\n    }\n    checkSafeUint53(value, message) {\n        if (typeof (value) !== \"number\") {\n            return;\n        }\n        if (message == null) {\n            message = \"value not safe\";\n        }\n        if (value < 0 || value >= 0x1fffffffffffff) {\n            this.throwError(message, Logger.errors.NUMERIC_FAULT, {\n                operation: \"checkSafeInteger\",\n                fault: \"out-of-safe-range\",\n                value: value\n            });\n        }\n        if (value % 1) {\n            this.throwError(message, Logger.errors.NUMERIC_FAULT, {\n                operation: \"checkSafeInteger\",\n                fault: \"non-integer\",\n                value: value\n            });\n        }\n    }\n    checkArgumentCount(count, expectedCount, message) {\n        if (message) {\n            message = \": \" + message;\n        }\n        else {\n            message = \"\";\n        }\n        if (count < expectedCount) {\n            this.throwError(\"missing argument\" + message, Logger.errors.MISSING_ARGUMENT, {\n                count: count,\n                expectedCount: expectedCount\n            });\n        }\n        if (count > expectedCount) {\n            this.throwError(\"too many arguments\" + message, Logger.errors.UNEXPECTED_ARGUMENT, {\n                count: count,\n                expectedCount: expectedCount\n            });\n        }\n    }\n    checkNew(target, kind) {\n        if (target === Object || target == null) {\n            this.throwError(\"missing new\", Logger.errors.MISSING_NEW, { name: kind.name });\n        }\n    }\n    checkAbstract(target, kind) {\n        if (target === kind) {\n            this.throwError(\"cannot instantiate abstract class \" + JSON.stringify(kind.name) + \" directly; use a sub-class\", Logger.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: \"new\" });\n        }\n        else if (target === Object || target == null) {\n            this.throwError(\"missing new\", Logger.errors.MISSING_NEW, { name: kind.name });\n        }\n    }\n    static globalLogger() {\n        if (!_globalLogger) {\n            _globalLogger = new Logger(version);\n        }\n        return _globalLogger;\n    }\n    static setCensorship(censorship, permanent) {\n        if (!censorship && permanent) {\n            this.globalLogger().throwError(\"cannot permanently disable censorship\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"setCensorship\"\n            });\n        }\n        if (_permanentCensorErrors) {\n            if (!censorship) {\n                return;\n            }\n            this.globalLogger().throwError(\"error censorship permanent\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"setCensorship\"\n            });\n        }\n        _censorErrors = !!censorship;\n        _permanentCensorErrors = !!permanent;\n    }\n    static setLogLevel(logLevel) {\n        const level = LogLevels[logLevel.toLowerCase()];\n        if (level == null) {\n            Logger.globalLogger().warn(\"invalid log level - \" + logLevel);\n            return;\n        }\n        _logLevel = level;\n    }\n    static from(version) {\n        return new Logger(version);\n    }\n}\nLogger.errors = ErrorCode;\nLogger.levels = LogLevel;\n//# sourceMappingURL=index.js.map"],"sourceRoot":""}