{"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/@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","checkNew","_getCoder","param","arrayChildren","arrayLength","components","component","_getWordSize","_getReader","_getWriter","getDefaultValue","P","defaultAbiCoder","__awaiter","thisArg","_arguments","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","_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","input","isEventFragment","verifyIdentifier","regexParen","modifier","parseGas","gas","comps","parseModifiers","constant","stateMutability","console","verifyState","isConstructorFragment","parens","output","toString","isFunctionFragment","returns","checkForbidden","sig","isErrorFragment","regexIdentifier","_isForkEvent","getBlock","baseFeePerGas","addListener","eventName","listener","on","removeListener","off","_isProvider"],"mappings":"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","file":"js/chunk-vendors~3622465b.8f1c63cd.js","sourcesContent":["export const version = \"abi/5.6.1\";\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.6.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        logger.checkNew(new.target, AbiCoder);\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        logger.checkNew(new.target, VoidSigner);\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.6.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        logger.checkNew(new.target, Interface);\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            // 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","\"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 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                maxPriorityFeePerGas = BigNumber.from(\"1500000000\");\n                maxFeePerGas = block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas);\n            }\n            return { 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.6.0\";\n//# sourceMappingURL=_version.js.map"],"sourceRoot":""}