{"version":3,"sources":["webpack:///./node_modules/@ethersproject/abi/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/base64/lib.esm/base64.js","webpack:///./node_modules/@ethersproject/basex/lib.esm/index.js","webpack:///./node_modules/@ethersproject/address/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/address/lib.esm/index.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/address.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/anonymous.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/array.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/boolean.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/bytes.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/fixed-bytes.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/null.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/number.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/string.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/coders/tuple.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/abi-coder.js","webpack:///./node_modules/@ethersproject/base64/lib.esm/index.js","webpack:///./node_modules/@ethersproject/abstract-signer/lib.esm/index.js","webpack:///./node_modules/@ethersproject/abstract-signer/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/interface.js","webpack:///./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack:///./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/@ethersproject/abi/lib.esm/fragments.js","webpack:///./node_modules/@ethersproject/abstract-provider/lib.esm/index.js","webpack:///./node_modules/@ethersproject/abstract-provider/lib.esm/_version.js"],"names":["e","version","decode","textData","atob","data","i","length","push","charCodeAt","encode","String","fromCharCode","btoa","BaseX","constructor","alphabet","this","charAt","_alphabetMap","value","source","digits","carry","j","base","string","k","_leader","q","TypeError","bytes","Uint8Array","byte","Error","reverse","Base58","logger","getChecksumAddress","address","throwArgumentError","chars","toLowerCase","substring","split","expanded","hashed","toUpperCase","join","ibanLookup","safeDigits","Math","floor","x","log10","log","LN10","ibanChecksum","map","c","block","parseInt","checksum","getAddress","result","match","isAddress","error","getIcapAddress","base36","getContractAddress","transaction","from","nonce","toHexString","getCreate2Address","salt","initCodeHash","checkResultErrors","errors","checkErrors","path","object","Array","isArray","key","childPath","slice","Coder","name","type","localName","dynamic","_throwError","message","Writer","wordSize","_data","_dataLength","_padding","_writeData","appendWriter","writer","writeBytes","paddingOffset","_getValue","throwError","BUFFER_OVERRUN","offset","writeValue","writeUpdatableValue","Reader","coerceFunc","allowLoose","_offset","consumed","static","toNumber","coerce","_coerceFunc","_peekBytes","loose","alignedLength","ceil","subReader","readBytes","readValue","super","defaultValue","reader","coder","pack","coders","values","arrayValues","unique","INVALID_ARGUMENT","argument","staticWriter","dynamicWriter","updateFuncs","forEach","index","dynamicOffset","updateFunc","baseOffset","func","unpack","baseReader","offsetReader","code","baseType","uniqueNames","reduce","accum","Object","defineProperty","enumerable","get","freeze","defaultChild","count","checkArgumentCount","isZero","size","signed","v","maxUintValue","mask","bounds","gt","lt","add","mul","toTwos","fromTwos","types","paramTypeBytes","RegExp","paramTypeNumber","_getCoder","param","arrayChildren","arrayLength","components","component","_getWordSize","_getReader","_getWriter","getDefaultValue","defaultAbiCoder","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","next","rejected","done","then","apply","allowedTransactionKeys","forwardErrors","INSUFFICIENT_FUNDS","NONCE_EXPIRED","REPLACEMENT_UNDERPRICED","checkAbstract","getBalance","blockTag","_checkProvider","provider","getTransactionCount","estimateGas","tx","checkTransaction","call","sendTransaction","populateTransaction","signedTx","signTransaction","getChainId","getNetwork","chainId","getGasPrice","getFeeData","resolveName","indexOf","all","to","catch","hasEip1559","maxFeePerGas","maxPriorityFeePerGas","gasPrice","feeData","UNSUPPORTED_OPERATION","operation","gasLimit","UNPREDICTABLE_GAS_LIMIT","results","_isSigner","_fail","signMessage","_signTypedData","domain","connect","LogDescription","TransactionDescription","ErrorDescription","Indexed","_isIndexed","BuiltinErrors","signature","inputs","reason","wrapAccessError","property","wrap","Interface","fragments","abi","JSON","parse","fragment","filter","bucket","deploy","warn","functions","events","format","payable","full","sighash","json","stringify","eventFragment","getFunction","nameOrSignatureOrSighash","getSighash","trim","matching","keys","f","fromString","getEvent","nameOrSignatureOrTopic","topichash","getEventTopic","getError","_","_decodeParams","params","_abiCoder","_encodeParams","encodeDeploy","decodeErrorResult","encodeErrorResult","decodeFunctionData","functionFragment","encodeFunctionData","decodeFunctionResult","errorArgs","errorName","errorSignature","outputs","selector","builtin","CALL_EXCEPTION","method","encodeFunctionResult","encodeFilterTopics","UNEXPECTED_ARGUMENT","topics","anonymous","encodeTopic","indexed","pop","encodeEventLog","dataTypes","dataValues","decodeEventLog","topicHash","expected","nonIndexed","fromObject","resultIndexed","resultNonIndexed","nonIndexedIndex","indexedIndex","hash","parseTransaction","args","parseLog","topic","parseError","hexData","errorFragment","_isInterface","_typeof","obj","Symbol","iterator","prototype","_toPropertyKey","arg","input","hint","prim","toPrimitive","res","Number","_defineProperty","toPropertyKey","configurable","writable","_constructorGuard","ModifiersBytes","calldata","memory","storage","ModifiersNest","checkModifier","populate","FormatTypes","minimal","paramTypeArray","ParamType","constructorGuard","_isParamType","comp","allowIndexed","isParamType","verifyType","node","ParamTypify","originalParam","newNode","parent","state","allowType","replace","allowParams","child","allowName","allowArray","sibling","readArray","parseParamType","parseParams","allowIndex","depth","splitNesting","Fragment","_isFragment","isFragment","FunctionFragment","EventFragment","ConstructorFragment","ErrorFragment","isEventFragment","verifyIdentifier","regexParen","modifier","parseGas","gas","comps","parseModifiers","constant","stateMutability","console","verifyState","isConstructorFragment","parens","output","toString","isFunctionFragment","returns","checkForbidden","sig","isErrorFragment","regexIdentifier","_isForkEvent","getBlock","lastBaseFeePerGas","baseFeePerGas","addListener","eventName","listener","on","removeListener","off","_isProvider"],"mappings":"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","file":"js/chunk-vendors~0f485567.bee664b0.js","sourcesContent":["export const version = \"abi/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { arrayify } from \"@ethersproject/bytes\";\nexport function decode(textData) {\n    textData = atob(textData);\n    const data = [];\n    for (let i = 0; i < textData.length; i++) {\n        data.push(textData.charCodeAt(i));\n    }\n    return arrayify(data);\n}\nexport function encode(data) {\n    data = arrayify(data);\n    let textData = \"\";\n    for (let i = 0; i < data.length; i++) {\n        textData += String.fromCharCode(data[i]);\n    }\n    return btoa(textData);\n}\n//# sourceMappingURL=base64.js.map","/**\n * var basex = require(\"base-x\");\n *\n * This implementation is heavily based on base-x. The main reason to\n * deviate was to prevent the dependency of Buffer.\n *\n * Contributors:\n *\n * base-x encoding\n * Forked from https://github.com/cryptocoinjs/bs58\n * Originally written by Mike Hearn for BitcoinJ\n * Copyright (c) 2011 Google Inc\n * Ported to JavaScript by Stefan Thomas\n * Merged Buffer refactorings from base58-native by Stephen Pair\n * Copyright (c) 2013 BitPay Inc\n *\n * The MIT License (MIT)\n *\n * Copyright base-x contributors (c) 2016\n *\n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n *\n */\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nexport class BaseX {\n    constructor(alphabet) {\n        defineReadOnly(this, \"alphabet\", alphabet);\n        defineReadOnly(this, \"base\", alphabet.length);\n        defineReadOnly(this, \"_alphabetMap\", {});\n        defineReadOnly(this, \"_leader\", alphabet.charAt(0));\n        // pre-compute lookup table\n        for (let i = 0; i < alphabet.length; i++) {\n            this._alphabetMap[alphabet.charAt(i)] = i;\n        }\n    }\n    encode(value) {\n        let source = arrayify(value);\n        if (source.length === 0) {\n            return \"\";\n        }\n        let digits = [0];\n        for (let i = 0; i < source.length; ++i) {\n            let carry = source[i];\n            for (let j = 0; j < digits.length; ++j) {\n                carry += digits[j] << 8;\n                digits[j] = carry % this.base;\n                carry = (carry / this.base) | 0;\n            }\n            while (carry > 0) {\n                digits.push(carry % this.base);\n                carry = (carry / this.base) | 0;\n            }\n        }\n        let string = \"\";\n        // deal with leading zeros\n        for (let k = 0; source[k] === 0 && k < source.length - 1; ++k) {\n            string += this._leader;\n        }\n        // convert digits to a string\n        for (let q = digits.length - 1; q >= 0; --q) {\n            string += this.alphabet[digits[q]];\n        }\n        return string;\n    }\n    decode(value) {\n        if (typeof (value) !== \"string\") {\n            throw new TypeError(\"Expected String\");\n        }\n        let bytes = [];\n        if (value.length === 0) {\n            return new Uint8Array(bytes);\n        }\n        bytes.push(0);\n        for (let i = 0; i < value.length; i++) {\n            let byte = this._alphabetMap[value[i]];\n            if (byte === undefined) {\n                throw new Error(\"Non-base\" + this.base + \" character\");\n            }\n            let carry = byte;\n            for (let j = 0; j < bytes.length; ++j) {\n                carry += bytes[j] * this.base;\n                bytes[j] = carry & 0xff;\n                carry >>= 8;\n            }\n            while (carry > 0) {\n                bytes.push(carry & 0xff);\n                carry >>= 8;\n            }\n        }\n        // deal with leading zeros\n        for (let k = 0; value[k] === this._leader && k < value.length - 1; ++k) {\n            bytes.push(0);\n        }\n        return arrayify(new Uint8Array(bytes.reverse()));\n    }\n}\nconst Base32 = new BaseX(\"abcdefghijklmnopqrstuvwxyz234567\");\nconst Base58 = new BaseX(\"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\");\nexport { Base32, Base58 };\n//console.log(Base58.decode(\"Qmd2V777o5XvJbYMeMb8k2nU5f8d3ciUQ5YpYuWhzv8iDj\"))\n//console.log(Base58.encode(Base58.decode(\"Qmd2V777o5XvJbYMeMb8k2nU5f8d3ciUQ5YpYuWhzv8iDj\")))\n//# sourceMappingURL=index.js.map","export const version = \"address/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { arrayify, concat, hexDataLength, hexDataSlice, isHexString, stripZeros } from \"@ethersproject/bytes\";\nimport { BigNumber, _base16To36, _base36To16 } from \"@ethersproject/bignumber\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { encode } from \"@ethersproject/rlp\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nfunction getChecksumAddress(address) {\n    if (!isHexString(address, 20)) {\n        logger.throwArgumentError(\"invalid address\", \"address\", address);\n    }\n    address = address.toLowerCase();\n    const chars = address.substring(2).split(\"\");\n    const expanded = new Uint8Array(40);\n    for (let i = 0; i < 40; i++) {\n        expanded[i] = chars[i].charCodeAt(0);\n    }\n    const hashed = arrayify(keccak256(expanded));\n    for (let i = 0; i < 40; i += 2) {\n        if ((hashed[i >> 1] >> 4) >= 8) {\n            chars[i] = chars[i].toUpperCase();\n        }\n        if ((hashed[i >> 1] & 0x0f) >= 8) {\n            chars[i + 1] = chars[i + 1].toUpperCase();\n        }\n    }\n    return \"0x\" + chars.join(\"\");\n}\n// Shims for environments that are missing some required constants and functions\nconst MAX_SAFE_INTEGER = 0x1fffffffffffff;\nfunction log10(x) {\n    if (Math.log10) {\n        return Math.log10(x);\n    }\n    return Math.log(x) / Math.LN10;\n}\n// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number\n// Create lookup table\nconst ibanLookup = {};\nfor (let i = 0; i < 10; i++) {\n    ibanLookup[String(i)] = String(i);\n}\nfor (let i = 0; i < 26; i++) {\n    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);\n}\n// How many decimal digits can we process? (for 64-bit float, this is 15)\nconst safeDigits = Math.floor(log10(MAX_SAFE_INTEGER));\nfunction ibanChecksum(address) {\n    address = address.toUpperCase();\n    address = address.substring(4) + address.substring(0, 2) + \"00\";\n    let expanded = address.split(\"\").map((c) => { return ibanLookup[c]; }).join(\"\");\n    // Javascript can handle integers safely up to 15 (decimal) digits\n    while (expanded.length >= safeDigits) {\n        let block = expanded.substring(0, safeDigits);\n        expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);\n    }\n    let checksum = String(98 - (parseInt(expanded, 10) % 97));\n    while (checksum.length < 2) {\n        checksum = \"0\" + checksum;\n    }\n    return checksum;\n}\n;\nexport function getAddress(address) {\n    let result = null;\n    if (typeof (address) !== \"string\") {\n        logger.throwArgumentError(\"invalid address\", \"address\", address);\n    }\n    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {\n        // Missing the 0x prefix\n        if (address.substring(0, 2) !== \"0x\") {\n            address = \"0x\" + address;\n        }\n        result = getChecksumAddress(address);\n        // It is a checksummed address with a bad checksum\n        if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) {\n            logger.throwArgumentError(\"bad address checksum\", \"address\", address);\n        }\n        // Maybe ICAP? (we only support direct mode)\n    }\n    else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {\n        // It is an ICAP address with a bad checksum\n        if (address.substring(2, 4) !== ibanChecksum(address)) {\n            logger.throwArgumentError(\"bad icap checksum\", \"address\", address);\n        }\n        result = _base36To16(address.substring(4));\n        while (result.length < 40) {\n            result = \"0\" + result;\n        }\n        result = getChecksumAddress(\"0x\" + result);\n    }\n    else {\n        logger.throwArgumentError(\"invalid address\", \"address\", address);\n    }\n    return result;\n}\nexport function isAddress(address) {\n    try {\n        getAddress(address);\n        return true;\n    }\n    catch (error) { }\n    return false;\n}\nexport function getIcapAddress(address) {\n    let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase();\n    while (base36.length < 30) {\n        base36 = \"0\" + base36;\n    }\n    return \"XE\" + ibanChecksum(\"XE00\" + base36) + base36;\n}\n// http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed\nexport function getContractAddress(transaction) {\n    let from = null;\n    try {\n        from = getAddress(transaction.from);\n    }\n    catch (error) {\n        logger.throwArgumentError(\"missing from address\", \"transaction\", transaction);\n    }\n    const nonce = stripZeros(arrayify(BigNumber.from(transaction.nonce).toHexString()));\n    return getAddress(hexDataSlice(keccak256(encode([from, nonce])), 12));\n}\nexport function getCreate2Address(from, salt, initCodeHash) {\n    if (hexDataLength(salt) !== 32) {\n        logger.throwArgumentError(\"salt must be 32 bytes\", \"salt\", salt);\n    }\n    if (hexDataLength(initCodeHash) !== 32) {\n        logger.throwArgumentError(\"initCodeHash must be 32 bytes\", \"initCodeHash\", initCodeHash);\n    }\n    return getAddress(hexDataSlice(keccak256(concat([\"0xff\", getAddress(from), salt, initCodeHash])), 12));\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\nimport { arrayify, concat, hexConcat, hexlify } from \"@ethersproject/bytes\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"../_version\";\nconst logger = new Logger(version);\nexport function checkResultErrors(result) {\n    // Find the first error (if any)\n    const errors = [];\n    const checkErrors = function (path, object) {\n        if (!Array.isArray(object)) {\n            return;\n        }\n        for (let key in object) {\n            const childPath = path.slice();\n            childPath.push(key);\n            try {\n                checkErrors(childPath, object[key]);\n            }\n            catch (error) {\n                errors.push({ path: childPath, error: error });\n            }\n        }\n    };\n    checkErrors([], result);\n    return errors;\n}\nexport class Coder {\n    constructor(name, type, localName, dynamic) {\n        // @TODO: defineReadOnly these\n        this.name = name;\n        this.type = type;\n        this.localName = localName;\n        this.dynamic = dynamic;\n    }\n    _throwError(message, value) {\n        logger.throwArgumentError(message, this.localName, value);\n    }\n}\nexport class Writer {\n    constructor(wordSize) {\n        defineReadOnly(this, \"wordSize\", wordSize || 32);\n        this._data = [];\n        this._dataLength = 0;\n        this._padding = new Uint8Array(wordSize);\n    }\n    get data() {\n        return hexConcat(this._data);\n    }\n    get length() { return this._dataLength; }\n    _writeData(data) {\n        this._data.push(data);\n        this._dataLength += data.length;\n        return data.length;\n    }\n    appendWriter(writer) {\n        return this._writeData(concat(writer._data));\n    }\n    // Arrayish items; padded on the right to wordSize\n    writeBytes(value) {\n        let bytes = arrayify(value);\n        const paddingOffset = bytes.length % this.wordSize;\n        if (paddingOffset) {\n            bytes = concat([bytes, this._padding.slice(paddingOffset)]);\n        }\n        return this._writeData(bytes);\n    }\n    _getValue(value) {\n        let bytes = arrayify(BigNumber.from(value));\n        if (bytes.length > this.wordSize) {\n            logger.throwError(\"value out-of-bounds\", Logger.errors.BUFFER_OVERRUN, {\n                length: this.wordSize,\n                offset: bytes.length\n            });\n        }\n        if (bytes.length % this.wordSize) {\n            bytes = concat([this._padding.slice(bytes.length % this.wordSize), bytes]);\n        }\n        return bytes;\n    }\n    // BigNumberish items; padded on the left to wordSize\n    writeValue(value) {\n        return this._writeData(this._getValue(value));\n    }\n    writeUpdatableValue() {\n        const offset = this._data.length;\n        this._data.push(this._padding);\n        this._dataLength += this.wordSize;\n        return (value) => {\n            this._data[offset] = this._getValue(value);\n        };\n    }\n}\nexport class Reader {\n    constructor(data, wordSize, coerceFunc, allowLoose) {\n        defineReadOnly(this, \"_data\", arrayify(data));\n        defineReadOnly(this, \"wordSize\", wordSize || 32);\n        defineReadOnly(this, \"_coerceFunc\", coerceFunc);\n        defineReadOnly(this, \"allowLoose\", allowLoose);\n        this._offset = 0;\n    }\n    get data() { return hexlify(this._data); }\n    get consumed() { return this._offset; }\n    // The default Coerce function\n    static coerce(name, value) {\n        let match = name.match(\"^u?int([0-9]+)$\");\n        if (match && parseInt(match[1]) <= 48) {\n            value = value.toNumber();\n        }\n        return value;\n    }\n    coerce(name, value) {\n        if (this._coerceFunc) {\n            return this._coerceFunc(name, value);\n        }\n        return Reader.coerce(name, value);\n    }\n    _peekBytes(offset, length, loose) {\n        let alignedLength = Math.ceil(length / this.wordSize) * this.wordSize;\n        if (this._offset + alignedLength > this._data.length) {\n            if (this.allowLoose && loose && this._offset + length <= this._data.length) {\n                alignedLength = length;\n            }\n            else {\n                logger.throwError(\"data out-of-bounds\", Logger.errors.BUFFER_OVERRUN, {\n                    length: this._data.length,\n                    offset: this._offset + alignedLength\n                });\n            }\n        }\n        return this._data.slice(this._offset, this._offset + alignedLength);\n    }\n    subReader(offset) {\n        return new Reader(this._data.slice(this._offset + offset), this.wordSize, this._coerceFunc, this.allowLoose);\n    }\n    readBytes(length, loose) {\n        let bytes = this._peekBytes(0, length, !!loose);\n        this._offset += bytes.length;\n        // @TODO: Make sure the length..end bytes are all 0?\n        return bytes.slice(0, length);\n    }\n    readValue() {\n        return BigNumber.from(this.readBytes(this.wordSize));\n    }\n}\n//# sourceMappingURL=abstract-coder.js.map","\"use strict\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { hexZeroPad } from \"@ethersproject/bytes\";\nimport { Coder } from \"./abstract-coder\";\nexport class AddressCoder extends Coder {\n    constructor(localName) {\n        super(\"address\", \"address\", localName, false);\n    }\n    defaultValue() {\n        return \"0x0000000000000000000000000000000000000000\";\n    }\n    encode(writer, value) {\n        try {\n            value = getAddress(value);\n        }\n        catch (error) {\n            this._throwError(error.message, value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        return getAddress(hexZeroPad(reader.readValue().toHexString(), 20));\n    }\n}\n//# sourceMappingURL=address.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\n// Clones the functionality of an existing Coder, but without a localName\nexport class AnonymousCoder extends Coder {\n    constructor(coder) {\n        super(coder.name, coder.type, undefined, coder.dynamic);\n        this.coder = coder;\n    }\n    defaultValue() {\n        return this.coder.defaultValue();\n    }\n    encode(writer, value) {\n        return this.coder.encode(writer, value);\n    }\n    decode(reader) {\n        return this.coder.decode(reader);\n    }\n}\n//# sourceMappingURL=anonymous.js.map","\"use strict\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"../_version\";\nconst logger = new Logger(version);\nimport { Coder, Writer } from \"./abstract-coder\";\nimport { AnonymousCoder } from \"./anonymous\";\nexport function pack(writer, coders, values) {\n    let arrayValues = null;\n    if (Array.isArray(values)) {\n        arrayValues = values;\n    }\n    else if (values && typeof (values) === \"object\") {\n        let unique = {};\n        arrayValues = coders.map((coder) => {\n            const name = coder.localName;\n            if (!name) {\n                logger.throwError(\"cannot encode object for signature with missing names\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"values\",\n                    coder: coder,\n                    value: values\n                });\n            }\n            if (unique[name]) {\n                logger.throwError(\"cannot encode object for signature with duplicate names\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"values\",\n                    coder: coder,\n                    value: values\n                });\n            }\n            unique[name] = true;\n            return values[name];\n        });\n    }\n    else {\n        logger.throwArgumentError(\"invalid tuple value\", \"tuple\", values);\n    }\n    if (coders.length !== arrayValues.length) {\n        logger.throwArgumentError(\"types/value length mismatch\", \"tuple\", values);\n    }\n    let staticWriter = new Writer(writer.wordSize);\n    let dynamicWriter = new Writer(writer.wordSize);\n    let updateFuncs = [];\n    coders.forEach((coder, index) => {\n        let value = arrayValues[index];\n        if (coder.dynamic) {\n            // Get current dynamic offset (for the future pointer)\n            let dynamicOffset = dynamicWriter.length;\n            // Encode the dynamic value into the dynamicWriter\n            coder.encode(dynamicWriter, value);\n            // Prepare to populate the correct offset once we are done\n            let updateFunc = staticWriter.writeUpdatableValue();\n            updateFuncs.push((baseOffset) => {\n                updateFunc(baseOffset + dynamicOffset);\n            });\n        }\n        else {\n            coder.encode(staticWriter, value);\n        }\n    });\n    // Backfill all the dynamic offsets, now that we know the static length\n    updateFuncs.forEach((func) => { func(staticWriter.length); });\n    let length = writer.appendWriter(staticWriter);\n    length += writer.appendWriter(dynamicWriter);\n    return length;\n}\nexport function unpack(reader, coders) {\n    let values = [];\n    // A reader anchored to this base\n    let baseReader = reader.subReader(0);\n    coders.forEach((coder) => {\n        let value = null;\n        if (coder.dynamic) {\n            let offset = reader.readValue();\n            let offsetReader = baseReader.subReader(offset.toNumber());\n            try {\n                value = coder.decode(offsetReader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (error.code === Logger.errors.BUFFER_OVERRUN) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        else {\n            try {\n                value = coder.decode(reader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (error.code === Logger.errors.BUFFER_OVERRUN) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        if (value != undefined) {\n            values.push(value);\n        }\n    });\n    // We only output named properties for uniquely named coders\n    const uniqueNames = coders.reduce((accum, coder) => {\n        const name = coder.localName;\n        if (name) {\n            if (!accum[name]) {\n                accum[name] = 0;\n            }\n            accum[name]++;\n        }\n        return accum;\n    }, {});\n    // Add any named parameters (i.e. tuples)\n    coders.forEach((coder, index) => {\n        let name = coder.localName;\n        if (!name || uniqueNames[name] !== 1) {\n            return;\n        }\n        if (name === \"length\") {\n            name = \"_length\";\n        }\n        if (values[name] != null) {\n            return;\n        }\n        const value = values[index];\n        if (value instanceof Error) {\n            Object.defineProperty(values, name, {\n                enumerable: true,\n                get: () => { throw value; }\n            });\n        }\n        else {\n            values[name] = value;\n        }\n    });\n    for (let i = 0; i < values.length; i++) {\n        const value = values[i];\n        if (value instanceof Error) {\n            Object.defineProperty(values, i, {\n                enumerable: true,\n                get: () => { throw value; }\n            });\n        }\n    }\n    return Object.freeze(values);\n}\nexport class ArrayCoder extends Coder {\n    constructor(coder, length, localName) {\n        const type = (coder.type + \"[\" + (length >= 0 ? length : \"\") + \"]\");\n        const dynamic = (length === -1 || coder.dynamic);\n        super(\"array\", type, localName, dynamic);\n        this.coder = coder;\n        this.length = length;\n    }\n    defaultValue() {\n        // Verifies the child coder is valid (even if the array is dynamic or 0-length)\n        const defaultChild = this.coder.defaultValue();\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            result.push(defaultChild);\n        }\n        return result;\n    }\n    encode(writer, value) {\n        if (!Array.isArray(value)) {\n            this._throwError(\"expected array value\", value);\n        }\n        let count = this.length;\n        if (count === -1) {\n            count = value.length;\n            writer.writeValue(value.length);\n        }\n        logger.checkArgumentCount(value.length, count, \"coder array\" + (this.localName ? (\" \" + this.localName) : \"\"));\n        let coders = [];\n        for (let i = 0; i < value.length; i++) {\n            coders.push(this.coder);\n        }\n        return pack(writer, coders, value);\n    }\n    decode(reader) {\n        let count = this.length;\n        if (count === -1) {\n            count = reader.readValue().toNumber();\n            // Check that there is *roughly* enough data to ensure\n            // stray random data is not being read as a length. Each\n            // slot requires at least 32 bytes for their value (or 32\n            // bytes as a link to the data). This could use a much\n            // tighter bound, but we are erroring on the side of safety.\n            if (count * 32 > reader._data.length) {\n                logger.throwError(\"insufficient data length\", Logger.errors.BUFFER_OVERRUN, {\n                    length: reader._data.length,\n                    count: count\n                });\n            }\n        }\n        let coders = [];\n        for (let i = 0; i < count; i++) {\n            coders.push(new AnonymousCoder(this.coder));\n        }\n        return reader.coerce(this.name, unpack(reader, coders));\n    }\n}\n//# sourceMappingURL=array.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\nexport class BooleanCoder extends Coder {\n    constructor(localName) {\n        super(\"bool\", \"bool\", localName, false);\n    }\n    defaultValue() {\n        return false;\n    }\n    encode(writer, value) {\n        return writer.writeValue(value ? 1 : 0);\n    }\n    decode(reader) {\n        return reader.coerce(this.type, !reader.readValue().isZero());\n    }\n}\n//# sourceMappingURL=boolean.js.map","\"use strict\";\nimport { arrayify, hexlify } from \"@ethersproject/bytes\";\nimport { Coder } from \"./abstract-coder\";\nexport class DynamicBytesCoder extends Coder {\n    constructor(type, localName) {\n        super(type, type, localName, true);\n    }\n    defaultValue() {\n        return \"0x\";\n    }\n    encode(writer, value) {\n        value = arrayify(value);\n        let length = writer.writeValue(value.length);\n        length += writer.writeBytes(value);\n        return length;\n    }\n    decode(reader) {\n        return reader.readBytes(reader.readValue().toNumber(), true);\n    }\n}\nexport class BytesCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"bytes\", localName);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, hexlify(super.decode(reader)));\n    }\n}\n//# sourceMappingURL=bytes.js.map","\"use strict\";\nimport { arrayify, hexlify } from \"@ethersproject/bytes\";\nimport { Coder } from \"./abstract-coder\";\n// @TODO: Merge this with bytes\nexport class FixedBytesCoder extends Coder {\n    constructor(size, localName) {\n        let name = \"bytes\" + String(size);\n        super(name, name, localName, false);\n        this.size = size;\n    }\n    defaultValue() {\n        return (\"0x0000000000000000000000000000000000000000000000000000000000000000\").substring(0, 2 + this.size * 2);\n    }\n    encode(writer, value) {\n        let data = arrayify(value);\n        if (data.length !== this.size) {\n            this._throwError(\"incorrect data length\", value);\n        }\n        return writer.writeBytes(data);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, hexlify(reader.readBytes(this.size)));\n    }\n}\n//# sourceMappingURL=fixed-bytes.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\nexport class NullCoder extends Coder {\n    constructor(localName) {\n        super(\"null\", \"\", localName, false);\n    }\n    defaultValue() {\n        return null;\n    }\n    encode(writer, value) {\n        if (value != null) {\n            this._throwError(\"not null\", value);\n        }\n        return writer.writeBytes([]);\n    }\n    decode(reader) {\n        reader.readBytes(0);\n        return reader.coerce(this.name, null);\n    }\n}\n//# sourceMappingURL=null.js.map","\"use strict\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { MaxUint256, NegativeOne, One, Zero } from \"@ethersproject/constants\";\nimport { Coder } from \"./abstract-coder\";\nexport class NumberCoder extends Coder {\n    constructor(size, signed, localName) {\n        const name = ((signed ? \"int\" : \"uint\") + (size * 8));\n        super(name, name, localName, false);\n        this.size = size;\n        this.signed = signed;\n    }\n    defaultValue() {\n        return 0;\n    }\n    encode(writer, value) {\n        let v = BigNumber.from(value);\n        // Check bounds are safe for encoding\n        let maxUintValue = MaxUint256.mask(writer.wordSize * 8);\n        if (this.signed) {\n            let bounds = maxUintValue.mask(this.size * 8 - 1);\n            if (v.gt(bounds) || v.lt(bounds.add(One).mul(NegativeOne))) {\n                this._throwError(\"value out-of-bounds\", value);\n            }\n        }\n        else if (v.lt(Zero) || v.gt(maxUintValue.mask(this.size * 8))) {\n            this._throwError(\"value out-of-bounds\", value);\n        }\n        v = v.toTwos(this.size * 8).mask(this.size * 8);\n        if (this.signed) {\n            v = v.fromTwos(this.size * 8).toTwos(8 * writer.wordSize);\n        }\n        return writer.writeValue(v);\n    }\n    decode(reader) {\n        let value = reader.readValue().mask(this.size * 8);\n        if (this.signed) {\n            value = value.fromTwos(this.size * 8);\n        }\n        return reader.coerce(this.name, value);\n    }\n}\n//# sourceMappingURL=number.js.map","\"use strict\";\nimport { toUtf8Bytes, toUtf8String } from \"@ethersproject/strings\";\nimport { DynamicBytesCoder } from \"./bytes\";\nexport class StringCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"string\", localName);\n    }\n    defaultValue() {\n        return \"\";\n    }\n    encode(writer, value) {\n        return super.encode(writer, toUtf8Bytes(value));\n    }\n    decode(reader) {\n        return toUtf8String(super.decode(reader));\n    }\n}\n//# sourceMappingURL=string.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\nimport { pack, unpack } from \"./array\";\nexport class TupleCoder extends Coder {\n    constructor(coders, localName) {\n        let dynamic = false;\n        const types = [];\n        coders.forEach((coder) => {\n            if (coder.dynamic) {\n                dynamic = true;\n            }\n            types.push(coder.type);\n        });\n        const type = (\"tuple(\" + types.join(\",\") + \")\");\n        super(\"tuple\", type, localName, dynamic);\n        this.coders = coders;\n    }\n    defaultValue() {\n        const values = [];\n        this.coders.forEach((coder) => {\n            values.push(coder.defaultValue());\n        });\n        // We only output named properties for uniquely named coders\n        const uniqueNames = this.coders.reduce((accum, coder) => {\n            const name = coder.localName;\n            if (name) {\n                if (!accum[name]) {\n                    accum[name] = 0;\n                }\n                accum[name]++;\n            }\n            return accum;\n        }, {});\n        // Add named values\n        this.coders.forEach((coder, index) => {\n            let name = coder.localName;\n            if (!name || uniqueNames[name] !== 1) {\n                return;\n            }\n            if (name === \"length\") {\n                name = \"_length\";\n            }\n            if (values[name] != null) {\n                return;\n            }\n            values[name] = values[index];\n        });\n        return Object.freeze(values);\n    }\n    encode(writer, value) {\n        return pack(writer, this.coders, value);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, unpack(reader, this.coders));\n    }\n}\n//# sourceMappingURL=tuple.js.map","\"use strict\";\n// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { Reader, Writer } from \"./coders/abstract-coder\";\nimport { AddressCoder } from \"./coders/address\";\nimport { ArrayCoder } from \"./coders/array\";\nimport { BooleanCoder } from \"./coders/boolean\";\nimport { BytesCoder } from \"./coders/bytes\";\nimport { FixedBytesCoder } from \"./coders/fixed-bytes\";\nimport { NullCoder } from \"./coders/null\";\nimport { NumberCoder } from \"./coders/number\";\nimport { StringCoder } from \"./coders/string\";\nimport { TupleCoder } from \"./coders/tuple\";\nimport { ParamType } from \"./fragments\";\nconst paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\nconst paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\nexport class AbiCoder {\n    constructor(coerceFunc) {\n        defineReadOnly(this, \"coerceFunc\", coerceFunc || null);\n    }\n    _getCoder(param) {\n        switch (param.baseType) {\n            case \"address\":\n                return new AddressCoder(param.name);\n            case \"bool\":\n                return new BooleanCoder(param.name);\n            case \"string\":\n                return new StringCoder(param.name);\n            case \"bytes\":\n                return new BytesCoder(param.name);\n            case \"array\":\n                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);\n            case \"tuple\":\n                return new TupleCoder((param.components || []).map((component) => {\n                    return this._getCoder(component);\n                }), param.name);\n            case \"\":\n                return new NullCoder(param.name);\n        }\n        // u?int[0-9]*\n        let match = param.type.match(paramTypeNumber);\n        if (match) {\n            let size = parseInt(match[2] || \"256\");\n            if (size === 0 || size > 256 || (size % 8) !== 0) {\n                logger.throwArgumentError(\"invalid \" + match[1] + \" bit length\", \"param\", param);\n            }\n            return new NumberCoder(size / 8, (match[1] === \"int\"), param.name);\n        }\n        // bytes[0-9]+\n        match = param.type.match(paramTypeBytes);\n        if (match) {\n            let size = parseInt(match[1]);\n            if (size === 0 || size > 32) {\n                logger.throwArgumentError(\"invalid bytes length\", \"param\", param);\n            }\n            return new FixedBytesCoder(size, param.name);\n        }\n        return logger.throwArgumentError(\"invalid type\", \"type\", param.type);\n    }\n    _getWordSize() { return 32; }\n    _getReader(data, allowLoose) {\n        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);\n    }\n    _getWriter() {\n        return new Writer(this._getWordSize());\n    }\n    getDefaultValue(types) {\n        const coders = types.map((type) => this._getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.defaultValue();\n    }\n    encode(types, values) {\n        if (types.length !== values.length) {\n            logger.throwError(\"types/values length mismatch\", Logger.errors.INVALID_ARGUMENT, {\n                count: { types: types.length, values: values.length },\n                value: { types: types, values: values }\n            });\n        }\n        const coders = types.map((type) => this._getCoder(ParamType.from(type)));\n        const coder = (new TupleCoder(coders, \"_\"));\n        const writer = this._getWriter();\n        coder.encode(writer, values);\n        return writer.data;\n    }\n    decode(types, data, loose) {\n        const coders = types.map((type) => this._getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.decode(this._getReader(arrayify(data), loose));\n    }\n}\nexport const defaultAbiCoder = new AbiCoder();\n//# sourceMappingURL=abi-coder.js.map","\"use strict\";\nexport { decode, encode } from \"./base64\";\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 { defineReadOnly, resolveProperties, shallowCopy } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nconst allowedTransactionKeys = [\n    \"accessList\", \"ccipReadEnabled\", \"chainId\", \"customData\", \"data\", \"from\", \"gasLimit\", \"gasPrice\", \"maxFeePerGas\", \"maxPriorityFeePerGas\", \"nonce\", \"to\", \"type\", \"value\"\n];\nconst forwardErrors = [\n    Logger.errors.INSUFFICIENT_FUNDS,\n    Logger.errors.NONCE_EXPIRED,\n    Logger.errors.REPLACEMENT_UNDERPRICED,\n];\n;\n;\nexport class Signer {\n    ///////////////////\n    // Sub-classes MUST call super\n    constructor() {\n        logger.checkAbstract(new.target, Signer);\n        defineReadOnly(this, \"_isSigner\", true);\n    }\n    ///////////////////\n    // Sub-classes MAY override these\n    getBalance(blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"getBalance\");\n            return yield this.provider.getBalance(this.getAddress(), blockTag);\n        });\n    }\n    getTransactionCount(blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"getTransactionCount\");\n            return yield this.provider.getTransactionCount(this.getAddress(), blockTag);\n        });\n    }\n    // Populates \"from\" if unspecified, and estimates the gas for the transaction\n    estimateGas(transaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"estimateGas\");\n            const tx = yield resolveProperties(this.checkTransaction(transaction));\n            return yield this.provider.estimateGas(tx);\n        });\n    }\n    // Populates \"from\" if unspecified, and calls with the transaction\n    call(transaction, blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"call\");\n            const tx = yield resolveProperties(this.checkTransaction(transaction));\n            return yield this.provider.call(tx, blockTag);\n        });\n    }\n    // Populates all fields in a transaction, signs it and sends it to the network\n    sendTransaction(transaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"sendTransaction\");\n            const tx = yield this.populateTransaction(transaction);\n            const signedTx = yield this.signTransaction(tx);\n            return yield this.provider.sendTransaction(signedTx);\n        });\n    }\n    getChainId() {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"getChainId\");\n            const network = yield this.provider.getNetwork();\n            return network.chainId;\n        });\n    }\n    getGasPrice() {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"getGasPrice\");\n            return yield this.provider.getGasPrice();\n        });\n    }\n    getFeeData() {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"getFeeData\");\n            return yield this.provider.getFeeData();\n        });\n    }\n    resolveName(name) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this._checkProvider(\"resolveName\");\n            return yield this.provider.resolveName(name);\n        });\n    }\n    // Checks a transaction does not contain invalid keys and if\n    // no \"from\" is provided, populates it.\n    // - does NOT require a provider\n    // - adds \"from\" is not present\n    // - returns a COPY (safe to mutate the result)\n    // By default called from: (overriding these prevents it)\n    //   - call\n    //   - estimateGas\n    //   - populateTransaction (and therefor sendTransaction)\n    checkTransaction(transaction) {\n        for (const key in transaction) {\n            if (allowedTransactionKeys.indexOf(key) === -1) {\n                logger.throwArgumentError(\"invalid transaction key: \" + key, \"transaction\", transaction);\n            }\n        }\n        const tx = shallowCopy(transaction);\n        if (tx.from == null) {\n            tx.from = this.getAddress();\n        }\n        else {\n            // Make sure any provided address matches this signer\n            tx.from = Promise.all([\n                Promise.resolve(tx.from),\n                this.getAddress()\n            ]).then((result) => {\n                if (result[0].toLowerCase() !== result[1].toLowerCase()) {\n                    logger.throwArgumentError(\"from address mismatch\", \"transaction\", transaction);\n                }\n                return result[0];\n            });\n        }\n        return tx;\n    }\n    // Populates ALL keys for a transaction and checks that \"from\" matches\n    // this Signer. Should be used by sendTransaction but NOT by signTransaction.\n    // By default called from: (overriding these prevents it)\n    //   - sendTransaction\n    //\n    // Notes:\n    //  - We allow gasPrice for EIP-1559 as long as it matches maxFeePerGas\n    populateTransaction(transaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const tx = yield resolveProperties(this.checkTransaction(transaction));\n            if (tx.to != null) {\n                tx.to = Promise.resolve(tx.to).then((to) => __awaiter(this, void 0, void 0, function* () {\n                    if (to == null) {\n                        return null;\n                    }\n                    const address = yield this.resolveName(to);\n                    if (address == null) {\n                        logger.throwArgumentError(\"provided ENS name resolves to null\", \"tx.to\", to);\n                    }\n                    return address;\n                }));\n                // Prevent this error from causing an UnhandledPromiseException\n                tx.to.catch((error) => { });\n            }\n            // Do not allow mixing pre-eip-1559 and eip-1559 properties\n            const hasEip1559 = (tx.maxFeePerGas != null || tx.maxPriorityFeePerGas != null);\n            if (tx.gasPrice != null && (tx.type === 2 || hasEip1559)) {\n                logger.throwArgumentError(\"eip-1559 transaction do not support gasPrice\", \"transaction\", transaction);\n            }\n            else if ((tx.type === 0 || tx.type === 1) && hasEip1559) {\n                logger.throwArgumentError(\"pre-eip-1559 transaction do not support maxFeePerGas/maxPriorityFeePerGas\", \"transaction\", transaction);\n            }\n            if ((tx.type === 2 || tx.type == null) && (tx.maxFeePerGas != null && tx.maxPriorityFeePerGas != null)) {\n                // Fully-formed EIP-1559 transaction (skip getFeeData)\n                tx.type = 2;\n            }\n            else if (tx.type === 0 || tx.type === 1) {\n                // Explicit Legacy or EIP-2930 transaction\n                // Populate missing gasPrice\n                if (tx.gasPrice == null) {\n                    tx.gasPrice = this.getGasPrice();\n                }\n            }\n            else {\n                // We need to get fee data to determine things\n                const feeData = yield this.getFeeData();\n                if (tx.type == null) {\n                    // We need to auto-detect the intended type of this transaction...\n                    if (feeData.maxFeePerGas != null && feeData.maxPriorityFeePerGas != null) {\n                        // The network supports EIP-1559!\n                        // Upgrade transaction from null to eip-1559\n                        tx.type = 2;\n                        if (tx.gasPrice != null) {\n                            // Using legacy gasPrice property on an eip-1559 network,\n                            // so use gasPrice as both fee properties\n                            const gasPrice = tx.gasPrice;\n                            delete tx.gasPrice;\n                            tx.maxFeePerGas = gasPrice;\n                            tx.maxPriorityFeePerGas = gasPrice;\n                        }\n                        else {\n                            // Populate missing fee data\n                            if (tx.maxFeePerGas == null) {\n                                tx.maxFeePerGas = feeData.maxFeePerGas;\n                            }\n                            if (tx.maxPriorityFeePerGas == null) {\n                                tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;\n                            }\n                        }\n                    }\n                    else if (feeData.gasPrice != null) {\n                        // Network doesn't support EIP-1559...\n                        // ...but they are trying to use EIP-1559 properties\n                        if (hasEip1559) {\n                            logger.throwError(\"network does not support EIP-1559\", Logger.errors.UNSUPPORTED_OPERATION, {\n                                operation: \"populateTransaction\"\n                            });\n                        }\n                        // Populate missing fee data\n                        if (tx.gasPrice == null) {\n                            tx.gasPrice = feeData.gasPrice;\n                        }\n                        // Explicitly set untyped transaction to legacy\n                        tx.type = 0;\n                    }\n                    else {\n                        // getFeeData has failed us.\n                        logger.throwError(\"failed to get consistent fee data\", Logger.errors.UNSUPPORTED_OPERATION, {\n                            operation: \"signer.getFeeData\"\n                        });\n                    }\n                }\n                else if (tx.type === 2) {\n                    // Explicitly using EIP-1559\n                    // Populate missing fee data\n                    if (tx.maxFeePerGas == null) {\n                        tx.maxFeePerGas = feeData.maxFeePerGas;\n                    }\n                    if (tx.maxPriorityFeePerGas == null) {\n                        tx.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;\n                    }\n                }\n            }\n            if (tx.nonce == null) {\n                tx.nonce = this.getTransactionCount(\"pending\");\n            }\n            if (tx.gasLimit == null) {\n                tx.gasLimit = this.estimateGas(tx).catch((error) => {\n                    if (forwardErrors.indexOf(error.code) >= 0) {\n                        throw error;\n                    }\n                    return logger.throwError(\"cannot estimate gas; transaction may fail or may require manual gas limit\", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {\n                        error: error,\n                        tx: tx\n                    });\n                });\n            }\n            if (tx.chainId == null) {\n                tx.chainId = this.getChainId();\n            }\n            else {\n                tx.chainId = Promise.all([\n                    Promise.resolve(tx.chainId),\n                    this.getChainId()\n                ]).then((results) => {\n                    if (results[1] !== 0 && results[0] !== results[1]) {\n                        logger.throwArgumentError(\"chainId address mismatch\", \"transaction\", transaction);\n                    }\n                    return results[0];\n                });\n            }\n            return yield resolveProperties(tx);\n        });\n    }\n    ///////////////////\n    // Sub-classes SHOULD leave these alone\n    _checkProvider(operation) {\n        if (!this.provider) {\n            logger.throwError(\"missing provider\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: (operation || \"_checkProvider\")\n            });\n        }\n    }\n    static isSigner(value) {\n        return !!(value && value._isSigner);\n    }\n}\nexport class VoidSigner extends Signer {\n    constructor(address, provider) {\n        super();\n        defineReadOnly(this, \"address\", address);\n        defineReadOnly(this, \"provider\", provider || null);\n    }\n    getAddress() {\n        return Promise.resolve(this.address);\n    }\n    _fail(message, operation) {\n        return Promise.resolve().then(() => {\n            logger.throwError(message, Logger.errors.UNSUPPORTED_OPERATION, { operation: operation });\n        });\n    }\n    signMessage(message) {\n        return this._fail(\"VoidSigner cannot sign messages\", \"signMessage\");\n    }\n    signTransaction(transaction) {\n        return this._fail(\"VoidSigner cannot sign transactions\", \"signTransaction\");\n    }\n    _signTypedData(domain, types, value) {\n        return this._fail(\"VoidSigner cannot sign typed data\", \"signTypedData\");\n    }\n    connect(provider) {\n        return new VoidSigner(this.address, provider);\n    }\n}\n//# sourceMappingURL=index.js.map","export const version = \"abstract-signer/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, concat, hexDataSlice, hexlify, hexZeroPad, isHexString } from \"@ethersproject/bytes\";\nimport { id } from \"@ethersproject/hash\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { defineReadOnly, Description, getStatic } from \"@ethersproject/properties\";\nimport { defaultAbiCoder } from \"./abi-coder\";\nimport { checkResultErrors } from \"./coders/abstract-coder\";\nimport { ConstructorFragment, EventFragment, FormatTypes, Fragment, FunctionFragment, ParamType } from \"./fragments\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport { checkResultErrors };\nexport class LogDescription extends Description {\n}\nexport class TransactionDescription extends Description {\n}\nexport class ErrorDescription extends Description {\n}\nexport class Indexed extends Description {\n    static isIndexed(value) {\n        return !!(value && value._isIndexed);\n    }\n}\nconst BuiltinErrors = {\n    \"0x08c379a0\": { signature: \"Error(string)\", name: \"Error\", inputs: [\"string\"], reason: true },\n    \"0x4e487b71\": { signature: \"Panic(uint256)\", name: \"Panic\", inputs: [\"uint256\"] }\n};\nfunction wrapAccessError(property, error) {\n    const wrap = new Error(`deferred error during ABI decoding triggered accessing ${property}`);\n    wrap.error = error;\n    return wrap;\n}\n/*\nfunction checkNames(fragment: Fragment, type: \"input\" | \"output\", params: Array<ParamType>): void {\n    params.reduce((accum, param) => {\n        if (param.name) {\n            if (accum[param.name]) {\n                logger.throwArgumentError(`duplicate ${ type } parameter ${ JSON.stringify(param.name) } in ${ fragment.format(\"full\") }`, \"fragment\", fragment);\n            }\n            accum[param.name] = true;\n        }\n        return accum;\n    }, <{ [ name: string ]: boolean }>{ });\n}\n*/\nexport class Interface {\n    constructor(fragments) {\n        let abi = [];\n        if (typeof (fragments) === \"string\") {\n            abi = JSON.parse(fragments);\n        }\n        else {\n            abi = fragments;\n        }\n        defineReadOnly(this, \"fragments\", abi.map((fragment) => {\n            return Fragment.from(fragment);\n        }).filter((fragment) => (fragment != null)));\n        defineReadOnly(this, \"_abiCoder\", getStatic(new.target, \"getAbiCoder\")());\n        defineReadOnly(this, \"functions\", {});\n        defineReadOnly(this, \"errors\", {});\n        defineReadOnly(this, \"events\", {});\n        defineReadOnly(this, \"structs\", {});\n        // Add all fragments by their signature\n        this.fragments.forEach((fragment) => {\n            let bucket = null;\n            switch (fragment.type) {\n                case \"constructor\":\n                    if (this.deploy) {\n                        logger.warn(\"duplicate definition - constructor\");\n                        return;\n                    }\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    defineReadOnly(this, \"deploy\", fragment);\n                    return;\n                case \"function\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    //checkNames(fragment, \"output\", (<FunctionFragment>fragment).outputs);\n                    bucket = this.functions;\n                    break;\n                case \"event\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    bucket = this.events;\n                    break;\n                case \"error\":\n                    bucket = this.errors;\n                    break;\n                default:\n                    return;\n            }\n            let signature = fragment.format();\n            if (bucket[signature]) {\n                logger.warn(\"duplicate definition - \" + signature);\n                return;\n            }\n            bucket[signature] = fragment;\n        });\n        // If we do not have a constructor add a default\n        if (!this.deploy) {\n            defineReadOnly(this, \"deploy\", ConstructorFragment.from({\n                payable: false,\n                type: \"constructor\"\n            }));\n        }\n        defineReadOnly(this, \"_isInterface\", true);\n    }\n    format(format) {\n        if (!format) {\n            format = FormatTypes.full;\n        }\n        if (format === FormatTypes.sighash) {\n            logger.throwArgumentError(\"interface does not support formatting sighash\", \"format\", format);\n        }\n        const abi = this.fragments.map((fragment) => fragment.format(format));\n        // We need to re-bundle the JSON fragments a bit\n        if (format === FormatTypes.json) {\n            return JSON.stringify(abi.map((j) => JSON.parse(j)));\n        }\n        return abi;\n    }\n    // Sub-classes can override these to handle other blockchains\n    static getAbiCoder() {\n        return defaultAbiCoder;\n    }\n    static getAddress(address) {\n        return getAddress(address);\n    }\n    static getSighash(fragment) {\n        return hexDataSlice(id(fragment.format()), 0, 4);\n    }\n    static getEventTopic(eventFragment) {\n        return id(eventFragment.format());\n    }\n    // Find a function definition by any means necessary (unless it is ambiguous)\n    getFunction(nameOrSignatureOrSighash) {\n        if (isHexString(nameOrSignatureOrSighash)) {\n            for (const name in this.functions) {\n                if (nameOrSignatureOrSighash === this.getSighash(name)) {\n                    return this.functions[name];\n                }\n            }\n            logger.throwArgumentError(\"no matching function\", \"sighash\", nameOrSignatureOrSighash);\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (nameOrSignatureOrSighash.indexOf(\"(\") === -1) {\n            const name = nameOrSignatureOrSighash.trim();\n            const matching = Object.keys(this.functions).filter((f) => (f.split(\"(\" /* fix:) */)[0] === name));\n            if (matching.length === 0) {\n                logger.throwArgumentError(\"no matching function\", \"name\", name);\n            }\n            else if (matching.length > 1) {\n                logger.throwArgumentError(\"multiple matching functions\", \"name\", name);\n            }\n            return this.functions[matching[0]];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.functions[FunctionFragment.fromString(nameOrSignatureOrSighash).format()];\n        if (!result) {\n            logger.throwArgumentError(\"no matching function\", \"signature\", nameOrSignatureOrSighash);\n        }\n        return result;\n    }\n    // Find an event definition by any means necessary (unless it is ambiguous)\n    getEvent(nameOrSignatureOrTopic) {\n        if (isHexString(nameOrSignatureOrTopic)) {\n            const topichash = nameOrSignatureOrTopic.toLowerCase();\n            for (const name in this.events) {\n                if (topichash === this.getEventTopic(name)) {\n                    return this.events[name];\n                }\n            }\n            logger.throwArgumentError(\"no matching event\", \"topichash\", topichash);\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (nameOrSignatureOrTopic.indexOf(\"(\") === -1) {\n            const name = nameOrSignatureOrTopic.trim();\n            const matching = Object.keys(this.events).filter((f) => (f.split(\"(\" /* fix:) */)[0] === name));\n            if (matching.length === 0) {\n                logger.throwArgumentError(\"no matching event\", \"name\", name);\n            }\n            else if (matching.length > 1) {\n                logger.throwArgumentError(\"multiple matching events\", \"name\", name);\n            }\n            return this.events[matching[0]];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.events[EventFragment.fromString(nameOrSignatureOrTopic).format()];\n        if (!result) {\n            logger.throwArgumentError(\"no matching event\", \"signature\", nameOrSignatureOrTopic);\n        }\n        return result;\n    }\n    // Find a function definition by any means necessary (unless it is ambiguous)\n    getError(nameOrSignatureOrSighash) {\n        if (isHexString(nameOrSignatureOrSighash)) {\n            const getSighash = getStatic(this.constructor, \"getSighash\");\n            for (const name in this.errors) {\n                const error = this.errors[name];\n                if (nameOrSignatureOrSighash === getSighash(error)) {\n                    return this.errors[name];\n                }\n            }\n            logger.throwArgumentError(\"no matching error\", \"sighash\", nameOrSignatureOrSighash);\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (nameOrSignatureOrSighash.indexOf(\"(\") === -1) {\n            const name = nameOrSignatureOrSighash.trim();\n            const matching = Object.keys(this.errors).filter((f) => (f.split(\"(\" /* fix:) */)[0] === name));\n            if (matching.length === 0) {\n                logger.throwArgumentError(\"no matching error\", \"name\", name);\n            }\n            else if (matching.length > 1) {\n                logger.throwArgumentError(\"multiple matching errors\", \"name\", name);\n            }\n            return this.errors[matching[0]];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.errors[FunctionFragment.fromString(nameOrSignatureOrSighash).format()];\n        if (!result) {\n            logger.throwArgumentError(\"no matching error\", \"signature\", nameOrSignatureOrSighash);\n        }\n        return result;\n    }\n    // Get the sighash (the bytes4 selector) used by Solidity to identify a function\n    getSighash(fragment) {\n        if (typeof (fragment) === \"string\") {\n            try {\n                fragment = this.getFunction(fragment);\n            }\n            catch (error) {\n                try {\n                    fragment = this.getError(fragment);\n                }\n                catch (_) {\n                    throw error;\n                }\n            }\n        }\n        return getStatic(this.constructor, \"getSighash\")(fragment);\n    }\n    // Get the topic (the bytes32 hash) used by Solidity to identify an event\n    getEventTopic(eventFragment) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        return getStatic(this.constructor, \"getEventTopic\")(eventFragment);\n    }\n    _decodeParams(params, data) {\n        return this._abiCoder.decode(params, data);\n    }\n    _encodeParams(params, values) {\n        return this._abiCoder.encode(params, values);\n    }\n    encodeDeploy(values) {\n        return this._encodeParams(this.deploy.inputs, values || []);\n    }\n    decodeErrorResult(fragment, data) {\n        if (typeof (fragment) === \"string\") {\n            fragment = this.getError(fragment);\n        }\n        const bytes = arrayify(data);\n        if (hexlify(bytes.slice(0, 4)) !== this.getSighash(fragment)) {\n            logger.throwArgumentError(`data signature does not match error ${fragment.name}.`, \"data\", hexlify(bytes));\n        }\n        return this._decodeParams(fragment.inputs, bytes.slice(4));\n    }\n    encodeErrorResult(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            fragment = this.getError(fragment);\n        }\n        return hexlify(concat([\n            this.getSighash(fragment),\n            this._encodeParams(fragment.inputs, values || [])\n        ]));\n    }\n    // Decode the data for a function call (e.g. tx.data)\n    decodeFunctionData(functionFragment, data) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        const bytes = arrayify(data);\n        if (hexlify(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) {\n            logger.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, \"data\", hexlify(bytes));\n        }\n        return this._decodeParams(functionFragment.inputs, bytes.slice(4));\n    }\n    // Encode the data for a function call (e.g. tx.data)\n    encodeFunctionData(functionFragment, values) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        return hexlify(concat([\n            this.getSighash(functionFragment),\n            this._encodeParams(functionFragment.inputs, values || [])\n        ]));\n    }\n    // Decode the result from a function call (e.g. from eth_call)\n    decodeFunctionResult(functionFragment, data) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        let bytes = arrayify(data);\n        let reason = null;\n        let message = \"\";\n        let errorArgs = null;\n        let errorName = null;\n        let errorSignature = null;\n        switch (bytes.length % this._abiCoder._getWordSize()) {\n            case 0:\n                try {\n                    return this._abiCoder.decode(functionFragment.outputs, bytes);\n                }\n                catch (error) { }\n                break;\n            case 4: {\n                const selector = hexlify(bytes.slice(0, 4));\n                const builtin = BuiltinErrors[selector];\n                if (builtin) {\n                    errorArgs = this._abiCoder.decode(builtin.inputs, bytes.slice(4));\n                    errorName = builtin.name;\n                    errorSignature = builtin.signature;\n                    if (builtin.reason) {\n                        reason = errorArgs[0];\n                    }\n                    if (errorName === \"Error\") {\n                        message = `; VM Exception while processing transaction: reverted with reason string ${JSON.stringify(errorArgs[0])}`;\n                    }\n                    else if (errorName === \"Panic\") {\n                        message = `; VM Exception while processing transaction: reverted with panic code ${errorArgs[0]}`;\n                    }\n                }\n                else {\n                    try {\n                        const error = this.getError(selector);\n                        errorArgs = this._abiCoder.decode(error.inputs, bytes.slice(4));\n                        errorName = error.name;\n                        errorSignature = error.format();\n                    }\n                    catch (error) { }\n                }\n                break;\n            }\n        }\n        return logger.throwError(\"call revert exception\" + message, Logger.errors.CALL_EXCEPTION, {\n            method: functionFragment.format(),\n            data: hexlify(data), errorArgs, errorName, errorSignature, reason\n        });\n    }\n    // Encode the result for a function call (e.g. for eth_call)\n    encodeFunctionResult(functionFragment, values) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        return hexlify(this._abiCoder.encode(functionFragment.outputs, values || []));\n    }\n    // Create the filter for the event with search criteria (e.g. for eth_filterLog)\n    encodeFilterTopics(eventFragment, values) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        if (values.length > eventFragment.inputs.length) {\n            logger.throwError(\"too many arguments for \" + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, {\n                argument: \"values\",\n                value: values\n            });\n        }\n        let topics = [];\n        if (!eventFragment.anonymous) {\n            topics.push(this.getEventTopic(eventFragment));\n        }\n        const encodeTopic = (param, value) => {\n            if (param.type === \"string\") {\n                return id(value);\n            }\n            else if (param.type === \"bytes\") {\n                return keccak256(hexlify(value));\n            }\n            if (param.type === \"bool\" && typeof (value) === \"boolean\") {\n                value = (value ? \"0x01\" : \"0x00\");\n            }\n            if (param.type.match(/^u?int/)) {\n                value = BigNumber.from(value).toHexString();\n            }\n            // Check addresses are valid\n            if (param.type === \"address\") {\n                this._abiCoder.encode([\"address\"], [value]);\n            }\n            return hexZeroPad(hexlify(value), 32);\n        };\n        values.forEach((value, index) => {\n            let param = eventFragment.inputs[index];\n            if (!param.indexed) {\n                if (value != null) {\n                    logger.throwArgumentError(\"cannot filter non-indexed parameters; must be null\", (\"contract.\" + param.name), value);\n                }\n                return;\n            }\n            if (value == null) {\n                topics.push(null);\n            }\n            else if (param.baseType === \"array\" || param.baseType === \"tuple\") {\n                logger.throwArgumentError(\"filtering with tuples or arrays not supported\", (\"contract.\" + param.name), value);\n            }\n            else if (Array.isArray(value)) {\n                topics.push(value.map((value) => encodeTopic(param, value)));\n            }\n            else {\n                topics.push(encodeTopic(param, value));\n            }\n        });\n        // Trim off trailing nulls\n        while (topics.length && topics[topics.length - 1] === null) {\n            topics.pop();\n        }\n        return topics;\n    }\n    encodeEventLog(eventFragment, values) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        const topics = [];\n        const dataTypes = [];\n        const dataValues = [];\n        if (!eventFragment.anonymous) {\n            topics.push(this.getEventTopic(eventFragment));\n        }\n        if (values.length !== eventFragment.inputs.length) {\n            logger.throwArgumentError(\"event arguments/values mismatch\", \"values\", values);\n        }\n        eventFragment.inputs.forEach((param, index) => {\n            const value = values[index];\n            if (param.indexed) {\n                if (param.type === \"string\") {\n                    topics.push(id(value));\n                }\n                else if (param.type === \"bytes\") {\n                    topics.push(keccak256(value));\n                }\n                else if (param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    // @TODO\n                    throw new Error(\"not implemented\");\n                }\n                else {\n                    topics.push(this._abiCoder.encode([param.type], [value]));\n                }\n            }\n            else {\n                dataTypes.push(param);\n                dataValues.push(value);\n            }\n        });\n        return {\n            data: this._abiCoder.encode(dataTypes, dataValues),\n            topics: topics\n        };\n    }\n    // Decode a filter for the event and the search criteria\n    decodeEventLog(eventFragment, data, topics) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        if (topics != null && !eventFragment.anonymous) {\n            let topicHash = this.getEventTopic(eventFragment);\n            if (!isHexString(topics[0], 32) || topics[0].toLowerCase() !== topicHash) {\n                logger.throwError(\"fragment/topic mismatch\", Logger.errors.INVALID_ARGUMENT, { argument: \"topics[0]\", expected: topicHash, value: topics[0] });\n            }\n            topics = topics.slice(1);\n        }\n        let indexed = [];\n        let nonIndexed = [];\n        let dynamic = [];\n        eventFragment.inputs.forEach((param, index) => {\n            if (param.indexed) {\n                if (param.type === \"string\" || param.type === \"bytes\" || param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    indexed.push(ParamType.fromObject({ type: \"bytes32\", name: param.name }));\n                    dynamic.push(true);\n                }\n                else {\n                    indexed.push(param);\n                    dynamic.push(false);\n                }\n            }\n            else {\n                nonIndexed.push(param);\n                dynamic.push(false);\n            }\n        });\n        let resultIndexed = (topics != null) ? this._abiCoder.decode(indexed, concat(topics)) : null;\n        let resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);\n        let result = [];\n        let nonIndexedIndex = 0, indexedIndex = 0;\n        eventFragment.inputs.forEach((param, index) => {\n            if (param.indexed) {\n                if (resultIndexed == null) {\n                    result[index] = new Indexed({ _isIndexed: true, hash: null });\n                }\n                else if (dynamic[index]) {\n                    result[index] = new Indexed({ _isIndexed: true, hash: resultIndexed[indexedIndex++] });\n                }\n                else {\n                    try {\n                        result[index] = resultIndexed[indexedIndex++];\n                    }\n                    catch (error) {\n                        result[index] = error;\n                    }\n                }\n            }\n            else {\n                try {\n                    result[index] = resultNonIndexed[nonIndexedIndex++];\n                }\n                catch (error) {\n                    result[index] = error;\n                }\n            }\n            // Add the keyword argument if named and safe\n            if (param.name && result[param.name] == null) {\n                const value = result[index];\n                // Make error named values throw on access\n                if (value instanceof Error) {\n                    Object.defineProperty(result, param.name, {\n                        enumerable: true,\n                        get: () => { throw wrapAccessError(`property ${JSON.stringify(param.name)}`, value); }\n                    });\n                }\n                else {\n                    result[param.name] = value;\n                }\n            }\n        });\n        // Make all error indexed values throw on access\n        for (let i = 0; i < result.length; i++) {\n            const value = result[i];\n            if (value instanceof Error) {\n                Object.defineProperty(result, i, {\n                    enumerable: true,\n                    get: () => { throw wrapAccessError(`index ${i}`, value); }\n                });\n            }\n        }\n        return Object.freeze(result);\n    }\n    // Given a transaction, find the matching function fragment (if any) and\n    // determine all its properties and call parameters\n    parseTransaction(tx) {\n        let fragment = this.getFunction(tx.data.substring(0, 10).toLowerCase());\n        if (!fragment) {\n            return null;\n        }\n        return new TransactionDescription({\n            args: this._abiCoder.decode(fragment.inputs, \"0x\" + tx.data.substring(10)),\n            functionFragment: fragment,\n            name: fragment.name,\n            signature: fragment.format(),\n            sighash: this.getSighash(fragment),\n            value: BigNumber.from(tx.value || \"0\"),\n        });\n    }\n    // @TODO\n    //parseCallResult(data: BytesLike): ??\n    // Given an event log, find the matching event fragment (if any) and\n    // determine all its properties and values\n    parseLog(log) {\n        let fragment = this.getEvent(log.topics[0]);\n        if (!fragment || fragment.anonymous) {\n            return null;\n        }\n        // @TODO: If anonymous, and the only method, and the input count matches, should we parse?\n        //        Probably not, because just because it is the only event in the ABI does\n        //        not mean we have the full ABI; maybe just a fragment?\n        return new LogDescription({\n            eventFragment: fragment,\n            name: fragment.name,\n            signature: fragment.format(),\n            topic: this.getEventTopic(fragment),\n            args: this.decodeEventLog(fragment, log.data, log.topics)\n        });\n    }\n    parseError(data) {\n        const hexData = hexlify(data);\n        let fragment = this.getError(hexData.substring(0, 10).toLowerCase());\n        if (!fragment) {\n            return null;\n        }\n        return new ErrorDescription({\n            args: this._abiCoder.decode(fragment.inputs, \"0x\" + hexData.substring(10)),\n            errorFragment: fragment,\n            name: fragment.name,\n            signature: fragment.format(),\n            sighash: this.getSighash(fragment),\n        });\n    }\n    /*\n    static from(value: Array<Fragment | string | JsonAbi> | string | Interface) {\n        if (Interface.isInterface(value)) {\n            return value;\n        }\n        if (typeof(value) === \"string\") {\n            return new Interface(JSON.parse(value));\n        }\n        return new Interface(value);\n    }\n    */\n    static isInterface(value) {\n        return !!(value && value._isInterface);\n    }\n}\n//# sourceMappingURL=interface.js.map","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}","import _typeof from \"./typeof.js\";\nexport default function _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","\"use strict\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n;\nconst _constructorGuard = {};\nlet ModifiersBytes = { calldata: true, memory: true, storage: true };\nlet ModifiersNest = { calldata: true, memory: true };\nfunction checkModifier(type, name) {\n    if (type === \"bytes\" || type === \"string\") {\n        if (ModifiersBytes[name]) {\n            return true;\n        }\n    }\n    else if (type === \"address\") {\n        if (name === \"payable\") {\n            return true;\n        }\n    }\n    else if (type.indexOf(\"[\") >= 0 || type === \"tuple\") {\n        if (ModifiersNest[name]) {\n            return true;\n        }\n    }\n    if (ModifiersBytes[name] || name === \"payable\") {\n        logger.throwArgumentError(\"invalid modifier\", \"name\", name);\n    }\n    return false;\n}\n// @TODO: Make sure that children of an indexed tuple are marked with a null indexed\nfunction parseParamType(param, allowIndexed) {\n    let originalParam = param;\n    function throwError(i) {\n        logger.throwArgumentError(`unexpected character at position ${i}`, \"param\", param);\n    }\n    param = param.replace(/\\s/g, \" \");\n    function newNode(parent) {\n        let node = { type: \"\", name: \"\", parent: parent, state: { allowType: true } };\n        if (allowIndexed) {\n            node.indexed = false;\n        }\n        return node;\n    }\n    let parent = { type: \"\", name: \"\", state: { allowType: true } };\n    let node = parent;\n    for (let i = 0; i < param.length; i++) {\n        let c = param[i];\n        switch (c) {\n            case \"(\":\n                if (node.state.allowType && node.type === \"\") {\n                    node.type = \"tuple\";\n                }\n                else if (!node.state.allowParams) {\n                    throwError(i);\n                }\n                node.state.allowType = false;\n                node.type = verifyType(node.type);\n                node.components = [newNode(node)];\n                node = node.components[0];\n                break;\n            case \")\":\n                delete node.state;\n                if (node.name === \"indexed\") {\n                    if (!allowIndexed) {\n                        throwError(i);\n                    }\n                    node.indexed = true;\n                    node.name = \"\";\n                }\n                if (checkModifier(node.type, node.name)) {\n                    node.name = \"\";\n                }\n                node.type = verifyType(node.type);\n                let child = node;\n                node = node.parent;\n                if (!node) {\n                    throwError(i);\n                }\n                delete child.parent;\n                node.state.allowParams = false;\n                node.state.allowName = true;\n                node.state.allowArray = true;\n                break;\n            case \",\":\n                delete node.state;\n                if (node.name === \"indexed\") {\n                    if (!allowIndexed) {\n                        throwError(i);\n                    }\n                    node.indexed = true;\n                    node.name = \"\";\n                }\n                if (checkModifier(node.type, node.name)) {\n                    node.name = \"\";\n                }\n                node.type = verifyType(node.type);\n                let sibling = newNode(node.parent);\n                //{ type: \"\", name: \"\", parent: node.parent, state: { allowType: true } };\n                node.parent.components.push(sibling);\n                delete node.parent;\n                node = sibling;\n                break;\n            // Hit a space...\n            case \" \":\n                // If reading type, the type is done and may read a param or name\n                if (node.state.allowType) {\n                    if (node.type !== \"\") {\n                        node.type = verifyType(node.type);\n                        delete node.state.allowType;\n                        node.state.allowName = true;\n                        node.state.allowParams = true;\n                    }\n                }\n                // If reading name, the name is done\n                if (node.state.allowName) {\n                    if (node.name !== \"\") {\n                        if (node.name === \"indexed\") {\n                            if (!allowIndexed) {\n                                throwError(i);\n                            }\n                            if (node.indexed) {\n                                throwError(i);\n                            }\n                            node.indexed = true;\n                            node.name = \"\";\n                        }\n                        else if (checkModifier(node.type, node.name)) {\n                            node.name = \"\";\n                        }\n                        else {\n                            node.state.allowName = false;\n                        }\n                    }\n                }\n                break;\n            case \"[\":\n                if (!node.state.allowArray) {\n                    throwError(i);\n                }\n                node.type += c;\n                node.state.allowArray = false;\n                node.state.allowName = false;\n                node.state.readArray = true;\n                break;\n            case \"]\":\n                if (!node.state.readArray) {\n                    throwError(i);\n                }\n                node.type += c;\n                node.state.readArray = false;\n                node.state.allowArray = true;\n                node.state.allowName = true;\n                break;\n            default:\n                if (node.state.allowType) {\n                    node.type += c;\n                    node.state.allowParams = true;\n                    node.state.allowArray = true;\n                }\n                else if (node.state.allowName) {\n                    node.name += c;\n                    delete node.state.allowArray;\n                }\n                else if (node.state.readArray) {\n                    node.type += c;\n                }\n                else {\n                    throwError(i);\n                }\n        }\n    }\n    if (node.parent) {\n        logger.throwArgumentError(\"unexpected eof\", \"param\", param);\n    }\n    delete parent.state;\n    if (node.name === \"indexed\") {\n        if (!allowIndexed) {\n            throwError(originalParam.length - 7);\n        }\n        if (node.indexed) {\n            throwError(originalParam.length - 7);\n        }\n        node.indexed = true;\n        node.name = \"\";\n    }\n    else if (checkModifier(node.type, node.name)) {\n        node.name = \"\";\n    }\n    parent.type = verifyType(parent.type);\n    return parent;\n}\nfunction populate(object, params) {\n    for (let key in params) {\n        defineReadOnly(object, key, params[key]);\n    }\n}\nexport const FormatTypes = Object.freeze({\n    // Bare formatting, as is needed for computing a sighash of an event or function\n    sighash: \"sighash\",\n    // Human-Readable with Minimal spacing and without names (compact human-readable)\n    minimal: \"minimal\",\n    // Human-Readable with nice spacing, including all names\n    full: \"full\",\n    // JSON-format a la Solidity\n    json: \"json\"\n});\nconst paramTypeArray = new RegExp(/^(.*)\\[([0-9]*)\\]$/);\nexport class ParamType {\n    constructor(constructorGuard, params) {\n        if (constructorGuard !== _constructorGuard) {\n            logger.throwError(\"use fromString\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"new ParamType()\"\n            });\n        }\n        populate(this, params);\n        let match = this.type.match(paramTypeArray);\n        if (match) {\n            populate(this, {\n                arrayLength: parseInt(match[2] || \"-1\"),\n                arrayChildren: ParamType.fromObject({\n                    type: match[1],\n                    components: this.components\n                }),\n                baseType: \"array\"\n            });\n        }\n        else {\n            populate(this, {\n                arrayLength: null,\n                arrayChildren: null,\n                baseType: ((this.components != null) ? \"tuple\" : this.type)\n            });\n        }\n        this._isParamType = true;\n        Object.freeze(this);\n    }\n    // Format the parameter fragment\n    //   - sighash: \"(uint256,address)\"\n    //   - minimal: \"tuple(uint256,address) indexed\"\n    //   - full:    \"tuple(uint256 foo, address bar) indexed baz\"\n    format(format) {\n        if (!format) {\n            format = FormatTypes.sighash;\n        }\n        if (!FormatTypes[format]) {\n            logger.throwArgumentError(\"invalid format type\", \"format\", format);\n        }\n        if (format === FormatTypes.json) {\n            let result = {\n                type: ((this.baseType === \"tuple\") ? \"tuple\" : this.type),\n                name: (this.name || undefined)\n            };\n            if (typeof (this.indexed) === \"boolean\") {\n                result.indexed = this.indexed;\n            }\n            if (this.components) {\n                result.components = this.components.map((comp) => JSON.parse(comp.format(format)));\n            }\n            return JSON.stringify(result);\n        }\n        let result = \"\";\n        // Array\n        if (this.baseType === \"array\") {\n            result += this.arrayChildren.format(format);\n            result += \"[\" + (this.arrayLength < 0 ? \"\" : String(this.arrayLength)) + \"]\";\n        }\n        else {\n            if (this.baseType === \"tuple\") {\n                if (format !== FormatTypes.sighash) {\n                    result += this.type;\n                }\n                result += \"(\" + this.components.map((comp) => comp.format(format)).join((format === FormatTypes.full) ? \", \" : \",\") + \")\";\n            }\n            else {\n                result += this.type;\n            }\n        }\n        if (format !== FormatTypes.sighash) {\n            if (this.indexed === true) {\n                result += \" indexed\";\n            }\n            if (format === FormatTypes.full && this.name) {\n                result += \" \" + this.name;\n            }\n        }\n        return result;\n    }\n    static from(value, allowIndexed) {\n        if (typeof (value) === \"string\") {\n            return ParamType.fromString(value, allowIndexed);\n        }\n        return ParamType.fromObject(value);\n    }\n    static fromObject(value) {\n        if (ParamType.isParamType(value)) {\n            return value;\n        }\n        return new ParamType(_constructorGuard, {\n            name: (value.name || null),\n            type: verifyType(value.type),\n            indexed: ((value.indexed == null) ? null : !!value.indexed),\n            components: (value.components ? value.components.map(ParamType.fromObject) : null)\n        });\n    }\n    static fromString(value, allowIndexed) {\n        function ParamTypify(node) {\n            return ParamType.fromObject({\n                name: node.name,\n                type: node.type,\n                indexed: node.indexed,\n                components: node.components\n            });\n        }\n        return ParamTypify(parseParamType(value, !!allowIndexed));\n    }\n    static isParamType(value) {\n        return !!(value != null && value._isParamType);\n    }\n}\n;\nfunction parseParams(value, allowIndex) {\n    return splitNesting(value).map((param) => ParamType.fromString(param, allowIndex));\n}\nexport class Fragment {\n    constructor(constructorGuard, params) {\n        if (constructorGuard !== _constructorGuard) {\n            logger.throwError(\"use a static from method\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"new Fragment()\"\n            });\n        }\n        populate(this, params);\n        this._isFragment = true;\n        Object.freeze(this);\n    }\n    static from(value) {\n        if (Fragment.isFragment(value)) {\n            return value;\n        }\n        if (typeof (value) === \"string\") {\n            return Fragment.fromString(value);\n        }\n        return Fragment.fromObject(value);\n    }\n    static fromObject(value) {\n        if (Fragment.isFragment(value)) {\n            return value;\n        }\n        switch (value.type) {\n            case \"function\":\n                return FunctionFragment.fromObject(value);\n            case \"event\":\n                return EventFragment.fromObject(value);\n            case \"constructor\":\n                return ConstructorFragment.fromObject(value);\n            case \"error\":\n                return ErrorFragment.fromObject(value);\n            case \"fallback\":\n            case \"receive\":\n                // @TODO: Something? Maybe return a FunctionFragment? A custom DefaultFunctionFragment?\n                return null;\n        }\n        return logger.throwArgumentError(\"invalid fragment object\", \"value\", value);\n    }\n    static fromString(value) {\n        // Make sure the \"returns\" is surrounded by a space and all whitespace is exactly one space\n        value = value.replace(/\\s/g, \" \");\n        value = value.replace(/\\(/g, \" (\").replace(/\\)/g, \") \").replace(/\\s+/g, \" \");\n        value = value.trim();\n        if (value.split(\" \")[0] === \"event\") {\n            return EventFragment.fromString(value.substring(5).trim());\n        }\n        else if (value.split(\" \")[0] === \"function\") {\n            return FunctionFragment.fromString(value.substring(8).trim());\n        }\n        else if (value.split(\"(\")[0].trim() === \"constructor\") {\n            return ConstructorFragment.fromString(value.trim());\n        }\n        else if (value.split(\" \")[0] === \"error\") {\n            return ErrorFragment.fromString(value.substring(5).trim());\n        }\n        return logger.throwArgumentError(\"unsupported fragment\", \"value\", value);\n    }\n    static isFragment(value) {\n        return !!(value && value._isFragment);\n    }\n}\nexport class EventFragment extends Fragment {\n    format(format) {\n        if (!format) {\n            format = FormatTypes.sighash;\n        }\n        if (!FormatTypes[format]) {\n            logger.throwArgumentError(\"invalid format type\", \"format\", format);\n        }\n        if (format === FormatTypes.json) {\n            return JSON.stringify({\n                type: \"event\",\n                anonymous: this.anonymous,\n                name: this.name,\n                inputs: this.inputs.map((input) => JSON.parse(input.format(format)))\n            });\n        }\n        let result = \"\";\n        if (format !== FormatTypes.sighash) {\n            result += \"event \";\n        }\n        result += this.name + \"(\" + this.inputs.map((input) => input.format(format)).join((format === FormatTypes.full) ? \", \" : \",\") + \") \";\n        if (format !== FormatTypes.sighash) {\n            if (this.anonymous) {\n                result += \"anonymous \";\n            }\n        }\n        return result.trim();\n    }\n    static from(value) {\n        if (typeof (value) === \"string\") {\n            return EventFragment.fromString(value);\n        }\n        return EventFragment.fromObject(value);\n    }\n    static fromObject(value) {\n        if (EventFragment.isEventFragment(value)) {\n            return value;\n        }\n        if (value.type !== \"event\") {\n            logger.throwArgumentError(\"invalid event object\", \"value\", value);\n        }\n        const params = {\n            name: verifyIdentifier(value.name),\n            anonymous: value.anonymous,\n            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),\n            type: \"event\"\n        };\n        return new EventFragment(_constructorGuard, params);\n    }\n    static fromString(value) {\n        let match = value.match(regexParen);\n        if (!match) {\n            logger.throwArgumentError(\"invalid event string\", \"value\", value);\n        }\n        let anonymous = false;\n        match[3].split(\" \").forEach((modifier) => {\n            switch (modifier.trim()) {\n                case \"anonymous\":\n                    anonymous = true;\n                    break;\n                case \"\":\n                    break;\n                default:\n                    logger.warn(\"unknown modifier: \" + modifier);\n            }\n        });\n        return EventFragment.fromObject({\n            name: match[1].trim(),\n            anonymous: anonymous,\n            inputs: parseParams(match[2], true),\n            type: \"event\"\n        });\n    }\n    static isEventFragment(value) {\n        return (value && value._isFragment && value.type === \"event\");\n    }\n}\nfunction parseGas(value, params) {\n    params.gas = null;\n    let comps = value.split(\"@\");\n    if (comps.length !== 1) {\n        if (comps.length > 2) {\n            logger.throwArgumentError(\"invalid human-readable ABI signature\", \"value\", value);\n        }\n        if (!comps[1].match(/^[0-9]+$/)) {\n            logger.throwArgumentError(\"invalid human-readable ABI signature gas\", \"value\", value);\n        }\n        params.gas = BigNumber.from(comps[1]);\n        return comps[0];\n    }\n    return value;\n}\nfunction parseModifiers(value, params) {\n    params.constant = false;\n    params.payable = false;\n    params.stateMutability = \"nonpayable\";\n    value.split(\" \").forEach((modifier) => {\n        switch (modifier.trim()) {\n            case \"constant\":\n                params.constant = true;\n                break;\n            case \"payable\":\n                params.payable = true;\n                params.stateMutability = \"payable\";\n                break;\n            case \"nonpayable\":\n                params.payable = false;\n                params.stateMutability = \"nonpayable\";\n                break;\n            case \"pure\":\n                params.constant = true;\n                params.stateMutability = \"pure\";\n                break;\n            case \"view\":\n                params.constant = true;\n                params.stateMutability = \"view\";\n                break;\n            case \"external\":\n            case \"public\":\n            case \"\":\n                break;\n            default:\n                console.log(\"unknown modifier: \" + modifier);\n        }\n    });\n}\nfunction verifyState(value) {\n    let result = {\n        constant: false,\n        payable: true,\n        stateMutability: \"payable\"\n    };\n    if (value.stateMutability != null) {\n        result.stateMutability = value.stateMutability;\n        // Set (and check things are consistent) the constant property\n        result.constant = (result.stateMutability === \"view\" || result.stateMutability === \"pure\");\n        if (value.constant != null) {\n            if ((!!value.constant) !== result.constant) {\n                logger.throwArgumentError(\"cannot have constant function with mutability \" + result.stateMutability, \"value\", value);\n            }\n        }\n        // Set (and check things are consistent) the payable property\n        result.payable = (result.stateMutability === \"payable\");\n        if (value.payable != null) {\n            if ((!!value.payable) !== result.payable) {\n                logger.throwArgumentError(\"cannot have payable function with mutability \" + result.stateMutability, \"value\", value);\n            }\n        }\n    }\n    else if (value.payable != null) {\n        result.payable = !!value.payable;\n        // If payable we can assume non-constant; otherwise we can't assume\n        if (value.constant == null && !result.payable && value.type !== \"constructor\") {\n            logger.throwArgumentError(\"unable to determine stateMutability\", \"value\", value);\n        }\n        result.constant = !!value.constant;\n        if (result.constant) {\n            result.stateMutability = \"view\";\n        }\n        else {\n            result.stateMutability = (result.payable ? \"payable\" : \"nonpayable\");\n        }\n        if (result.payable && result.constant) {\n            logger.throwArgumentError(\"cannot have constant payable function\", \"value\", value);\n        }\n    }\n    else if (value.constant != null) {\n        result.constant = !!value.constant;\n        result.payable = !result.constant;\n        result.stateMutability = (result.constant ? \"view\" : \"payable\");\n    }\n    else if (value.type !== \"constructor\") {\n        logger.throwArgumentError(\"unable to determine stateMutability\", \"value\", value);\n    }\n    return result;\n}\nexport class ConstructorFragment extends Fragment {\n    format(format) {\n        if (!format) {\n            format = FormatTypes.sighash;\n        }\n        if (!FormatTypes[format]) {\n            logger.throwArgumentError(\"invalid format type\", \"format\", format);\n        }\n        if (format === FormatTypes.json) {\n            return JSON.stringify({\n                type: \"constructor\",\n                stateMutability: ((this.stateMutability !== \"nonpayable\") ? this.stateMutability : undefined),\n                payable: this.payable,\n                gas: (this.gas ? this.gas.toNumber() : undefined),\n                inputs: this.inputs.map((input) => JSON.parse(input.format(format)))\n            });\n        }\n        if (format === FormatTypes.sighash) {\n            logger.throwError(\"cannot format a constructor for sighash\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"format(sighash)\"\n            });\n        }\n        let result = \"constructor(\" + this.inputs.map((input) => input.format(format)).join((format === FormatTypes.full) ? \", \" : \",\") + \") \";\n        if (this.stateMutability && this.stateMutability !== \"nonpayable\") {\n            result += this.stateMutability + \" \";\n        }\n        return result.trim();\n    }\n    static from(value) {\n        if (typeof (value) === \"string\") {\n            return ConstructorFragment.fromString(value);\n        }\n        return ConstructorFragment.fromObject(value);\n    }\n    static fromObject(value) {\n        if (ConstructorFragment.isConstructorFragment(value)) {\n            return value;\n        }\n        if (value.type !== \"constructor\") {\n            logger.throwArgumentError(\"invalid constructor object\", \"value\", value);\n        }\n        let state = verifyState(value);\n        if (state.constant) {\n            logger.throwArgumentError(\"constructor cannot be constant\", \"value\", value);\n        }\n        const params = {\n            name: null,\n            type: value.type,\n            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),\n            payable: state.payable,\n            stateMutability: state.stateMutability,\n            gas: (value.gas ? BigNumber.from(value.gas) : null)\n        };\n        return new ConstructorFragment(_constructorGuard, params);\n    }\n    static fromString(value) {\n        let params = { type: \"constructor\" };\n        value = parseGas(value, params);\n        let parens = value.match(regexParen);\n        if (!parens || parens[1].trim() !== \"constructor\") {\n            logger.throwArgumentError(\"invalid constructor string\", \"value\", value);\n        }\n        params.inputs = parseParams(parens[2].trim(), false);\n        parseModifiers(parens[3].trim(), params);\n        return ConstructorFragment.fromObject(params);\n    }\n    static isConstructorFragment(value) {\n        return (value && value._isFragment && value.type === \"constructor\");\n    }\n}\nexport class FunctionFragment extends ConstructorFragment {\n    format(format) {\n        if (!format) {\n            format = FormatTypes.sighash;\n        }\n        if (!FormatTypes[format]) {\n            logger.throwArgumentError(\"invalid format type\", \"format\", format);\n        }\n        if (format === FormatTypes.json) {\n            return JSON.stringify({\n                type: \"function\",\n                name: this.name,\n                constant: this.constant,\n                stateMutability: ((this.stateMutability !== \"nonpayable\") ? this.stateMutability : undefined),\n                payable: this.payable,\n                gas: (this.gas ? this.gas.toNumber() : undefined),\n                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),\n                outputs: this.outputs.map((output) => JSON.parse(output.format(format))),\n            });\n        }\n        let result = \"\";\n        if (format !== FormatTypes.sighash) {\n            result += \"function \";\n        }\n        result += this.name + \"(\" + this.inputs.map((input) => input.format(format)).join((format === FormatTypes.full) ? \", \" : \",\") + \") \";\n        if (format !== FormatTypes.sighash) {\n            if (this.stateMutability) {\n                if (this.stateMutability !== \"nonpayable\") {\n                    result += (this.stateMutability + \" \");\n                }\n            }\n            else if (this.constant) {\n                result += \"view \";\n            }\n            if (this.outputs && this.outputs.length) {\n                result += \"returns (\" + this.outputs.map((output) => output.format(format)).join(\", \") + \") \";\n            }\n            if (this.gas != null) {\n                result += \"@\" + this.gas.toString() + \" \";\n            }\n        }\n        return result.trim();\n    }\n    static from(value) {\n        if (typeof (value) === \"string\") {\n            return FunctionFragment.fromString(value);\n        }\n        return FunctionFragment.fromObject(value);\n    }\n    static fromObject(value) {\n        if (FunctionFragment.isFunctionFragment(value)) {\n            return value;\n        }\n        if (value.type !== \"function\") {\n            logger.throwArgumentError(\"invalid function object\", \"value\", value);\n        }\n        let state = verifyState(value);\n        const params = {\n            type: value.type,\n            name: verifyIdentifier(value.name),\n            constant: state.constant,\n            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : []),\n            outputs: (value.outputs ? value.outputs.map(ParamType.fromObject) : []),\n            payable: state.payable,\n            stateMutability: state.stateMutability,\n            gas: (value.gas ? BigNumber.from(value.gas) : null)\n        };\n        return new FunctionFragment(_constructorGuard, params);\n    }\n    static fromString(value) {\n        let params = { type: \"function\" };\n        value = parseGas(value, params);\n        let comps = value.split(\" returns \");\n        if (comps.length > 2) {\n            logger.throwArgumentError(\"invalid function string\", \"value\", value);\n        }\n        let parens = comps[0].match(regexParen);\n        if (!parens) {\n            logger.throwArgumentError(\"invalid function signature\", \"value\", value);\n        }\n        params.name = parens[1].trim();\n        if (params.name) {\n            verifyIdentifier(params.name);\n        }\n        params.inputs = parseParams(parens[2], false);\n        parseModifiers(parens[3].trim(), params);\n        // We have outputs\n        if (comps.length > 1) {\n            let returns = comps[1].match(regexParen);\n            if (returns[1].trim() != \"\" || returns[3].trim() != \"\") {\n                logger.throwArgumentError(\"unexpected tokens\", \"value\", value);\n            }\n            params.outputs = parseParams(returns[2], false);\n        }\n        else {\n            params.outputs = [];\n        }\n        return FunctionFragment.fromObject(params);\n    }\n    static isFunctionFragment(value) {\n        return (value && value._isFragment && value.type === \"function\");\n    }\n}\n//export class StructFragment extends Fragment {\n//}\nfunction checkForbidden(fragment) {\n    const sig = fragment.format();\n    if (sig === \"Error(string)\" || sig === \"Panic(uint256)\") {\n        logger.throwArgumentError(`cannot specify user defined ${sig} error`, \"fragment\", fragment);\n    }\n    return fragment;\n}\nexport class ErrorFragment extends Fragment {\n    format(format) {\n        if (!format) {\n            format = FormatTypes.sighash;\n        }\n        if (!FormatTypes[format]) {\n            logger.throwArgumentError(\"invalid format type\", \"format\", format);\n        }\n        if (format === FormatTypes.json) {\n            return JSON.stringify({\n                type: \"error\",\n                name: this.name,\n                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),\n            });\n        }\n        let result = \"\";\n        if (format !== FormatTypes.sighash) {\n            result += \"error \";\n        }\n        result += this.name + \"(\" + this.inputs.map((input) => input.format(format)).join((format === FormatTypes.full) ? \", \" : \",\") + \") \";\n        return result.trim();\n    }\n    static from(value) {\n        if (typeof (value) === \"string\") {\n            return ErrorFragment.fromString(value);\n        }\n        return ErrorFragment.fromObject(value);\n    }\n    static fromObject(value) {\n        if (ErrorFragment.isErrorFragment(value)) {\n            return value;\n        }\n        if (value.type !== \"error\") {\n            logger.throwArgumentError(\"invalid error object\", \"value\", value);\n        }\n        const params = {\n            type: value.type,\n            name: verifyIdentifier(value.name),\n            inputs: (value.inputs ? value.inputs.map(ParamType.fromObject) : [])\n        };\n        return checkForbidden(new ErrorFragment(_constructorGuard, params));\n    }\n    static fromString(value) {\n        let params = { type: \"error\" };\n        let parens = value.match(regexParen);\n        if (!parens) {\n            logger.throwArgumentError(\"invalid error signature\", \"value\", value);\n        }\n        params.name = parens[1].trim();\n        if (params.name) {\n            verifyIdentifier(params.name);\n        }\n        params.inputs = parseParams(parens[2], false);\n        return checkForbidden(ErrorFragment.fromObject(params));\n    }\n    static isErrorFragment(value) {\n        return (value && value._isFragment && value.type === \"error\");\n    }\n}\nfunction verifyType(type) {\n    // These need to be transformed to their full description\n    if (type.match(/^uint($|[^1-9])/)) {\n        type = \"uint256\" + type.substring(4);\n    }\n    else if (type.match(/^int($|[^1-9])/)) {\n        type = \"int256\" + type.substring(3);\n    }\n    // @TODO: more verification\n    return type;\n}\n// See: https://github.com/ethereum/solidity/blob/1f8f1a3db93a548d0555e3e14cfc55a10e25b60e/docs/grammar/SolidityLexer.g4#L234\nconst regexIdentifier = new RegExp(\"^[a-zA-Z$_][a-zA-Z0-9$_]*$\");\nfunction verifyIdentifier(value) {\n    if (!value || !value.match(regexIdentifier)) {\n        logger.throwArgumentError(`invalid identifier \"${value}\"`, \"value\", value);\n    }\n    return value;\n}\nconst regexParen = new RegExp(\"^([^)(]*)\\\\((.*)\\\\)([^)(]*)$\");\nfunction splitNesting(value) {\n    value = value.trim();\n    let result = [];\n    let accum = \"\";\n    let depth = 0;\n    for (let offset = 0; offset < value.length; offset++) {\n        let c = value[offset];\n        if (c === \",\" && depth === 0) {\n            result.push(accum);\n            accum = \"\";\n        }\n        else {\n            accum += c;\n            if (c === \"(\") {\n                depth++;\n            }\n            else if (c === \")\") {\n                depth--;\n                if (depth === -1) {\n                    logger.throwArgumentError(\"unbalanced parenthesis\", \"value\", value);\n                }\n            }\n        }\n    }\n    if (accum) {\n        result.push(accum);\n    }\n    return result;\n}\n//# sourceMappingURL=fragments.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 { BigNumber } from \"@ethersproject/bignumber\";\nimport { isHexString } from \"@ethersproject/bytes\";\nimport { Description, defineReadOnly, resolveProperties } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n;\n;\n//export type CallTransactionable = {\n//    call(transaction: TransactionRequest): Promise<TransactionResponse>;\n//};\nexport class ForkEvent extends Description {\n    static isForkEvent(value) {\n        return !!(value && value._isForkEvent);\n    }\n}\nexport class BlockForkEvent extends ForkEvent {\n    constructor(blockHash, expiry) {\n        if (!isHexString(blockHash, 32)) {\n            logger.throwArgumentError(\"invalid blockHash\", \"blockHash\", blockHash);\n        }\n        super({\n            _isForkEvent: true,\n            _isBlockForkEvent: true,\n            expiry: (expiry || 0),\n            blockHash: blockHash\n        });\n    }\n}\nexport class TransactionForkEvent extends ForkEvent {\n    constructor(hash, expiry) {\n        if (!isHexString(hash, 32)) {\n            logger.throwArgumentError(\"invalid transaction hash\", \"hash\", hash);\n        }\n        super({\n            _isForkEvent: true,\n            _isTransactionForkEvent: true,\n            expiry: (expiry || 0),\n            hash: hash\n        });\n    }\n}\nexport class TransactionOrderForkEvent extends ForkEvent {\n    constructor(beforeHash, afterHash, expiry) {\n        if (!isHexString(beforeHash, 32)) {\n            logger.throwArgumentError(\"invalid transaction hash\", \"beforeHash\", beforeHash);\n        }\n        if (!isHexString(afterHash, 32)) {\n            logger.throwArgumentError(\"invalid transaction hash\", \"afterHash\", afterHash);\n        }\n        super({\n            _isForkEvent: true,\n            _isTransactionOrderForkEvent: true,\n            expiry: (expiry || 0),\n            beforeHash: beforeHash,\n            afterHash: afterHash\n        });\n    }\n}\n///////////////////////////////\n// Exported Abstracts\nexport class Provider {\n    constructor() {\n        logger.checkAbstract(new.target, Provider);\n        defineReadOnly(this, \"_isProvider\", true);\n    }\n    getFeeData() {\n        return __awaiter(this, void 0, void 0, function* () {\n            const { block, gasPrice } = yield resolveProperties({\n                block: this.getBlock(\"latest\"),\n                gasPrice: this.getGasPrice().catch((error) => {\n                    // @TODO: Why is this now failing on Calaveras?\n                    //console.log(error);\n                    return null;\n                })\n            });\n            let lastBaseFeePerGas = null, maxFeePerGas = null, maxPriorityFeePerGas = null;\n            if (block && block.baseFeePerGas) {\n                // We may want to compute this more accurately in the future,\n                // using the formula \"check if the base fee is correct\".\n                // See: https://eips.ethereum.org/EIPS/eip-1559\n                lastBaseFeePerGas = block.baseFeePerGas;\n                maxPriorityFeePerGas = BigNumber.from(\"1500000000\");\n                maxFeePerGas = block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas);\n            }\n            return { lastBaseFeePerGas, maxFeePerGas, maxPriorityFeePerGas, gasPrice };\n        });\n    }\n    // Alias for \"on\"\n    addListener(eventName, listener) {\n        return this.on(eventName, listener);\n    }\n    // Alias for \"off\"\n    removeListener(eventName, listener) {\n        return this.off(eventName, listener);\n    }\n    static isProvider(value) {\n        return !!(value && value._isProvider);\n    }\n}\n//# sourceMappingURL=index.js.map","export const version = \"abstract-provider/5.7.0\";\n//# sourceMappingURL=_version.js.map"],"sourceRoot":""}