{"version":3,"sources":["webpack:///./node_modules/@ethersproject/hash/lib.esm/namehash.js","webpack:///./node_modules/@ethersproject/bignumber/lib.esm/fixednumber.js","webpack:///./node_modules/@ethersproject/hash/lib.esm/id.js","webpack:///./node_modules/@ethersproject/constants/lib.esm/hashes.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/bytes/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/bytes/lib.esm/index.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/constants/lib.esm/bignumbers.js","webpack:///./node_modules/@ethersproject/bignumber/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/constants/lib.esm/strings.js","webpack:///./node_modules/@ethersproject/constants/lib.esm/addresses.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/bignumber/lib.esm/bignumber.js","webpack:///./node_modules/@ethersproject/hdnode/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/hdnode/lib.esm/index.js","webpack:///./node_modules/@ethersproject/contracts/lib.esm/index.js","webpack:///./node_modules/@ethersproject/contracts/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/json-wallets/lib.esm/utils.js","webpack:///./node_modules/@ethersproject/logger/lib.esm/index.js","webpack:///./node_modules/@ethersproject/logger/lib.esm/_version.js"],"names":["i","logger","Zeros","Uint8Array","fill","Partition","RegExp","isValidName","name","comps","split","length","Error","error","namehash","throwArgumentError","current","result","partition","match","label","dnsEncode","map","comp","bytes","_constructorGuard","Zero","from","NegativeOne","throwFault","message","fault","operation","value","params","throwError","errors","NUMERIC_FAULT","zeros","getMultiplier","decimals","toNumber","e","substring","formatFixed","multiplier","negative","lt","mul","fraction","mod","toString","whole","div","parseFixed","wholeValue","fractionValue","wei","add","FixedFormat","constructor","constructorGuard","signed","width","UNSUPPORTED_OPERATION","this","String","_multiplier","Object","freeze","static","parseInt","check","key","type","defaultValue","FixedNumber","hex","format","checkNew","_hex","_value","_isFixedNumber","_checkFormat","other","addUnsafe","a","b","fromValue","subUnsafe","sub","mulUnsafe","divUnsafe","floor","push","hasFraction","isNegative","ONE","toFormat","ceiling","round","factor","bump","BUMP","isZero","toHexString","fromTwos","toTwos","toUnsafeFloat","parseFloat","fromString","fixedFormat","numeric","decimal","fromBytes","code","INVALID_ARGUMENT","id","text","HashZero","version","isHexable","addSlice","array","slice","args","Array","prototype","call","arguments","apply","isBytesLike","isHexString","isBytes","isInteger","v","arrayify","options","checkSafeUint53","unshift","allowMissingPrefix","hexPad","concat","items","objects","item","reduce","accum","offset","object","set","stripZeros","start","zeroPad","HexCharacters","hexlify","Math","toLowerCase","hexDataLength","data","hexDataSlice","endOffset","hexConcat","forEach","hexValue","trimmed","hexStripZeros","hexZeroPad","splitSignature","signature","r","s","_vs","recoveryParam","yParityAndS","compact","vs","recId","joinSignature","isCrowdsaleWallet","json","JSON","parse","encseed","ethaddr","isKeystoreWallet","getJsonWalletAddress","address","keccak256","keccak_256","hashMessage","hasMnemonic","mnemonic","phrase","KeystoreAccount","isKeystoreAccount","_isKeystoreAccount","_getAccount","ciphertext","privateKey","iv","counter","Counter","aesCtr","ModeOfOperation","ctr","decrypt","_decrypt","mnemonicKey","account","mnemonicCiphertext","mnemonicIv","mnemonicCounter","mnemonicAesCtr","path","locale","entropy","node","fromMnemonic","derivePath","argument","pbkdf2Sync","passwordBytes","salt","count","dkLen","prfFunc","pbkdf2","Promise","resolve","_computeKdfKey","password","pbkdf2Func","scryptFunc","progressCallback","kdf","N","p","prf","decryptSync","syncScrypt","thisArg","_arguments","P","generator","adopt","reject","fulfilled","step","next","rejected","done","then","__awaiter","scrypt","encrypt","srcMnemonic","client","uuidRandom","uuid","derivedKey","macPrefix","mac","Crypto","cipher","cipherparams","kdfparams","n","dklen","now","Date","timestamp","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","gethFilename","stringify","One","Two","WeiPerEther","MaxUint256","MinInt256","MaxInt256","EtherSymbol","AddressZero","isCrowdsaleAccount","_isCrowdsaleAccount","encryptedSeed","aesCbc","cbc","seed","padding","pkcs7","strip","seedHex","fromCharCode","seedHexBytes","decryptJsonWallet","decryptJsonWalletSync","hexTrue","hexFalse","domainFieldTypes","chainId","verifyingContract","domainFieldNames","checkString","domainChecks","getBaseEncoder","boundsUpper","mask","boundsLower","gt","padOffset","hexPadRight","encodeType","fields","join","TypedDataEncoder","types","links","parents","subtypes","keys","uniqueNames","field","baseType","primaryTypes","filter","t","checkCircular","found","child","subtype","primaryType","st","sort","_types","getEncoder","encoder","_encoderCache","_getEncoder","subEncoder","encodedType","values","encodeData","hashStruct","encode","hash","_visit","callback","visit","domain","domainFields","indexOf","EIP712Domain","hashDomain","resolveName","ensCache","domainValues","domainTypes","typesWithDomain","BN","MAX_SAFE","isBigNumberish","BigNumber","isBigNumber","_warnedToStringRadix","_isBigNumber","toBigNumber","toBN","abs","isNeg","umod","pow","and","or","xor","maskn","shl","shln","shr","shrn","eq","lte","gte","toBigInt","BigInt","warn","UNEXPECTED_ARGUMENT","toJSON","toHex","anyValue","_base36To16","_base16To36","MasterSecret","HardenedBit","getUpperMask","bits","getLowerMask","bytes32","base58check","sha2","getWordlist","wordlist","wordlists","words","defaultPath","publicKey","parentFingerprint","chainCode","index","depth","mnemonicOrPath","signingKey","compressedPublicKey","extendedKey","neuter","_derive","I","sha512","IL","IR","ki","Ki","_addPoint","fingerprint","components","shift","component","seedArray","entropyToMnemonic","mnemonicToEntropy","_fromSeed","mnemonicToSeed","decode","NFKD","checkNormalize","ceil","getWordIndex","normalize","bit","entropyBits","checksumMask","indices","remainingBits","checksumBits","checksum","getWord","isValidMnemonic","getAccountPath","allowedTransactionKeys","gasLimit","gasPrice","nonce","to","accessList","maxFeePerGas","maxPriorityFeePerGas","customData","ccipReadEnabled","resolver","nameOrPromise","resolveAddresses","paramType","isArray","all","arrayChildren","makeError","populateTransaction","contract","fragment","overrides","inputs","pop","checkArgumentCount","signer","override","getAddress","provider","resolved","resolvedAddress","interface","encodeFunctionData","tx","ro","gas","intrinsic","roValue","payable","leftovers","l","addContractWait","wait","bind","confirmations","receipt","events","logs","log","event","parsed","parseLog","topics","decodeEventLog","eventFragment","eventSignature","removeListener","getBlock","blockHash","getTransaction","transactionHash","getTransactionReceipt","buildCall","collapseSimple","signerOrProvider","blockTag","deployTransaction","_deployed","decodeFunctionResult","outputs","CALL_EXCEPTION","transaction","buildDefault","constant","txRequest","sendTransaction","buildSend","getEventTag","topic","tag","_listeners","addListener","listener","once","removeAllListeners","listeners","listenerCount","run","argsCopy","setTimeout","prepareEvent","getEmit","ErrorRunningEvent","super","contractInterface","getEventTopic","decodeError","addressOrName","Contract","isSigner","isProvider","uniqueFilters","filters","encodeFilterTopics","catch","uniqueSignatures","functions","callStatic","buildPopulate","estimateGas","buildEstimate","signatures","isInterface","deployed","_deployedPromise","getCode","contractAddress","fallback","connect","attach","isIndexed","_normalizeRunningEvent","runningEvent","_runningEvents","_getRunningEvent","eventName","getEvent","_checkRunningEvents","emit","_wrappedEmits","off","_wrapEvent","_addEventListener","wrappedEmit","on","queryFilter","fromBlockOrBlockhash","toBlock","fromBlock","getLogs","bytecode","bytecodeHex","getDeployTransaction","deploy","encodeDeploy","unsignedTx","getContract","compilerOutput","MISSING_ARGUMENT","abi","evm","getInterface","looseArrayify","hexString","zpad","getPassword","NFKC","searchPath","currentChild","matchingChild","uuidV4","randomBytes","_permanentCensorErrors","_censorErrors","LogLevels","debug","info","warning","_logLevel","_globalLogger","_normalizeError","missing","form","_checkNormalize","LogLevel","ErrorCode","HEX","defineProperty","enumerable","writable","_log","logLevel","level","console","levels","DEBUG","INFO","WARNING","UNKNOWN_ERROR","messageDetails","reason","url","INSUFFICIENT_FUNDS","MISSING_NEW","NONCE_EXPIRED","REPLACEMENT_UNDERPRICED","TRANSACTION_REPLACED","UNPREDICTABLE_GAS_LIMIT","assert","condition","assertArgument","expectedCount","target","kind","checkAbstract","censorship","permanent","globalLogger"],"mappings":"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","file":"js/chunk-vendors~5cbdb1e7.f29831ff.js","sourcesContent":["import { concat, hexlify } from \"@ethersproject/bytes\";\nimport { nameprep, toUtf8Bytes } from \"@ethersproject/strings\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nconst Zeros = new Uint8Array(32);\nZeros.fill(0);\nconst Partition = new RegExp(\"^((.*)\\\\.)?([^.]+)$\");\nexport function isValidName(name) {\n    try {\n        const comps = name.split(\".\");\n        for (let i = 0; i < comps.length; i++) {\n            if (nameprep(comps[i]).length === 0) {\n                throw new Error(\"empty\");\n            }\n        }\n        return true;\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 current = name;\n    let result = Zeros;\n    while (current.length) {\n        const partition = current.match(Partition);\n        if (partition == null || partition[2] === \"\") {\n            logger.throwArgumentError(\"invalid ENS address; missing component\", \"name\", name);\n        }\n        const label = toUtf8Bytes(nameprep(partition[3]));\n        result = keccak256(concat([result, keccak256(label)]));\n        current = partition[2] || \"\";\n    }\n    return hexlify(result);\n}\nexport function dnsEncode(name) {\n    return hexlify(concat(name.split(\".\").map((comp) => {\n        // We jam in an _ prefix to fill in with the length later\n        // Note: Nameprep throws if the component is over 63 bytes\n        const bytes = toUtf8Bytes(\"_\" + nameprep(comp));\n        bytes[0] = bytes.length - 1;\n        return bytes;\n    }))) + \"00\";\n}\n//# sourceMappingURL=namehash.js.map","\"use strict\";\nimport { arrayify, hexZeroPad, isBytes } from \"@ethersproject/bytes\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { BigNumber, isBigNumberish } from \"./bignumber\";\nconst _constructorGuard = {};\nconst Zero = BigNumber.from(0);\nconst NegativeOne = BigNumber.from(-1);\nfunction throwFault(message, fault, operation, value) {\n    const params = { fault: fault, operation: operation };\n    if (value !== undefined) {\n        params.value = value;\n    }\n    return logger.throwError(message, Logger.errors.NUMERIC_FAULT, params);\n}\n// Constant to pull zeros from for multipliers\nlet zeros = \"0\";\nwhile (zeros.length < 256) {\n    zeros += zeros;\n}\n// Returns a string \"1\" followed by decimal \"0\"s\nfunction getMultiplier(decimals) {\n    if (typeof (decimals) !== \"number\") {\n        try {\n            decimals = BigNumber.from(decimals).toNumber();\n        }\n        catch (e) { }\n    }\n    if (typeof (decimals) === \"number\" && decimals >= 0 && decimals <= 256 && !(decimals % 1)) {\n        return (\"1\" + zeros.substring(0, decimals));\n    }\n    return logger.throwArgumentError(\"invalid decimal size\", \"decimals\", decimals);\n}\nexport function formatFixed(value, decimals) {\n    if (decimals == null) {\n        decimals = 0;\n    }\n    const multiplier = getMultiplier(decimals);\n    // Make sure wei is a big number (convert as necessary)\n    value = BigNumber.from(value);\n    const negative = value.lt(Zero);\n    if (negative) {\n        value = value.mul(NegativeOne);\n    }\n    let fraction = value.mod(multiplier).toString();\n    while (fraction.length < multiplier.length - 1) {\n        fraction = \"0\" + fraction;\n    }\n    // Strip training 0\n    fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];\n    const whole = value.div(multiplier).toString();\n    if (multiplier.length === 1) {\n        value = whole;\n    }\n    else {\n        value = whole + \".\" + fraction;\n    }\n    if (negative) {\n        value = \"-\" + value;\n    }\n    return value;\n}\nexport function parseFixed(value, decimals) {\n    if (decimals == null) {\n        decimals = 0;\n    }\n    const multiplier = getMultiplier(decimals);\n    if (typeof (value) !== \"string\" || !value.match(/^-?[0-9.]+$/)) {\n        logger.throwArgumentError(\"invalid decimal value\", \"value\", value);\n    }\n    // Is it negative?\n    const negative = (value.substring(0, 1) === \"-\");\n    if (negative) {\n        value = value.substring(1);\n    }\n    if (value === \".\") {\n        logger.throwArgumentError(\"missing value\", \"value\", value);\n    }\n    // Split it into a whole and fractional part\n    const comps = value.split(\".\");\n    if (comps.length > 2) {\n        logger.throwArgumentError(\"too many decimal points\", \"value\", value);\n    }\n    let whole = comps[0], fraction = comps[1];\n    if (!whole) {\n        whole = \"0\";\n    }\n    if (!fraction) {\n        fraction = \"0\";\n    }\n    // Trim trailing zeros\n    while (fraction[fraction.length - 1] === \"0\") {\n        fraction = fraction.substring(0, fraction.length - 1);\n    }\n    // Check the fraction doesn't exceed our decimals size\n    if (fraction.length > multiplier.length - 1) {\n        throwFault(\"fractional component exceeds decimals\", \"underflow\", \"parseFixed\");\n    }\n    // If decimals is 0, we have an empty string for fraction\n    if (fraction === \"\") {\n        fraction = \"0\";\n    }\n    // Fully pad the string with zeros to get to wei\n    while (fraction.length < multiplier.length - 1) {\n        fraction += \"0\";\n    }\n    const wholeValue = BigNumber.from(whole);\n    const fractionValue = BigNumber.from(fraction);\n    let wei = (wholeValue.mul(multiplier)).add(fractionValue);\n    if (negative) {\n        wei = wei.mul(NegativeOne);\n    }\n    return wei;\n}\nexport class FixedFormat {\n    constructor(constructorGuard, signed, width, decimals) {\n        if (constructorGuard !== _constructorGuard) {\n            logger.throwError(\"cannot use FixedFormat constructor; use FixedFormat.from\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"new FixedFormat\"\n            });\n        }\n        this.signed = signed;\n        this.width = width;\n        this.decimals = decimals;\n        this.name = (signed ? \"\" : \"u\") + \"fixed\" + String(width) + \"x\" + String(decimals);\n        this._multiplier = getMultiplier(decimals);\n        Object.freeze(this);\n    }\n    static from(value) {\n        if (value instanceof FixedFormat) {\n            return value;\n        }\n        if (typeof (value) === \"number\") {\n            value = `fixed128x${value}`;\n        }\n        let signed = true;\n        let width = 128;\n        let decimals = 18;\n        if (typeof (value) === \"string\") {\n            if (value === \"fixed\") {\n                // defaults...\n            }\n            else if (value === \"ufixed\") {\n                signed = false;\n            }\n            else {\n                const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);\n                if (!match) {\n                    logger.throwArgumentError(\"invalid fixed format\", \"format\", value);\n                }\n                signed = (match[1] !== \"u\");\n                width = parseInt(match[2]);\n                decimals = parseInt(match[3]);\n            }\n        }\n        else if (value) {\n            const check = (key, type, defaultValue) => {\n                if (value[key] == null) {\n                    return defaultValue;\n                }\n                if (typeof (value[key]) !== type) {\n                    logger.throwArgumentError(\"invalid fixed format (\" + key + \" not \" + type + \")\", \"format.\" + key, value[key]);\n                }\n                return value[key];\n            };\n            signed = check(\"signed\", \"boolean\", signed);\n            width = check(\"width\", \"number\", width);\n            decimals = check(\"decimals\", \"number\", decimals);\n        }\n        if (width % 8) {\n            logger.throwArgumentError(\"invalid fixed format width (not byte aligned)\", \"format.width\", width);\n        }\n        if (decimals > 80) {\n            logger.throwArgumentError(\"invalid fixed format (decimals too large)\", \"format.decimals\", decimals);\n        }\n        return new FixedFormat(_constructorGuard, signed, width, decimals);\n    }\n}\nexport class FixedNumber {\n    constructor(constructorGuard, hex, value, format) {\n        logger.checkNew(new.target, FixedNumber);\n        if (constructorGuard !== _constructorGuard) {\n            logger.throwError(\"cannot use FixedNumber constructor; use FixedNumber.from\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"new FixedFormat\"\n            });\n        }\n        this.format = format;\n        this._hex = hex;\n        this._value = value;\n        this._isFixedNumber = true;\n        Object.freeze(this);\n    }\n    _checkFormat(other) {\n        if (this.format.name !== other.format.name) {\n            logger.throwArgumentError(\"incompatible format; use fixedNumber.toFormat\", \"other\", other);\n        }\n    }\n    addUnsafe(other) {\n        this._checkFormat(other);\n        const a = parseFixed(this._value, this.format.decimals);\n        const b = parseFixed(other._value, other.format.decimals);\n        return FixedNumber.fromValue(a.add(b), this.format.decimals, this.format);\n    }\n    subUnsafe(other) {\n        this._checkFormat(other);\n        const a = parseFixed(this._value, this.format.decimals);\n        const b = parseFixed(other._value, other.format.decimals);\n        return FixedNumber.fromValue(a.sub(b), this.format.decimals, this.format);\n    }\n    mulUnsafe(other) {\n        this._checkFormat(other);\n        const a = parseFixed(this._value, this.format.decimals);\n        const b = parseFixed(other._value, other.format.decimals);\n        return FixedNumber.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);\n    }\n    divUnsafe(other) {\n        this._checkFormat(other);\n        const a = parseFixed(this._value, this.format.decimals);\n        const b = parseFixed(other._value, other.format.decimals);\n        return FixedNumber.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);\n    }\n    floor() {\n        const comps = this.toString().split(\".\");\n        if (comps.length === 1) {\n            comps.push(\"0\");\n        }\n        let result = FixedNumber.from(comps[0], this.format);\n        const hasFraction = !comps[1].match(/^(0*)$/);\n        if (this.isNegative() && hasFraction) {\n            result = result.subUnsafe(ONE.toFormat(result.format));\n        }\n        return result;\n    }\n    ceiling() {\n        const comps = this.toString().split(\".\");\n        if (comps.length === 1) {\n            comps.push(\"0\");\n        }\n        let result = FixedNumber.from(comps[0], this.format);\n        const hasFraction = !comps[1].match(/^(0*)$/);\n        if (!this.isNegative() && hasFraction) {\n            result = result.addUnsafe(ONE.toFormat(result.format));\n        }\n        return result;\n    }\n    // @TODO: Support other rounding algorithms\n    round(decimals) {\n        if (decimals == null) {\n            decimals = 0;\n        }\n        // If we are already in range, we're done\n        const comps = this.toString().split(\".\");\n        if (comps.length === 1) {\n            comps.push(\"0\");\n        }\n        if (decimals < 0 || decimals > 80 || (decimals % 1)) {\n            logger.throwArgumentError(\"invalid decimal count\", \"decimals\", decimals);\n        }\n        if (comps[1].length <= decimals) {\n            return this;\n        }\n        const factor = FixedNumber.from(\"1\" + zeros.substring(0, decimals), this.format);\n        const bump = BUMP.toFormat(this.format);\n        return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor);\n    }\n    isZero() {\n        return (this._value === \"0.0\" || this._value === \"0\");\n    }\n    isNegative() {\n        return (this._value[0] === \"-\");\n    }\n    toString() { return this._value; }\n    toHexString(width) {\n        if (width == null) {\n            return this._hex;\n        }\n        if (width % 8) {\n            logger.throwArgumentError(\"invalid byte width\", \"width\", width);\n        }\n        const hex = BigNumber.from(this._hex).fromTwos(this.format.width).toTwos(width).toHexString();\n        return hexZeroPad(hex, width / 8);\n    }\n    toUnsafeFloat() { return parseFloat(this.toString()); }\n    toFormat(format) {\n        return FixedNumber.fromString(this._value, format);\n    }\n    static fromValue(value, decimals, format) {\n        // If decimals looks more like a format, and there is no format, shift the parameters\n        if (format == null && decimals != null && !isBigNumberish(decimals)) {\n            format = decimals;\n            decimals = null;\n        }\n        if (decimals == null) {\n            decimals = 0;\n        }\n        if (format == null) {\n            format = \"fixed\";\n        }\n        return FixedNumber.fromString(formatFixed(value, decimals), FixedFormat.from(format));\n    }\n    static fromString(value, format) {\n        if (format == null) {\n            format = \"fixed\";\n        }\n        const fixedFormat = FixedFormat.from(format);\n        const numeric = parseFixed(value, fixedFormat.decimals);\n        if (!fixedFormat.signed && numeric.lt(Zero)) {\n            throwFault(\"unsigned value cannot be negative\", \"overflow\", \"value\", value);\n        }\n        let hex = null;\n        if (fixedFormat.signed) {\n            hex = numeric.toTwos(fixedFormat.width).toHexString();\n        }\n        else {\n            hex = numeric.toHexString();\n            hex = hexZeroPad(hex, fixedFormat.width / 8);\n        }\n        const decimal = formatFixed(numeric, fixedFormat.decimals);\n        return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat);\n    }\n    static fromBytes(value, format) {\n        if (format == null) {\n            format = \"fixed\";\n        }\n        const fixedFormat = FixedFormat.from(format);\n        if (arrayify(value).length > fixedFormat.width / 8) {\n            throw new Error(\"overflow\");\n        }\n        let numeric = BigNumber.from(value);\n        if (fixedFormat.signed) {\n            numeric = numeric.fromTwos(fixedFormat.width);\n        }\n        const hex = numeric.toTwos((fixedFormat.signed ? 0 : 1) + fixedFormat.width).toHexString();\n        const decimal = formatFixed(numeric, fixedFormat.decimals);\n        return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat);\n    }\n    static from(value, format) {\n        if (typeof (value) === \"string\") {\n            return FixedNumber.fromString(value, format);\n        }\n        if (isBytes(value)) {\n            return FixedNumber.fromBytes(value, format);\n        }\n        try {\n            return FixedNumber.fromValue(value, 0, format);\n        }\n        catch (error) {\n            // Allow NUMERIC_FAULT to bubble up\n            if (error.code !== Logger.errors.INVALID_ARGUMENT) {\n                throw error;\n            }\n        }\n        return logger.throwArgumentError(\"invalid FixedNumber value\", \"value\", value);\n    }\n    static isFixedNumber(value) {\n        return !!(value && value._isFixedNumber);\n    }\n}\nconst ONE = FixedNumber.from(1);\nconst BUMP = FixedNumber.from(\"0.5\");\n//# sourceMappingURL=fixednumber.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 HashZero = \"0x0000000000000000000000000000000000000000000000000000000000000000\";\n//# sourceMappingURL=hashes.js.map","export const version = \"json-wallets/5.6.0\";\n//# sourceMappingURL=_version.js.map","export const version = \"bytes/5.6.1\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n///////////////////////////////\nfunction isHexable(value) {\n    return !!(value.toHexString);\n}\nfunction addSlice(array) {\n    if (array.slice) {\n        return array;\n    }\n    array.slice = function () {\n        const args = Array.prototype.slice.call(arguments);\n        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));\n    };\n    return array;\n}\nexport function isBytesLike(value) {\n    return ((isHexString(value) && !(value.length % 2)) || isBytes(value));\n}\nfunction isInteger(value) {\n    return (typeof (value) === \"number\" && value == value && (value % 1) === 0);\n}\nexport function isBytes(value) {\n    if (value == null) {\n        return false;\n    }\n    if (value.constructor === Uint8Array) {\n        return true;\n    }\n    if (typeof (value) === \"string\") {\n        return false;\n    }\n    if (!isInteger(value.length) || value.length < 0) {\n        return false;\n    }\n    for (let i = 0; i < value.length; i++) {\n        const v = value[i];\n        if (!isInteger(v) || v < 0 || v >= 256) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function arrayify(value, options) {\n    if (!options) {\n        options = {};\n    }\n    if (typeof (value) === \"number\") {\n        logger.checkSafeUint53(value, \"invalid arrayify value\");\n        const result = [];\n        while (value) {\n            result.unshift(value & 0xff);\n            value = parseInt(String(value / 256));\n        }\n        if (result.length === 0) {\n            result.push(0);\n        }\n        return addSlice(new Uint8Array(result));\n    }\n    if (options.allowMissingPrefix && typeof (value) === \"string\" && value.substring(0, 2) !== \"0x\") {\n        value = \"0x\" + value;\n    }\n    if (isHexable(value)) {\n        value = value.toHexString();\n    }\n    if (isHexString(value)) {\n        let hex = value.substring(2);\n        if (hex.length % 2) {\n            if (options.hexPad === \"left\") {\n                hex = \"0\" + hex;\n            }\n            else if (options.hexPad === \"right\") {\n                hex += \"0\";\n            }\n            else {\n                logger.throwArgumentError(\"hex data is odd-length\", \"value\", value);\n            }\n        }\n        const result = [];\n        for (let i = 0; i < hex.length; i += 2) {\n            result.push(parseInt(hex.substring(i, i + 2), 16));\n        }\n        return addSlice(new Uint8Array(result));\n    }\n    if (isBytes(value)) {\n        return addSlice(new Uint8Array(value));\n    }\n    return logger.throwArgumentError(\"invalid arrayify value\", \"value\", value);\n}\nexport function concat(items) {\n    const objects = items.map(item => arrayify(item));\n    const length = objects.reduce((accum, item) => (accum + item.length), 0);\n    const result = new Uint8Array(length);\n    objects.reduce((offset, object) => {\n        result.set(object, offset);\n        return offset + object.length;\n    }, 0);\n    return addSlice(result);\n}\nexport function stripZeros(value) {\n    let result = arrayify(value);\n    if (result.length === 0) {\n        return result;\n    }\n    // Find the first non-zero entry\n    let start = 0;\n    while (start < result.length && result[start] === 0) {\n        start++;\n    }\n    // If we started with zeros, strip them\n    if (start) {\n        result = result.slice(start);\n    }\n    return result;\n}\nexport function zeroPad(value, length) {\n    value = arrayify(value);\n    if (value.length > length) {\n        logger.throwArgumentError(\"value out of range\", \"value\", arguments[0]);\n    }\n    const result = new Uint8Array(length);\n    result.set(value, length - value.length);\n    return addSlice(result);\n}\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (length && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    return true;\n}\nconst HexCharacters = \"0123456789abcdef\";\nexport function hexlify(value, options) {\n    if (!options) {\n        options = {};\n    }\n    if (typeof (value) === \"number\") {\n        logger.checkSafeUint53(value, \"invalid hexlify value\");\n        let hex = \"\";\n        while (value) {\n            hex = HexCharacters[value & 0xf] + hex;\n            value = Math.floor(value / 16);\n        }\n        if (hex.length) {\n            if (hex.length % 2) {\n                hex = \"0\" + hex;\n            }\n            return \"0x\" + hex;\n        }\n        return \"0x00\";\n    }\n    if (typeof (value) === \"bigint\") {\n        value = value.toString(16);\n        if (value.length % 2) {\n            return (\"0x0\" + value);\n        }\n        return \"0x\" + value;\n    }\n    if (options.allowMissingPrefix && typeof (value) === \"string\" && value.substring(0, 2) !== \"0x\") {\n        value = \"0x\" + value;\n    }\n    if (isHexable(value)) {\n        return value.toHexString();\n    }\n    if (isHexString(value)) {\n        if (value.length % 2) {\n            if (options.hexPad === \"left\") {\n                value = \"0x0\" + value.substring(2);\n            }\n            else if (options.hexPad === \"right\") {\n                value += \"0\";\n            }\n            else {\n                logger.throwArgumentError(\"hex data is odd-length\", \"value\", value);\n            }\n        }\n        return value.toLowerCase();\n    }\n    if (isBytes(value)) {\n        let result = \"0x\";\n        for (let i = 0; i < value.length; i++) {\n            let v = value[i];\n            result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n        }\n        return result;\n    }\n    return logger.throwArgumentError(\"invalid hexlify value\", \"value\", value);\n}\n/*\nfunction unoddify(value: BytesLike | Hexable | number): BytesLike | Hexable | number {\n    if (typeof(value) === \"string\" && value.length % 2 && value.substring(0, 2) === \"0x\") {\n        return \"0x0\" + value.substring(2);\n    }\n    return value;\n}\n*/\nexport function hexDataLength(data) {\n    if (typeof (data) !== \"string\") {\n        data = hexlify(data);\n    }\n    else if (!isHexString(data) || (data.length % 2)) {\n        return null;\n    }\n    return (data.length - 2) / 2;\n}\nexport function hexDataSlice(data, offset, endOffset) {\n    if (typeof (data) !== \"string\") {\n        data = hexlify(data);\n    }\n    else if (!isHexString(data) || (data.length % 2)) {\n        logger.throwArgumentError(\"invalid hexData\", \"value\", data);\n    }\n    offset = 2 + 2 * offset;\n    if (endOffset != null) {\n        return \"0x\" + data.substring(offset, 2 + 2 * endOffset);\n    }\n    return \"0x\" + data.substring(offset);\n}\nexport function hexConcat(items) {\n    let result = \"0x\";\n    items.forEach((item) => {\n        result += hexlify(item).substring(2);\n    });\n    return result;\n}\nexport function hexValue(value) {\n    const trimmed = hexStripZeros(hexlify(value, { hexPad: \"left\" }));\n    if (trimmed === \"0x\") {\n        return \"0x0\";\n    }\n    return trimmed;\n}\nexport function hexStripZeros(value) {\n    if (typeof (value) !== \"string\") {\n        value = hexlify(value);\n    }\n    if (!isHexString(value)) {\n        logger.throwArgumentError(\"invalid hex string\", \"value\", value);\n    }\n    value = value.substring(2);\n    let offset = 0;\n    while (offset < value.length && value[offset] === \"0\") {\n        offset++;\n    }\n    return \"0x\" + value.substring(offset);\n}\nexport function hexZeroPad(value, length) {\n    if (typeof (value) !== \"string\") {\n        value = hexlify(value);\n    }\n    else if (!isHexString(value)) {\n        logger.throwArgumentError(\"invalid hex string\", \"value\", value);\n    }\n    if (value.length > 2 * length + 2) {\n        logger.throwArgumentError(\"value out of range\", \"value\", arguments[1]);\n    }\n    while (value.length < 2 * length + 2) {\n        value = \"0x0\" + value.substring(2);\n    }\n    return value;\n}\nexport function splitSignature(signature) {\n    const result = {\n        r: \"0x\",\n        s: \"0x\",\n        _vs: \"0x\",\n        recoveryParam: 0,\n        v: 0,\n        yParityAndS: \"0x\",\n        compact: \"0x\"\n    };\n    if (isBytesLike(signature)) {\n        let bytes = arrayify(signature);\n        // Get the r, s and v\n        if (bytes.length === 64) {\n            // EIP-2098; pull the v from the top bit of s and clear it\n            result.v = 27 + (bytes[32] >> 7);\n            bytes[32] &= 0x7f;\n            result.r = hexlify(bytes.slice(0, 32));\n            result.s = hexlify(bytes.slice(32, 64));\n        }\n        else if (bytes.length === 65) {\n            result.r = hexlify(bytes.slice(0, 32));\n            result.s = hexlify(bytes.slice(32, 64));\n            result.v = bytes[64];\n        }\n        else {\n            logger.throwArgumentError(\"invalid signature string\", \"signature\", signature);\n        }\n        // Allow a recid to be used as the v\n        if (result.v < 27) {\n            if (result.v === 0 || result.v === 1) {\n                result.v += 27;\n            }\n            else {\n                logger.throwArgumentError(\"signature invalid v byte\", \"signature\", signature);\n            }\n        }\n        // Compute recoveryParam from v\n        result.recoveryParam = 1 - (result.v % 2);\n        // Compute _vs from recoveryParam and s\n        if (result.recoveryParam) {\n            bytes[32] |= 0x80;\n        }\n        result._vs = hexlify(bytes.slice(32, 64));\n    }\n    else {\n        result.r = signature.r;\n        result.s = signature.s;\n        result.v = signature.v;\n        result.recoveryParam = signature.recoveryParam;\n        result._vs = signature._vs;\n        // If the _vs is available, use it to populate missing s, v and recoveryParam\n        // and verify non-missing s, v and recoveryParam\n        if (result._vs != null) {\n            const vs = zeroPad(arrayify(result._vs), 32);\n            result._vs = hexlify(vs);\n            // Set or check the recid\n            const recoveryParam = ((vs[0] >= 128) ? 1 : 0);\n            if (result.recoveryParam == null) {\n                result.recoveryParam = recoveryParam;\n            }\n            else if (result.recoveryParam !== recoveryParam) {\n                logger.throwArgumentError(\"signature recoveryParam mismatch _vs\", \"signature\", signature);\n            }\n            // Set or check the s\n            vs[0] &= 0x7f;\n            const s = hexlify(vs);\n            if (result.s == null) {\n                result.s = s;\n            }\n            else if (result.s !== s) {\n                logger.throwArgumentError(\"signature v mismatch _vs\", \"signature\", signature);\n            }\n        }\n        // Use recid and v to populate each other\n        if (result.recoveryParam == null) {\n            if (result.v == null) {\n                logger.throwArgumentError(\"signature missing v and recoveryParam\", \"signature\", signature);\n            }\n            else if (result.v === 0 || result.v === 1) {\n                result.recoveryParam = result.v;\n            }\n            else {\n                result.recoveryParam = 1 - (result.v % 2);\n            }\n        }\n        else {\n            if (result.v == null) {\n                result.v = 27 + result.recoveryParam;\n            }\n            else {\n                const recId = (result.v === 0 || result.v === 1) ? result.v : (1 - (result.v % 2));\n                if (result.recoveryParam !== recId) {\n                    logger.throwArgumentError(\"signature recoveryParam mismatch v\", \"signature\", signature);\n                }\n            }\n        }\n        if (result.r == null || !isHexString(result.r)) {\n            logger.throwArgumentError(\"signature missing or invalid r\", \"signature\", signature);\n        }\n        else {\n            result.r = hexZeroPad(result.r, 32);\n        }\n        if (result.s == null || !isHexString(result.s)) {\n            logger.throwArgumentError(\"signature missing or invalid s\", \"signature\", signature);\n        }\n        else {\n            result.s = hexZeroPad(result.s, 32);\n        }\n        const vs = arrayify(result.s);\n        if (vs[0] >= 128) {\n            logger.throwArgumentError(\"signature s out of range\", \"signature\", signature);\n        }\n        if (result.recoveryParam) {\n            vs[0] |= 0x80;\n        }\n        const _vs = hexlify(vs);\n        if (result._vs) {\n            if (!isHexString(result._vs)) {\n                logger.throwArgumentError(\"signature invalid _vs\", \"signature\", signature);\n            }\n            result._vs = hexZeroPad(result._vs, 32);\n        }\n        // Set or check the _vs\n        if (result._vs == null) {\n            result._vs = _vs;\n        }\n        else if (result._vs !== _vs) {\n            logger.throwArgumentError(\"signature _vs mismatch v and s\", \"signature\", signature);\n        }\n    }\n    result.yParityAndS = result._vs;\n    result.compact = result.r + result.yParityAndS.substring(2);\n    return result;\n}\nexport function joinSignature(signature) {\n    signature = splitSignature(signature);\n    return hexlify(concat([\n        signature.r,\n        signature.s,\n        (signature.recoveryParam ? \"0x1c\" : \"0x1b\")\n    ]));\n}\n//# sourceMappingURL=index.js.map","export const version = \"hash/5.6.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","import { BigNumber } from \"@ethersproject/bignumber\";\nconst NegativeOne = ( /*#__PURE__*/BigNumber.from(-1));\nconst Zero = ( /*#__PURE__*/BigNumber.from(0));\nconst One = ( /*#__PURE__*/BigNumber.from(1));\nconst Two = ( /*#__PURE__*/BigNumber.from(2));\nconst WeiPerEther = ( /*#__PURE__*/BigNumber.from(\"1000000000000000000\"));\nconst MaxUint256 = ( /*#__PURE__*/BigNumber.from(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"));\nconst MinInt256 = ( /*#__PURE__*/BigNumber.from(\"-0x8000000000000000000000000000000000000000000000000000000000000000\"));\nconst MaxInt256 = ( /*#__PURE__*/BigNumber.from(\"0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"));\nexport { NegativeOne, Zero, One, Two, WeiPerEther, MaxUint256, MinInt256, MaxInt256, };\n//# sourceMappingURL=bignumbers.js.map","export const version = \"bignumber/5.6.0\";\n//# sourceMappingURL=_version.js.map","// NFKC (composed)             // (decomposed)\nexport const EtherSymbol = \"\\u039e\"; // \"\\uD835\\uDF63\";\n//# sourceMappingURL=strings.js.map","export const AddressZero = \"0x0000000000000000000000000000000000000000\";\n//# sourceMappingURL=addresses.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","\"use strict\";\n/**\n *  BigNumber\n *\n *  A wrapper around the BN.js object. We use the BN.js library\n *  because it is used by elliptic, so it is required regardless.\n *\n */\nimport _BN from \"bn.js\";\nvar BN = _BN.BN;\nimport { hexlify, isBytes, isHexString } from \"@ethersproject/bytes\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nconst _constructorGuard = {};\nconst MAX_SAFE = 0x1fffffffffffff;\nexport function isBigNumberish(value) {\n    return (value != null) && (BigNumber.isBigNumber(value) ||\n        (typeof (value) === \"number\" && (value % 1) === 0) ||\n        (typeof (value) === \"string\" && !!value.match(/^-?[0-9]+$/)) ||\n        isHexString(value) ||\n        (typeof (value) === \"bigint\") ||\n        isBytes(value));\n}\n// Only warn about passing 10 into radix once\nlet _warnedToStringRadix = false;\nexport class BigNumber {\n    constructor(constructorGuard, hex) {\n        logger.checkNew(new.target, BigNumber);\n        if (constructorGuard !== _constructorGuard) {\n            logger.throwError(\"cannot call constructor directly; use BigNumber.from\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"new (BigNumber)\"\n            });\n        }\n        this._hex = hex;\n        this._isBigNumber = true;\n        Object.freeze(this);\n    }\n    fromTwos(value) {\n        return toBigNumber(toBN(this).fromTwos(value));\n    }\n    toTwos(value) {\n        return toBigNumber(toBN(this).toTwos(value));\n    }\n    abs() {\n        if (this._hex[0] === \"-\") {\n            return BigNumber.from(this._hex.substring(1));\n        }\n        return this;\n    }\n    add(other) {\n        return toBigNumber(toBN(this).add(toBN(other)));\n    }\n    sub(other) {\n        return toBigNumber(toBN(this).sub(toBN(other)));\n    }\n    div(other) {\n        const o = BigNumber.from(other);\n        if (o.isZero()) {\n            throwFault(\"division-by-zero\", \"div\");\n        }\n        return toBigNumber(toBN(this).div(toBN(other)));\n    }\n    mul(other) {\n        return toBigNumber(toBN(this).mul(toBN(other)));\n    }\n    mod(other) {\n        const value = toBN(other);\n        if (value.isNeg()) {\n            throwFault(\"division-by-zero\", \"mod\");\n        }\n        return toBigNumber(toBN(this).umod(value));\n    }\n    pow(other) {\n        const value = toBN(other);\n        if (value.isNeg()) {\n            throwFault(\"negative-power\", \"pow\");\n        }\n        return toBigNumber(toBN(this).pow(value));\n    }\n    and(other) {\n        const value = toBN(other);\n        if (this.isNegative() || value.isNeg()) {\n            throwFault(\"unbound-bitwise-result\", \"and\");\n        }\n        return toBigNumber(toBN(this).and(value));\n    }\n    or(other) {\n        const value = toBN(other);\n        if (this.isNegative() || value.isNeg()) {\n            throwFault(\"unbound-bitwise-result\", \"or\");\n        }\n        return toBigNumber(toBN(this).or(value));\n    }\n    xor(other) {\n        const value = toBN(other);\n        if (this.isNegative() || value.isNeg()) {\n            throwFault(\"unbound-bitwise-result\", \"xor\");\n        }\n        return toBigNumber(toBN(this).xor(value));\n    }\n    mask(value) {\n        if (this.isNegative() || value < 0) {\n            throwFault(\"negative-width\", \"mask\");\n        }\n        return toBigNumber(toBN(this).maskn(value));\n    }\n    shl(value) {\n        if (this.isNegative() || value < 0) {\n            throwFault(\"negative-width\", \"shl\");\n        }\n        return toBigNumber(toBN(this).shln(value));\n    }\n    shr(value) {\n        if (this.isNegative() || value < 0) {\n            throwFault(\"negative-width\", \"shr\");\n        }\n        return toBigNumber(toBN(this).shrn(value));\n    }\n    eq(other) {\n        return toBN(this).eq(toBN(other));\n    }\n    lt(other) {\n        return toBN(this).lt(toBN(other));\n    }\n    lte(other) {\n        return toBN(this).lte(toBN(other));\n    }\n    gt(other) {\n        return toBN(this).gt(toBN(other));\n    }\n    gte(other) {\n        return toBN(this).gte(toBN(other));\n    }\n    isNegative() {\n        return (this._hex[0] === \"-\");\n    }\n    isZero() {\n        return toBN(this).isZero();\n    }\n    toNumber() {\n        try {\n            return toBN(this).toNumber();\n        }\n        catch (error) {\n            throwFault(\"overflow\", \"toNumber\", this.toString());\n        }\n        return null;\n    }\n    toBigInt() {\n        try {\n            return BigInt(this.toString());\n        }\n        catch (e) { }\n        return logger.throwError(\"this platform does not support BigInt\", Logger.errors.UNSUPPORTED_OPERATION, {\n            value: this.toString()\n        });\n    }\n    toString() {\n        // Lots of people expect this, which we do not support, so check (See: #889)\n        if (arguments.length > 0) {\n            if (arguments[0] === 10) {\n                if (!_warnedToStringRadix) {\n                    _warnedToStringRadix = true;\n                    logger.warn(\"BigNumber.toString does not accept any parameters; base-10 is assumed\");\n                }\n            }\n            else if (arguments[0] === 16) {\n                logger.throwError(\"BigNumber.toString does not accept any parameters; use bigNumber.toHexString()\", Logger.errors.UNEXPECTED_ARGUMENT, {});\n            }\n            else {\n                logger.throwError(\"BigNumber.toString does not accept parameters\", Logger.errors.UNEXPECTED_ARGUMENT, {});\n            }\n        }\n        return toBN(this).toString(10);\n    }\n    toHexString() {\n        return this._hex;\n    }\n    toJSON(key) {\n        return { type: \"BigNumber\", hex: this.toHexString() };\n    }\n    static from(value) {\n        if (value instanceof BigNumber) {\n            return value;\n        }\n        if (typeof (value) === \"string\") {\n            if (value.match(/^-?0x[0-9a-f]+$/i)) {\n                return new BigNumber(_constructorGuard, toHex(value));\n            }\n            if (value.match(/^-?[0-9]+$/)) {\n                return new BigNumber(_constructorGuard, toHex(new BN(value)));\n            }\n            return logger.throwArgumentError(\"invalid BigNumber string\", \"value\", value);\n        }\n        if (typeof (value) === \"number\") {\n            if (value % 1) {\n                throwFault(\"underflow\", \"BigNumber.from\", value);\n            }\n            if (value >= MAX_SAFE || value <= -MAX_SAFE) {\n                throwFault(\"overflow\", \"BigNumber.from\", value);\n            }\n            return BigNumber.from(String(value));\n        }\n        const anyValue = value;\n        if (typeof (anyValue) === \"bigint\") {\n            return BigNumber.from(anyValue.toString());\n        }\n        if (isBytes(anyValue)) {\n            return BigNumber.from(hexlify(anyValue));\n        }\n        if (anyValue) {\n            // Hexable interface (takes priority)\n            if (anyValue.toHexString) {\n                const hex = anyValue.toHexString();\n                if (typeof (hex) === \"string\") {\n                    return BigNumber.from(hex);\n                }\n            }\n            else {\n                // For now, handle legacy JSON-ified values (goes away in v6)\n                let hex = anyValue._hex;\n                // New-form JSON\n                if (hex == null && anyValue.type === \"BigNumber\") {\n                    hex = anyValue.hex;\n                }\n                if (typeof (hex) === \"string\") {\n                    if (isHexString(hex) || (hex[0] === \"-\" && isHexString(hex.substring(1)))) {\n                        return BigNumber.from(hex);\n                    }\n                }\n            }\n        }\n        return logger.throwArgumentError(\"invalid BigNumber value\", \"value\", value);\n    }\n    static isBigNumber(value) {\n        return !!(value && value._isBigNumber);\n    }\n}\n// Normalize the hex string\nfunction toHex(value) {\n    // For BN, call on the hex string\n    if (typeof (value) !== \"string\") {\n        return toHex(value.toString(16));\n    }\n    // If negative, prepend the negative sign to the normalized positive value\n    if (value[0] === \"-\") {\n        // Strip off the negative sign\n        value = value.substring(1);\n        // Cannot have multiple negative signs (e.g. \"--0x04\")\n        if (value[0] === \"-\") {\n            logger.throwArgumentError(\"invalid hex\", \"value\", value);\n        }\n        // Call toHex on the positive component\n        value = toHex(value);\n        // Do not allow \"-0x00\"\n        if (value === \"0x00\") {\n            return value;\n        }\n        // Negate the value\n        return \"-\" + value;\n    }\n    // Add a \"0x\" prefix if missing\n    if (value.substring(0, 2) !== \"0x\") {\n        value = \"0x\" + value;\n    }\n    // Normalize zero\n    if (value === \"0x\") {\n        return \"0x00\";\n    }\n    // Make the string even length\n    if (value.length % 2) {\n        value = \"0x0\" + value.substring(2);\n    }\n    // Trim to smallest even-length string\n    while (value.length > 4 && value.substring(0, 4) === \"0x00\") {\n        value = \"0x\" + value.substring(4);\n    }\n    return value;\n}\nfunction toBigNumber(value) {\n    return BigNumber.from(toHex(value));\n}\nfunction toBN(value) {\n    const hex = BigNumber.from(value).toHexString();\n    if (hex[0] === \"-\") {\n        return (new BN(\"-\" + hex.substring(3), 16));\n    }\n    return new BN(hex.substring(2), 16);\n}\nfunction throwFault(fault, operation, value) {\n    const params = { fault: fault, operation: operation };\n    if (value != null) {\n        params.value = value;\n    }\n    return logger.throwError(fault, Logger.errors.NUMERIC_FAULT, params);\n}\n// value should have no prefix\nexport function _base36To16(value) {\n    return (new BN(value, 36)).toString(16);\n}\n// value should have no prefix\nexport function _base16To36(value) {\n    return (new BN(value, 16)).toString(36);\n}\n//# sourceMappingURL=bignumber.js.map","export const version = \"hdnode/5.6.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        logger.checkNew(new.target, HDNode);\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\";\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 { checkResultErrors, Indexed, Interface } from \"@ethersproject/abi\";\nimport { Provider } from \"@ethersproject/abstract-provider\";\nimport { Signer, VoidSigner } from \"@ethersproject/abstract-signer\";\nimport { getAddress, getContractAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, concat, hexlify, isBytes, isHexString } from \"@ethersproject/bytes\";\nimport { defineReadOnly, deepCopy, getStatic, resolveProperties, shallowCopy } from \"@ethersproject/properties\";\nimport { accessListify } from \"@ethersproject/transactions\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n;\n;\n///////////////////////////////\nconst allowedTransactionKeys = {\n    chainId: true, data: true, from: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true,\n    type: true, accessList: true,\n    maxFeePerGas: true, maxPriorityFeePerGas: true,\n    customData: true,\n    ccipReadEnabled: true\n};\nfunction resolveName(resolver, nameOrPromise) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const name = yield nameOrPromise;\n        if (typeof (name) !== \"string\") {\n            logger.throwArgumentError(\"invalid address or ENS name\", \"name\", name);\n        }\n        // If it is already an address, just use it (after adding checksum)\n        try {\n            return getAddress(name);\n        }\n        catch (error) { }\n        if (!resolver) {\n            logger.throwError(\"a provider or signer is needed to resolve ENS names\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"resolveName\"\n            });\n        }\n        const address = yield resolver.resolveName(name);\n        if (address == null) {\n            logger.throwArgumentError(\"resolver or addr is not configured for ENS name\", \"name\", name);\n        }\n        return address;\n    });\n}\n// Recursively replaces ENS names with promises to resolve the name and resolves all properties\nfunction resolveAddresses(resolver, value, paramType) {\n    return __awaiter(this, void 0, void 0, function* () {\n        if (Array.isArray(paramType)) {\n            return yield Promise.all(paramType.map((paramType, index) => {\n                return resolveAddresses(resolver, ((Array.isArray(value)) ? value[index] : value[paramType.name]), paramType);\n            }));\n        }\n        if (paramType.type === \"address\") {\n            return yield resolveName(resolver, value);\n        }\n        if (paramType.type === \"tuple\") {\n            return yield resolveAddresses(resolver, value, paramType.components);\n        }\n        if (paramType.baseType === \"array\") {\n            if (!Array.isArray(value)) {\n                return Promise.reject(logger.makeError(\"invalid value for array\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"value\",\n                    value\n                }));\n            }\n            return yield Promise.all(value.map((v) => resolveAddresses(resolver, v, paramType.arrayChildren)));\n        }\n        return value;\n    });\n}\nfunction populateTransaction(contract, fragment, args) {\n    return __awaiter(this, void 0, void 0, function* () {\n        // If an extra argument is given, it is overrides\n        let overrides = {};\n        if (args.length === fragment.inputs.length + 1 && typeof (args[args.length - 1]) === \"object\") {\n            overrides = shallowCopy(args.pop());\n        }\n        // Make sure the parameter count matches\n        logger.checkArgumentCount(args.length, fragment.inputs.length, \"passed to contract\");\n        // Populate \"from\" override (allow promises)\n        if (contract.signer) {\n            if (overrides.from) {\n                // Contracts with a Signer are from the Signer's frame-of-reference;\n                // but we allow overriding \"from\" if it matches the signer\n                overrides.from = resolveProperties({\n                    override: resolveName(contract.signer, overrides.from),\n                    signer: contract.signer.getAddress()\n                }).then((check) => __awaiter(this, void 0, void 0, function* () {\n                    if (getAddress(check.signer) !== check.override) {\n                        logger.throwError(\"Contract with a Signer cannot override from\", Logger.errors.UNSUPPORTED_OPERATION, {\n                            operation: \"overrides.from\"\n                        });\n                    }\n                    return check.override;\n                }));\n            }\n            else {\n                overrides.from = contract.signer.getAddress();\n            }\n        }\n        else if (overrides.from) {\n            overrides.from = resolveName(contract.provider, overrides.from);\n            //} else {\n            // Contracts without a signer can override \"from\", and if\n            // unspecified the zero address is used\n            //overrides.from = AddressZero;\n        }\n        // Wait for all dependencies to be resolved (prefer the signer over the provider)\n        const resolved = yield resolveProperties({\n            args: resolveAddresses(contract.signer || contract.provider, args, fragment.inputs),\n            address: contract.resolvedAddress,\n            overrides: (resolveProperties(overrides) || {})\n        });\n        // The ABI coded transaction\n        const data = contract.interface.encodeFunctionData(fragment, resolved.args);\n        const tx = {\n            data: data,\n            to: resolved.address\n        };\n        // Resolved Overrides\n        const ro = resolved.overrides;\n        // Populate simple overrides\n        if (ro.nonce != null) {\n            tx.nonce = BigNumber.from(ro.nonce).toNumber();\n        }\n        if (ro.gasLimit != null) {\n            tx.gasLimit = BigNumber.from(ro.gasLimit);\n        }\n        if (ro.gasPrice != null) {\n            tx.gasPrice = BigNumber.from(ro.gasPrice);\n        }\n        if (ro.maxFeePerGas != null) {\n            tx.maxFeePerGas = BigNumber.from(ro.maxFeePerGas);\n        }\n        if (ro.maxPriorityFeePerGas != null) {\n            tx.maxPriorityFeePerGas = BigNumber.from(ro.maxPriorityFeePerGas);\n        }\n        if (ro.from != null) {\n            tx.from = ro.from;\n        }\n        if (ro.type != null) {\n            tx.type = ro.type;\n        }\n        if (ro.accessList != null) {\n            tx.accessList = accessListify(ro.accessList);\n        }\n        // If there was no \"gasLimit\" override, but the ABI specifies a default, use it\n        if (tx.gasLimit == null && fragment.gas != null) {\n            // Compute the intrinsic gas cost for this transaction\n            // @TODO: This is based on the yellow paper as of Petersburg; this is something\n            // we may wish to parameterize in v6 as part of the Network object. Since this\n            // is always a non-nil to address, we can ignore G_create, but may wish to add\n            // similar logic to the ContractFactory.\n            let intrinsic = 21000;\n            const bytes = arrayify(data);\n            for (let i = 0; i < bytes.length; i++) {\n                intrinsic += 4;\n                if (bytes[i]) {\n                    intrinsic += 64;\n                }\n            }\n            tx.gasLimit = BigNumber.from(fragment.gas).add(intrinsic);\n        }\n        // Populate \"value\" override\n        if (ro.value) {\n            const roValue = BigNumber.from(ro.value);\n            if (!roValue.isZero() && !fragment.payable) {\n                logger.throwError(\"non-payable method cannot override value\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"overrides.value\",\n                    value: overrides.value\n                });\n            }\n            tx.value = roValue;\n        }\n        if (ro.customData) {\n            tx.customData = shallowCopy(ro.customData);\n        }\n        if (ro.ccipReadEnabled) {\n            tx.ccipReadEnabled = !!ro.ccipReadEnabled;\n        }\n        // Remove the overrides\n        delete overrides.nonce;\n        delete overrides.gasLimit;\n        delete overrides.gasPrice;\n        delete overrides.from;\n        delete overrides.value;\n        delete overrides.type;\n        delete overrides.accessList;\n        delete overrides.maxFeePerGas;\n        delete overrides.maxPriorityFeePerGas;\n        delete overrides.customData;\n        delete overrides.ccipReadEnabled;\n        // Make sure there are no stray overrides, which may indicate a\n        // typo or using an unsupported key.\n        const leftovers = Object.keys(overrides).filter((key) => (overrides[key] != null));\n        if (leftovers.length) {\n            logger.throwError(`cannot override ${leftovers.map((l) => JSON.stringify(l)).join(\",\")}`, Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"overrides\",\n                overrides: leftovers\n            });\n        }\n        return tx;\n    });\n}\nfunction buildPopulate(contract, fragment) {\n    return function (...args) {\n        return populateTransaction(contract, fragment, args);\n    };\n}\nfunction buildEstimate(contract, fragment) {\n    const signerOrProvider = (contract.signer || contract.provider);\n    return function (...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (!signerOrProvider) {\n                logger.throwError(\"estimate require a provider or signer\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"estimateGas\"\n                });\n            }\n            const tx = yield populateTransaction(contract, fragment, args);\n            return yield signerOrProvider.estimateGas(tx);\n        });\n    };\n}\nfunction addContractWait(contract, tx) {\n    const wait = tx.wait.bind(tx);\n    tx.wait = (confirmations) => {\n        return wait(confirmations).then((receipt) => {\n            receipt.events = receipt.logs.map((log) => {\n                let event = deepCopy(log);\n                let parsed = null;\n                try {\n                    parsed = contract.interface.parseLog(log);\n                }\n                catch (e) { }\n                // Successfully parsed the event log; include it\n                if (parsed) {\n                    event.args = parsed.args;\n                    event.decode = (data, topics) => {\n                        return contract.interface.decodeEventLog(parsed.eventFragment, data, topics);\n                    };\n                    event.event = parsed.name;\n                    event.eventSignature = parsed.signature;\n                }\n                // Useful operations\n                event.removeListener = () => { return contract.provider; };\n                event.getBlock = () => {\n                    return contract.provider.getBlock(receipt.blockHash);\n                };\n                event.getTransaction = () => {\n                    return contract.provider.getTransaction(receipt.transactionHash);\n                };\n                event.getTransactionReceipt = () => {\n                    return Promise.resolve(receipt);\n                };\n                return event;\n            });\n            return receipt;\n        });\n    };\n}\nfunction buildCall(contract, fragment, collapseSimple) {\n    const signerOrProvider = (contract.signer || contract.provider);\n    return function (...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Extract the \"blockTag\" override if present\n            let blockTag = undefined;\n            if (args.length === fragment.inputs.length + 1 && typeof (args[args.length - 1]) === \"object\") {\n                const overrides = shallowCopy(args.pop());\n                if (overrides.blockTag != null) {\n                    blockTag = yield overrides.blockTag;\n                }\n                delete overrides.blockTag;\n                args.push(overrides);\n            }\n            // If the contract was just deployed, wait until it is mined\n            if (contract.deployTransaction != null) {\n                yield contract._deployed(blockTag);\n            }\n            // Call a node and get the result\n            const tx = yield populateTransaction(contract, fragment, args);\n            const result = yield signerOrProvider.call(tx, blockTag);\n            try {\n                let value = contract.interface.decodeFunctionResult(fragment, result);\n                if (collapseSimple && fragment.outputs.length === 1) {\n                    value = value[0];\n                }\n                return value;\n            }\n            catch (error) {\n                if (error.code === Logger.errors.CALL_EXCEPTION) {\n                    error.address = contract.address;\n                    error.args = args;\n                    error.transaction = tx;\n                }\n                throw error;\n            }\n        });\n    };\n}\nfunction buildSend(contract, fragment) {\n    return function (...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (!contract.signer) {\n                logger.throwError(\"sending a transaction requires a signer\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"sendTransaction\"\n                });\n            }\n            // If the contract was just deployed, wait until it is mined\n            if (contract.deployTransaction != null) {\n                yield contract._deployed();\n            }\n            const txRequest = yield populateTransaction(contract, fragment, args);\n            const tx = yield contract.signer.sendTransaction(txRequest);\n            // Tweak the tx.wait so the receipt has extra properties\n            addContractWait(contract, tx);\n            return tx;\n        });\n    };\n}\nfunction buildDefault(contract, fragment, collapseSimple) {\n    if (fragment.constant) {\n        return buildCall(contract, fragment, collapseSimple);\n    }\n    return buildSend(contract, fragment);\n}\nfunction getEventTag(filter) {\n    if (filter.address && (filter.topics == null || filter.topics.length === 0)) {\n        return \"*\";\n    }\n    return (filter.address || \"*\") + \"@\" + (filter.topics ? filter.topics.map((topic) => {\n        if (Array.isArray(topic)) {\n            return topic.join(\"|\");\n        }\n        return topic;\n    }).join(\":\") : \"\");\n}\nclass RunningEvent {\n    constructor(tag, filter) {\n        defineReadOnly(this, \"tag\", tag);\n        defineReadOnly(this, \"filter\", filter);\n        this._listeners = [];\n    }\n    addListener(listener, once) {\n        this._listeners.push({ listener: listener, once: once });\n    }\n    removeListener(listener) {\n        let done = false;\n        this._listeners = this._listeners.filter((item) => {\n            if (done || item.listener !== listener) {\n                return true;\n            }\n            done = true;\n            return false;\n        });\n    }\n    removeAllListeners() {\n        this._listeners = [];\n    }\n    listeners() {\n        return this._listeners.map((i) => i.listener);\n    }\n    listenerCount() {\n        return this._listeners.length;\n    }\n    run(args) {\n        const listenerCount = this.listenerCount();\n        this._listeners = this._listeners.filter((item) => {\n            const argsCopy = args.slice();\n            // Call the callback in the next event loop\n            setTimeout(() => {\n                item.listener.apply(this, argsCopy);\n            }, 0);\n            // Reschedule it if it not \"once\"\n            return !(item.once);\n        });\n        return listenerCount;\n    }\n    prepareEvent(event) {\n    }\n    // Returns the array that will be applied to an emit\n    getEmit(event) {\n        return [event];\n    }\n}\nclass ErrorRunningEvent extends RunningEvent {\n    constructor() {\n        super(\"error\", null);\n    }\n}\n// @TODO Fragment should inherit Wildcard? and just override getEmit?\n//       or have a common abstract super class, with enough constructor\n//       options to configure both.\n// A Fragment Event will populate all the properties that Wildcard\n// will, and additionally dereference the arguments when emitting\nclass FragmentRunningEvent extends RunningEvent {\n    constructor(address, contractInterface, fragment, topics) {\n        const filter = {\n            address: address\n        };\n        let topic = contractInterface.getEventTopic(fragment);\n        if (topics) {\n            if (topic !== topics[0]) {\n                logger.throwArgumentError(\"topic mismatch\", \"topics\", topics);\n            }\n            filter.topics = topics.slice();\n        }\n        else {\n            filter.topics = [topic];\n        }\n        super(getEventTag(filter), filter);\n        defineReadOnly(this, \"address\", address);\n        defineReadOnly(this, \"interface\", contractInterface);\n        defineReadOnly(this, \"fragment\", fragment);\n    }\n    prepareEvent(event) {\n        super.prepareEvent(event);\n        event.event = this.fragment.name;\n        event.eventSignature = this.fragment.format();\n        event.decode = (data, topics) => {\n            return this.interface.decodeEventLog(this.fragment, data, topics);\n        };\n        try {\n            event.args = this.interface.decodeEventLog(this.fragment, event.data, event.topics);\n        }\n        catch (error) {\n            event.args = null;\n            event.decodeError = error;\n        }\n    }\n    getEmit(event) {\n        const errors = checkResultErrors(event.args);\n        if (errors.length) {\n            throw errors[0].error;\n        }\n        const args = (event.args || []).slice();\n        args.push(event);\n        return args;\n    }\n}\n// A Wildcard Event will attempt to populate:\n//  - event            The name of the event name\n//  - eventSignature   The full signature of the event\n//  - decode           A function to decode data and topics\n//  - args             The decoded data and topics\nclass WildcardRunningEvent extends RunningEvent {\n    constructor(address, contractInterface) {\n        super(\"*\", { address: address });\n        defineReadOnly(this, \"address\", address);\n        defineReadOnly(this, \"interface\", contractInterface);\n    }\n    prepareEvent(event) {\n        super.prepareEvent(event);\n        try {\n            const parsed = this.interface.parseLog(event);\n            event.event = parsed.name;\n            event.eventSignature = parsed.signature;\n            event.decode = (data, topics) => {\n                return this.interface.decodeEventLog(parsed.eventFragment, data, topics);\n            };\n            event.args = parsed.args;\n        }\n        catch (error) {\n            // No matching event\n        }\n    }\n}\nexport class BaseContract {\n    constructor(addressOrName, contractInterface, signerOrProvider) {\n        logger.checkNew(new.target, Contract);\n        // @TODO: Maybe still check the addressOrName looks like a valid address or name?\n        //address = getAddress(address);\n        defineReadOnly(this, \"interface\", getStatic(new.target, \"getInterface\")(contractInterface));\n        if (signerOrProvider == null) {\n            defineReadOnly(this, \"provider\", null);\n            defineReadOnly(this, \"signer\", null);\n        }\n        else if (Signer.isSigner(signerOrProvider)) {\n            defineReadOnly(this, \"provider\", signerOrProvider.provider || null);\n            defineReadOnly(this, \"signer\", signerOrProvider);\n        }\n        else if (Provider.isProvider(signerOrProvider)) {\n            defineReadOnly(this, \"provider\", signerOrProvider);\n            defineReadOnly(this, \"signer\", null);\n        }\n        else {\n            logger.throwArgumentError(\"invalid signer or provider\", \"signerOrProvider\", signerOrProvider);\n        }\n        defineReadOnly(this, \"callStatic\", {});\n        defineReadOnly(this, \"estimateGas\", {});\n        defineReadOnly(this, \"functions\", {});\n        defineReadOnly(this, \"populateTransaction\", {});\n        defineReadOnly(this, \"filters\", {});\n        {\n            const uniqueFilters = {};\n            Object.keys(this.interface.events).forEach((eventSignature) => {\n                const event = this.interface.events[eventSignature];\n                defineReadOnly(this.filters, eventSignature, (...args) => {\n                    return {\n                        address: this.address,\n                        topics: this.interface.encodeFilterTopics(event, args)\n                    };\n                });\n                if (!uniqueFilters[event.name]) {\n                    uniqueFilters[event.name] = [];\n                }\n                uniqueFilters[event.name].push(eventSignature);\n            });\n            Object.keys(uniqueFilters).forEach((name) => {\n                const filters = uniqueFilters[name];\n                if (filters.length === 1) {\n                    defineReadOnly(this.filters, name, this.filters[filters[0]]);\n                }\n                else {\n                    logger.warn(`Duplicate definition of ${name} (${filters.join(\", \")})`);\n                }\n            });\n        }\n        defineReadOnly(this, \"_runningEvents\", {});\n        defineReadOnly(this, \"_wrappedEmits\", {});\n        if (addressOrName == null) {\n            logger.throwArgumentError(\"invalid contract address or ENS name\", \"addressOrName\", addressOrName);\n        }\n        defineReadOnly(this, \"address\", addressOrName);\n        if (this.provider) {\n            defineReadOnly(this, \"resolvedAddress\", resolveName(this.provider, addressOrName));\n        }\n        else {\n            try {\n                defineReadOnly(this, \"resolvedAddress\", Promise.resolve(getAddress(addressOrName)));\n            }\n            catch (error) {\n                // Without a provider, we cannot use ENS names\n                logger.throwError(\"provider is required to use ENS name as contract address\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"new Contract\"\n                });\n            }\n        }\n        // Swallow bad ENS names to prevent Unhandled Exceptions\n        this.resolvedAddress.catch((e) => { });\n        const uniqueNames = {};\n        const uniqueSignatures = {};\n        Object.keys(this.interface.functions).forEach((signature) => {\n            const fragment = this.interface.functions[signature];\n            // Check that the signature is unique; if not the ABI generation has\n            // not been cleaned or may be incorrectly generated\n            if (uniqueSignatures[signature]) {\n                logger.warn(`Duplicate ABI entry for ${JSON.stringify(signature)}`);\n                return;\n            }\n            uniqueSignatures[signature] = true;\n            // Track unique names; we only expose bare named functions if they\n            // are ambiguous\n            {\n                const name = fragment.name;\n                if (!uniqueNames[`%${name}`]) {\n                    uniqueNames[`%${name}`] = [];\n                }\n                uniqueNames[`%${name}`].push(signature);\n            }\n            if (this[signature] == null) {\n                defineReadOnly(this, signature, buildDefault(this, fragment, true));\n            }\n            // We do not collapse simple calls on this bucket, which allows\n            // frameworks to safely use this without introspection as well as\n            // allows decoding error recovery.\n            if (this.functions[signature] == null) {\n                defineReadOnly(this.functions, signature, buildDefault(this, fragment, false));\n            }\n            if (this.callStatic[signature] == null) {\n                defineReadOnly(this.callStatic, signature, buildCall(this, fragment, true));\n            }\n            if (this.populateTransaction[signature] == null) {\n                defineReadOnly(this.populateTransaction, signature, buildPopulate(this, fragment));\n            }\n            if (this.estimateGas[signature] == null) {\n                defineReadOnly(this.estimateGas, signature, buildEstimate(this, fragment));\n            }\n        });\n        Object.keys(uniqueNames).forEach((name) => {\n            // Ambiguous names to not get attached as bare names\n            const signatures = uniqueNames[name];\n            if (signatures.length > 1) {\n                return;\n            }\n            // Strip off the leading \"%\" used for prototype protection\n            name = name.substring(1);\n            const signature = signatures[0];\n            // If overwriting a member property that is null, swallow the error\n            try {\n                if (this[name] == null) {\n                    defineReadOnly(this, name, this[signature]);\n                }\n            }\n            catch (e) { }\n            if (this.functions[name] == null) {\n                defineReadOnly(this.functions, name, this.functions[signature]);\n            }\n            if (this.callStatic[name] == null) {\n                defineReadOnly(this.callStatic, name, this.callStatic[signature]);\n            }\n            if (this.populateTransaction[name] == null) {\n                defineReadOnly(this.populateTransaction, name, this.populateTransaction[signature]);\n            }\n            if (this.estimateGas[name] == null) {\n                defineReadOnly(this.estimateGas, name, this.estimateGas[signature]);\n            }\n        });\n    }\n    static getContractAddress(transaction) {\n        return getContractAddress(transaction);\n    }\n    static getInterface(contractInterface) {\n        if (Interface.isInterface(contractInterface)) {\n            return contractInterface;\n        }\n        return new Interface(contractInterface);\n    }\n    // @TODO: Allow timeout?\n    deployed() {\n        return this._deployed();\n    }\n    _deployed(blockTag) {\n        if (!this._deployedPromise) {\n            // If we were just deployed, we know the transaction we should occur in\n            if (this.deployTransaction) {\n                this._deployedPromise = this.deployTransaction.wait().then(() => {\n                    return this;\n                });\n            }\n            else {\n                // @TODO: Once we allow a timeout to be passed in, we will wait\n                // up to that many blocks for getCode\n                // Otherwise, poll for our code to be deployed\n                this._deployedPromise = this.provider.getCode(this.address, blockTag).then((code) => {\n                    if (code === \"0x\") {\n                        logger.throwError(\"contract not deployed\", Logger.errors.UNSUPPORTED_OPERATION, {\n                            contractAddress: this.address,\n                            operation: \"getDeployed\"\n                        });\n                    }\n                    return this;\n                });\n            }\n        }\n        return this._deployedPromise;\n    }\n    // @TODO:\n    // estimateFallback(overrides?: TransactionRequest): Promise<BigNumber>\n    // @TODO:\n    // estimateDeploy(bytecode: string, ...args): Promise<BigNumber>\n    fallback(overrides) {\n        if (!this.signer) {\n            logger.throwError(\"sending a transactions require a signer\", Logger.errors.UNSUPPORTED_OPERATION, { operation: \"sendTransaction(fallback)\" });\n        }\n        const tx = shallowCopy(overrides || {});\n        [\"from\", \"to\"].forEach(function (key) {\n            if (tx[key] == null) {\n                return;\n            }\n            logger.throwError(\"cannot override \" + key, Logger.errors.UNSUPPORTED_OPERATION, { operation: key });\n        });\n        tx.to = this.resolvedAddress;\n        return this.deployed().then(() => {\n            return this.signer.sendTransaction(tx);\n        });\n    }\n    // Reconnect to a different signer or provider\n    connect(signerOrProvider) {\n        if (typeof (signerOrProvider) === \"string\") {\n            signerOrProvider = new VoidSigner(signerOrProvider, this.provider);\n        }\n        const contract = new (this.constructor)(this.address, this.interface, signerOrProvider);\n        if (this.deployTransaction) {\n            defineReadOnly(contract, \"deployTransaction\", this.deployTransaction);\n        }\n        return contract;\n    }\n    // Re-attach to a different on-chain instance of this contract\n    attach(addressOrName) {\n        return new (this.constructor)(addressOrName, this.interface, this.signer || this.provider);\n    }\n    static isIndexed(value) {\n        return Indexed.isIndexed(value);\n    }\n    _normalizeRunningEvent(runningEvent) {\n        // Already have an instance of this event running; we can re-use it\n        if (this._runningEvents[runningEvent.tag]) {\n            return this._runningEvents[runningEvent.tag];\n        }\n        return runningEvent;\n    }\n    _getRunningEvent(eventName) {\n        if (typeof (eventName) === \"string\") {\n            // Listen for \"error\" events (if your contract has an error event, include\n            // the full signature to bypass this special event keyword)\n            if (eventName === \"error\") {\n                return this._normalizeRunningEvent(new ErrorRunningEvent());\n            }\n            // Listen for any event that is registered\n            if (eventName === \"event\") {\n                return this._normalizeRunningEvent(new RunningEvent(\"event\", null));\n            }\n            // Listen for any event\n            if (eventName === \"*\") {\n                return this._normalizeRunningEvent(new WildcardRunningEvent(this.address, this.interface));\n            }\n            // Get the event Fragment (throws if ambiguous/unknown event)\n            const fragment = this.interface.getEvent(eventName);\n            return this._normalizeRunningEvent(new FragmentRunningEvent(this.address, this.interface, fragment));\n        }\n        // We have topics to filter by...\n        if (eventName.topics && eventName.topics.length > 0) {\n            // Is it a known topichash? (throws if no matching topichash)\n            try {\n                const topic = eventName.topics[0];\n                if (typeof (topic) !== \"string\") {\n                    throw new Error(\"invalid topic\"); // @TODO: May happen for anonymous events\n                }\n                const fragment = this.interface.getEvent(topic);\n                return this._normalizeRunningEvent(new FragmentRunningEvent(this.address, this.interface, fragment, eventName.topics));\n            }\n            catch (error) { }\n            // Filter by the unknown topichash\n            const filter = {\n                address: this.address,\n                topics: eventName.topics\n            };\n            return this._normalizeRunningEvent(new RunningEvent(getEventTag(filter), filter));\n        }\n        return this._normalizeRunningEvent(new WildcardRunningEvent(this.address, this.interface));\n    }\n    _checkRunningEvents(runningEvent) {\n        if (runningEvent.listenerCount() === 0) {\n            delete this._runningEvents[runningEvent.tag];\n            // If we have a poller for this, remove it\n            const emit = this._wrappedEmits[runningEvent.tag];\n            if (emit && runningEvent.filter) {\n                this.provider.off(runningEvent.filter, emit);\n                delete this._wrappedEmits[runningEvent.tag];\n            }\n        }\n    }\n    // Subclasses can override this to gracefully recover\n    // from parse errors if they wish\n    _wrapEvent(runningEvent, log, listener) {\n        const event = deepCopy(log);\n        event.removeListener = () => {\n            if (!listener) {\n                return;\n            }\n            runningEvent.removeListener(listener);\n            this._checkRunningEvents(runningEvent);\n        };\n        event.getBlock = () => { return this.provider.getBlock(log.blockHash); };\n        event.getTransaction = () => { return this.provider.getTransaction(log.transactionHash); };\n        event.getTransactionReceipt = () => { return this.provider.getTransactionReceipt(log.transactionHash); };\n        // This may throw if the topics and data mismatch the signature\n        runningEvent.prepareEvent(event);\n        return event;\n    }\n    _addEventListener(runningEvent, listener, once) {\n        if (!this.provider) {\n            logger.throwError(\"events require a provider or a signer with a provider\", Logger.errors.UNSUPPORTED_OPERATION, { operation: \"once\" });\n        }\n        runningEvent.addListener(listener, once);\n        // Track this running event and its listeners (may already be there; but no hard in updating)\n        this._runningEvents[runningEvent.tag] = runningEvent;\n        // If we are not polling the provider, start polling\n        if (!this._wrappedEmits[runningEvent.tag]) {\n            const wrappedEmit = (log) => {\n                let event = this._wrapEvent(runningEvent, log, listener);\n                // Try to emit the result for the parameterized event...\n                if (event.decodeError == null) {\n                    try {\n                        const args = runningEvent.getEmit(event);\n                        this.emit(runningEvent.filter, ...args);\n                    }\n                    catch (error) {\n                        event.decodeError = error.error;\n                    }\n                }\n                // Always emit \"event\" for fragment-base events\n                if (runningEvent.filter != null) {\n                    this.emit(\"event\", event);\n                }\n                // Emit \"error\" if there was an error\n                if (event.decodeError != null) {\n                    this.emit(\"error\", event.decodeError, event);\n                }\n            };\n            this._wrappedEmits[runningEvent.tag] = wrappedEmit;\n            // Special events, like \"error\" do not have a filter\n            if (runningEvent.filter != null) {\n                this.provider.on(runningEvent.filter, wrappedEmit);\n            }\n        }\n    }\n    queryFilter(event, fromBlockOrBlockhash, toBlock) {\n        const runningEvent = this._getRunningEvent(event);\n        const filter = shallowCopy(runningEvent.filter);\n        if (typeof (fromBlockOrBlockhash) === \"string\" && isHexString(fromBlockOrBlockhash, 32)) {\n            if (toBlock != null) {\n                logger.throwArgumentError(\"cannot specify toBlock with blockhash\", \"toBlock\", toBlock);\n            }\n            filter.blockHash = fromBlockOrBlockhash;\n        }\n        else {\n            filter.fromBlock = ((fromBlockOrBlockhash != null) ? fromBlockOrBlockhash : 0);\n            filter.toBlock = ((toBlock != null) ? toBlock : \"latest\");\n        }\n        return this.provider.getLogs(filter).then((logs) => {\n            return logs.map((log) => this._wrapEvent(runningEvent, log, null));\n        });\n    }\n    on(event, listener) {\n        this._addEventListener(this._getRunningEvent(event), listener, false);\n        return this;\n    }\n    once(event, listener) {\n        this._addEventListener(this._getRunningEvent(event), listener, true);\n        return this;\n    }\n    emit(eventName, ...args) {\n        if (!this.provider) {\n            return false;\n        }\n        const runningEvent = this._getRunningEvent(eventName);\n        const result = (runningEvent.run(args) > 0);\n        // May have drained all the \"once\" events; check for living events\n        this._checkRunningEvents(runningEvent);\n        return result;\n    }\n    listenerCount(eventName) {\n        if (!this.provider) {\n            return 0;\n        }\n        if (eventName == null) {\n            return Object.keys(this._runningEvents).reduce((accum, key) => {\n                return accum + this._runningEvents[key].listenerCount();\n            }, 0);\n        }\n        return this._getRunningEvent(eventName).listenerCount();\n    }\n    listeners(eventName) {\n        if (!this.provider) {\n            return [];\n        }\n        if (eventName == null) {\n            const result = [];\n            for (let tag in this._runningEvents) {\n                this._runningEvents[tag].listeners().forEach((listener) => {\n                    result.push(listener);\n                });\n            }\n            return result;\n        }\n        return this._getRunningEvent(eventName).listeners();\n    }\n    removeAllListeners(eventName) {\n        if (!this.provider) {\n            return this;\n        }\n        if (eventName == null) {\n            for (const tag in this._runningEvents) {\n                const runningEvent = this._runningEvents[tag];\n                runningEvent.removeAllListeners();\n                this._checkRunningEvents(runningEvent);\n            }\n            return this;\n        }\n        // Delete any listeners\n        const runningEvent = this._getRunningEvent(eventName);\n        runningEvent.removeAllListeners();\n        this._checkRunningEvents(runningEvent);\n        return this;\n    }\n    off(eventName, listener) {\n        if (!this.provider) {\n            return this;\n        }\n        const runningEvent = this._getRunningEvent(eventName);\n        runningEvent.removeListener(listener);\n        this._checkRunningEvents(runningEvent);\n        return this;\n    }\n    removeListener(eventName, listener) {\n        return this.off(eventName, listener);\n    }\n}\nexport class Contract extends BaseContract {\n}\nexport class ContractFactory {\n    constructor(contractInterface, bytecode, signer) {\n        let bytecodeHex = null;\n        if (typeof (bytecode) === \"string\") {\n            bytecodeHex = bytecode;\n        }\n        else if (isBytes(bytecode)) {\n            bytecodeHex = hexlify(bytecode);\n        }\n        else if (bytecode && typeof (bytecode.object) === \"string\") {\n            // Allow the bytecode object from the Solidity compiler\n            bytecodeHex = bytecode.object;\n        }\n        else {\n            // Crash in the next verification step\n            bytecodeHex = \"!\";\n        }\n        // Make sure it is 0x prefixed\n        if (bytecodeHex.substring(0, 2) !== \"0x\") {\n            bytecodeHex = \"0x\" + bytecodeHex;\n        }\n        // Make sure the final result is valid bytecode\n        if (!isHexString(bytecodeHex) || (bytecodeHex.length % 2)) {\n            logger.throwArgumentError(\"invalid bytecode\", \"bytecode\", bytecode);\n        }\n        // If we have a signer, make sure it is valid\n        if (signer && !Signer.isSigner(signer)) {\n            logger.throwArgumentError(\"invalid signer\", \"signer\", signer);\n        }\n        defineReadOnly(this, \"bytecode\", bytecodeHex);\n        defineReadOnly(this, \"interface\", getStatic(new.target, \"getInterface\")(contractInterface));\n        defineReadOnly(this, \"signer\", signer || null);\n    }\n    // @TODO: Future; rename to populateTransaction?\n    getDeployTransaction(...args) {\n        let tx = {};\n        // If we have 1 additional argument, we allow transaction overrides\n        if (args.length === this.interface.deploy.inputs.length + 1 && typeof (args[args.length - 1]) === \"object\") {\n            tx = shallowCopy(args.pop());\n            for (const key in tx) {\n                if (!allowedTransactionKeys[key]) {\n                    throw new Error(\"unknown transaction override \" + key);\n                }\n            }\n        }\n        // Do not allow these to be overridden in a deployment transaction\n        [\"data\", \"from\", \"to\"].forEach((key) => {\n            if (tx[key] == null) {\n                return;\n            }\n            logger.throwError(\"cannot override \" + key, Logger.errors.UNSUPPORTED_OPERATION, { operation: key });\n        });\n        if (tx.value) {\n            const value = BigNumber.from(tx.value);\n            if (!value.isZero() && !this.interface.deploy.payable) {\n                logger.throwError(\"non-payable constructor cannot override value\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"overrides.value\",\n                    value: tx.value\n                });\n            }\n        }\n        // Make sure the call matches the constructor signature\n        logger.checkArgumentCount(args.length, this.interface.deploy.inputs.length, \" in Contract constructor\");\n        // Set the data to the bytecode + the encoded constructor arguments\n        tx.data = hexlify(concat([\n            this.bytecode,\n            this.interface.encodeDeploy(args)\n        ]));\n        return tx;\n    }\n    deploy(...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let overrides = {};\n            // If 1 extra parameter was passed in, it contains overrides\n            if (args.length === this.interface.deploy.inputs.length + 1) {\n                overrides = args.pop();\n            }\n            // Make sure the call matches the constructor signature\n            logger.checkArgumentCount(args.length, this.interface.deploy.inputs.length, \" in Contract constructor\");\n            // Resolve ENS names and promises in the arguments\n            const params = yield resolveAddresses(this.signer, args, this.interface.deploy.inputs);\n            params.push(overrides);\n            // Get the deployment transaction (with optional overrides)\n            const unsignedTx = this.getDeployTransaction(...params);\n            // Send the deployment transaction\n            const tx = yield this.signer.sendTransaction(unsignedTx);\n            const address = getStatic(this.constructor, \"getContractAddress\")(tx);\n            const contract = getStatic(this.constructor, \"getContract\")(address, this.interface, this.signer);\n            // Add the modified wait that wraps events\n            addContractWait(contract, tx);\n            defineReadOnly(contract, \"deployTransaction\", tx);\n            return contract;\n        });\n    }\n    attach(address) {\n        return (this.constructor).getContract(address, this.interface, this.signer);\n    }\n    connect(signer) {\n        return new (this.constructor)(this.interface, this.bytecode, signer);\n    }\n    static fromSolidity(compilerOutput, signer) {\n        if (compilerOutput == null) {\n            logger.throwError(\"missing compiler output\", Logger.errors.MISSING_ARGUMENT, { argument: \"compilerOutput\" });\n        }\n        if (typeof (compilerOutput) === \"string\") {\n            compilerOutput = JSON.parse(compilerOutput);\n        }\n        const abi = compilerOutput.abi;\n        let bytecode = null;\n        if (compilerOutput.bytecode) {\n            bytecode = compilerOutput.bytecode;\n        }\n        else if (compilerOutput.evm && compilerOutput.evm.bytecode) {\n            bytecode = compilerOutput.evm.bytecode;\n        }\n        return new this(abi, bytecode, signer);\n    }\n    static getInterface(contractInterface) {\n        return Contract.getInterface(contractInterface);\n    }\n    static getContractAddress(tx) {\n        return getContractAddress(tx);\n    }\n    static getContract(address, contractInterface, signer) {\n        return new Contract(address, contractInterface, signer);\n    }\n}\n//# sourceMappingURL=index.js.map","export const version = \"contracts/5.6.0\";\n//# sourceMappingURL=_version.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})(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","export const version = \"logger/5.6.0\";\n//# sourceMappingURL=_version.js.map"],"sourceRoot":""}