{"version":3,"file":"index.9d71f849.js","sources":["../../../node_modules/@ethersproject/abi/lib.esm/_version.js","../../../node_modules/@ethersproject/abi/lib.esm/fragments.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/address.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/anonymous.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/array.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/boolean.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/bytes.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/fixed-bytes.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/null.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/number.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/string.js","../../../node_modules/@ethersproject/abi/lib.esm/coders/tuple.js","../../../node_modules/@ethersproject/abi/lib.esm/abi-coder.js","../../../node_modules/@ethersproject/abi/lib.esm/interface.js","../../../node_modules/@ethersproject/contracts/lib.esm/_version.js","../../../node_modules/@ethersproject/contracts/lib.esm/index.js"],"sourcesContent":["export const version = \"abi/5.7.0\";\n//# sourceMappingURL=_version.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\";\nimport { arrayify, concat, hexConcat, hexlify } from \"@ethersproject/bytes\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"../_version\";\nconst logger = new Logger(version);\nexport function checkResultErrors(result) {\n    // Find the first error (if any)\n    const errors = [];\n    const checkErrors = function (path, object) {\n        if (!Array.isArray(object)) {\n            return;\n        }\n        for (let key in object) {\n            const childPath = path.slice();\n            childPath.push(key);\n            try {\n                checkErrors(childPath, object[key]);\n            }\n            catch (error) {\n                errors.push({ path: childPath, error: error });\n            }\n        }\n    };\n    checkErrors([], result);\n    return errors;\n}\nexport class Coder {\n    constructor(name, type, localName, dynamic) {\n        // @TODO: defineReadOnly these\n        this.name = name;\n        this.type = type;\n        this.localName = localName;\n        this.dynamic = dynamic;\n    }\n    _throwError(message, value) {\n        logger.throwArgumentError(message, this.localName, value);\n    }\n}\nexport class Writer {\n    constructor(wordSize) {\n        defineReadOnly(this, \"wordSize\", wordSize || 32);\n        this._data = [];\n        this._dataLength = 0;\n        this._padding = new Uint8Array(wordSize);\n    }\n    get data() {\n        return hexConcat(this._data);\n    }\n    get length() { return this._dataLength; }\n    _writeData(data) {\n        this._data.push(data);\n        this._dataLength += data.length;\n        return data.length;\n    }\n    appendWriter(writer) {\n        return this._writeData(concat(writer._data));\n    }\n    // Arrayish items; padded on the right to wordSize\n    writeBytes(value) {\n        let bytes = arrayify(value);\n        const paddingOffset = bytes.length % this.wordSize;\n        if (paddingOffset) {\n            bytes = concat([bytes, this._padding.slice(paddingOffset)]);\n        }\n        return this._writeData(bytes);\n    }\n    _getValue(value) {\n        let bytes = arrayify(BigNumber.from(value));\n        if (bytes.length > this.wordSize) {\n            logger.throwError(\"value out-of-bounds\", Logger.errors.BUFFER_OVERRUN, {\n                length: this.wordSize,\n                offset: bytes.length\n            });\n        }\n        if (bytes.length % this.wordSize) {\n            bytes = concat([this._padding.slice(bytes.length % this.wordSize), bytes]);\n        }\n        return bytes;\n    }\n    // BigNumberish items; padded on the left to wordSize\n    writeValue(value) {\n        return this._writeData(this._getValue(value));\n    }\n    writeUpdatableValue() {\n        const offset = this._data.length;\n        this._data.push(this._padding);\n        this._dataLength += this.wordSize;\n        return (value) => {\n            this._data[offset] = this._getValue(value);\n        };\n    }\n}\nexport class Reader {\n    constructor(data, wordSize, coerceFunc, allowLoose) {\n        defineReadOnly(this, \"_data\", arrayify(data));\n        defineReadOnly(this, \"wordSize\", wordSize || 32);\n        defineReadOnly(this, \"_coerceFunc\", coerceFunc);\n        defineReadOnly(this, \"allowLoose\", allowLoose);\n        this._offset = 0;\n    }\n    get data() { return hexlify(this._data); }\n    get consumed() { return this._offset; }\n    // The default Coerce function\n    static coerce(name, value) {\n        let match = name.match(\"^u?int([0-9]+)$\");\n        if (match && parseInt(match[1]) <= 48) {\n            value = value.toNumber();\n        }\n        return value;\n    }\n    coerce(name, value) {\n        if (this._coerceFunc) {\n            return this._coerceFunc(name, value);\n        }\n        return Reader.coerce(name, value);\n    }\n    _peekBytes(offset, length, loose) {\n        let alignedLength = Math.ceil(length / this.wordSize) * this.wordSize;\n        if (this._offset + alignedLength > this._data.length) {\n            if (this.allowLoose && loose && this._offset + length <= this._data.length) {\n                alignedLength = length;\n            }\n            else {\n                logger.throwError(\"data out-of-bounds\", Logger.errors.BUFFER_OVERRUN, {\n                    length: this._data.length,\n                    offset: this._offset + alignedLength\n                });\n            }\n        }\n        return this._data.slice(this._offset, this._offset + alignedLength);\n    }\n    subReader(offset) {\n        return new Reader(this._data.slice(this._offset + offset), this.wordSize, this._coerceFunc, this.allowLoose);\n    }\n    readBytes(length, loose) {\n        let bytes = this._peekBytes(0, length, !!loose);\n        this._offset += bytes.length;\n        // @TODO: Make sure the length..end bytes are all 0?\n        return bytes.slice(0, length);\n    }\n    readValue() {\n        return BigNumber.from(this.readBytes(this.wordSize));\n    }\n}\n//# sourceMappingURL=abstract-coder.js.map","\"use strict\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { hexZeroPad } from \"@ethersproject/bytes\";\nimport { Coder } from \"./abstract-coder\";\nexport class AddressCoder extends Coder {\n    constructor(localName) {\n        super(\"address\", \"address\", localName, false);\n    }\n    defaultValue() {\n        return \"0x0000000000000000000000000000000000000000\";\n    }\n    encode(writer, value) {\n        try {\n            value = getAddress(value);\n        }\n        catch (error) {\n            this._throwError(error.message, value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        return getAddress(hexZeroPad(reader.readValue().toHexString(), 20));\n    }\n}\n//# sourceMappingURL=address.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\n// Clones the functionality of an existing Coder, but without a localName\nexport class AnonymousCoder extends Coder {\n    constructor(coder) {\n        super(coder.name, coder.type, undefined, coder.dynamic);\n        this.coder = coder;\n    }\n    defaultValue() {\n        return this.coder.defaultValue();\n    }\n    encode(writer, value) {\n        return this.coder.encode(writer, value);\n    }\n    decode(reader) {\n        return this.coder.decode(reader);\n    }\n}\n//# sourceMappingURL=anonymous.js.map","\"use strict\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"../_version\";\nconst logger = new Logger(version);\nimport { Coder, Writer } from \"./abstract-coder\";\nimport { AnonymousCoder } from \"./anonymous\";\nexport function pack(writer, coders, values) {\n    let arrayValues = null;\n    if (Array.isArray(values)) {\n        arrayValues = values;\n    }\n    else if (values && typeof (values) === \"object\") {\n        let unique = {};\n        arrayValues = coders.map((coder) => {\n            const name = coder.localName;\n            if (!name) {\n                logger.throwError(\"cannot encode object for signature with missing names\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"values\",\n                    coder: coder,\n                    value: values\n                });\n            }\n            if (unique[name]) {\n                logger.throwError(\"cannot encode object for signature with duplicate names\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"values\",\n                    coder: coder,\n                    value: values\n                });\n            }\n            unique[name] = true;\n            return values[name];\n        });\n    }\n    else {\n        logger.throwArgumentError(\"invalid tuple value\", \"tuple\", values);\n    }\n    if (coders.length !== arrayValues.length) {\n        logger.throwArgumentError(\"types/value length mismatch\", \"tuple\", values);\n    }\n    let staticWriter = new Writer(writer.wordSize);\n    let dynamicWriter = new Writer(writer.wordSize);\n    let updateFuncs = [];\n    coders.forEach((coder, index) => {\n        let value = arrayValues[index];\n        if (coder.dynamic) {\n            // Get current dynamic offset (for the future pointer)\n            let dynamicOffset = dynamicWriter.length;\n            // Encode the dynamic value into the dynamicWriter\n            coder.encode(dynamicWriter, value);\n            // Prepare to populate the correct offset once we are done\n            let updateFunc = staticWriter.writeUpdatableValue();\n            updateFuncs.push((baseOffset) => {\n                updateFunc(baseOffset + dynamicOffset);\n            });\n        }\n        else {\n            coder.encode(staticWriter, value);\n        }\n    });\n    // Backfill all the dynamic offsets, now that we know the static length\n    updateFuncs.forEach((func) => { func(staticWriter.length); });\n    let length = writer.appendWriter(staticWriter);\n    length += writer.appendWriter(dynamicWriter);\n    return length;\n}\nexport function unpack(reader, coders) {\n    let values = [];\n    // A reader anchored to this base\n    let baseReader = reader.subReader(0);\n    coders.forEach((coder) => {\n        let value = null;\n        if (coder.dynamic) {\n            let offset = reader.readValue();\n            let offsetReader = baseReader.subReader(offset.toNumber());\n            try {\n                value = coder.decode(offsetReader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (error.code === Logger.errors.BUFFER_OVERRUN) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        else {\n            try {\n                value = coder.decode(reader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (error.code === Logger.errors.BUFFER_OVERRUN) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        if (value != undefined) {\n            values.push(value);\n        }\n    });\n    // We only output named properties for uniquely named coders\n    const uniqueNames = coders.reduce((accum, coder) => {\n        const name = coder.localName;\n        if (name) {\n            if (!accum[name]) {\n                accum[name] = 0;\n            }\n            accum[name]++;\n        }\n        return accum;\n    }, {});\n    // Add any named parameters (i.e. tuples)\n    coders.forEach((coder, index) => {\n        let name = coder.localName;\n        if (!name || uniqueNames[name] !== 1) {\n            return;\n        }\n        if (name === \"length\") {\n            name = \"_length\";\n        }\n        if (values[name] != null) {\n            return;\n        }\n        const value = values[index];\n        if (value instanceof Error) {\n            Object.defineProperty(values, name, {\n                enumerable: true,\n                get: () => { throw value; }\n            });\n        }\n        else {\n            values[name] = value;\n        }\n    });\n    for (let i = 0; i < values.length; i++) {\n        const value = values[i];\n        if (value instanceof Error) {\n            Object.defineProperty(values, i, {\n                enumerable: true,\n                get: () => { throw value; }\n            });\n        }\n    }\n    return Object.freeze(values);\n}\nexport class ArrayCoder extends Coder {\n    constructor(coder, length, localName) {\n        const type = (coder.type + \"[\" + (length >= 0 ? length : \"\") + \"]\");\n        const dynamic = (length === -1 || coder.dynamic);\n        super(\"array\", type, localName, dynamic);\n        this.coder = coder;\n        this.length = length;\n    }\n    defaultValue() {\n        // Verifies the child coder is valid (even if the array is dynamic or 0-length)\n        const defaultChild = this.coder.defaultValue();\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            result.push(defaultChild);\n        }\n        return result;\n    }\n    encode(writer, value) {\n        if (!Array.isArray(value)) {\n            this._throwError(\"expected array value\", value);\n        }\n        let count = this.length;\n        if (count === -1) {\n            count = value.length;\n            writer.writeValue(value.length);\n        }\n        logger.checkArgumentCount(value.length, count, \"coder array\" + (this.localName ? (\" \" + this.localName) : \"\"));\n        let coders = [];\n        for (let i = 0; i < value.length; i++) {\n            coders.push(this.coder);\n        }\n        return pack(writer, coders, value);\n    }\n    decode(reader) {\n        let count = this.length;\n        if (count === -1) {\n            count = reader.readValue().toNumber();\n            // Check that there is *roughly* enough data to ensure\n            // stray random data is not being read as a length. Each\n            // slot requires at least 32 bytes for their value (or 32\n            // bytes as a link to the data). This could use a much\n            // tighter bound, but we are erroring on the side of safety.\n            if (count * 32 > reader._data.length) {\n                logger.throwError(\"insufficient data length\", Logger.errors.BUFFER_OVERRUN, {\n                    length: reader._data.length,\n                    count: count\n                });\n            }\n        }\n        let coders = [];\n        for (let i = 0; i < count; i++) {\n            coders.push(new AnonymousCoder(this.coder));\n        }\n        return reader.coerce(this.name, unpack(reader, coders));\n    }\n}\n//# sourceMappingURL=array.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\nexport class BooleanCoder extends Coder {\n    constructor(localName) {\n        super(\"bool\", \"bool\", localName, false);\n    }\n    defaultValue() {\n        return false;\n    }\n    encode(writer, value) {\n        return writer.writeValue(value ? 1 : 0);\n    }\n    decode(reader) {\n        return reader.coerce(this.type, !reader.readValue().isZero());\n    }\n}\n//# sourceMappingURL=boolean.js.map","\"use strict\";\nimport { arrayify, hexlify } from \"@ethersproject/bytes\";\nimport { Coder } from \"./abstract-coder\";\nexport class DynamicBytesCoder extends Coder {\n    constructor(type, localName) {\n        super(type, type, localName, true);\n    }\n    defaultValue() {\n        return \"0x\";\n    }\n    encode(writer, value) {\n        value = arrayify(value);\n        let length = writer.writeValue(value.length);\n        length += writer.writeBytes(value);\n        return length;\n    }\n    decode(reader) {\n        return reader.readBytes(reader.readValue().toNumber(), true);\n    }\n}\nexport class BytesCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"bytes\", localName);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, hexlify(super.decode(reader)));\n    }\n}\n//# sourceMappingURL=bytes.js.map","\"use strict\";\nimport { arrayify, hexlify } from \"@ethersproject/bytes\";\nimport { Coder } from \"./abstract-coder\";\n// @TODO: Merge this with bytes\nexport class FixedBytesCoder extends Coder {\n    constructor(size, localName) {\n        let name = \"bytes\" + String(size);\n        super(name, name, localName, false);\n        this.size = size;\n    }\n    defaultValue() {\n        return (\"0x0000000000000000000000000000000000000000000000000000000000000000\").substring(0, 2 + this.size * 2);\n    }\n    encode(writer, value) {\n        let data = arrayify(value);\n        if (data.length !== this.size) {\n            this._throwError(\"incorrect data length\", value);\n        }\n        return writer.writeBytes(data);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, hexlify(reader.readBytes(this.size)));\n    }\n}\n//# sourceMappingURL=fixed-bytes.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\nexport class NullCoder extends Coder {\n    constructor(localName) {\n        super(\"null\", \"\", localName, false);\n    }\n    defaultValue() {\n        return null;\n    }\n    encode(writer, value) {\n        if (value != null) {\n            this._throwError(\"not null\", value);\n        }\n        return writer.writeBytes([]);\n    }\n    decode(reader) {\n        reader.readBytes(0);\n        return reader.coerce(this.name, null);\n    }\n}\n//# sourceMappingURL=null.js.map","\"use strict\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { MaxUint256, NegativeOne, One, Zero } from \"@ethersproject/constants\";\nimport { Coder } from \"./abstract-coder\";\nexport class NumberCoder extends Coder {\n    constructor(size, signed, localName) {\n        const name = ((signed ? \"int\" : \"uint\") + (size * 8));\n        super(name, name, localName, false);\n        this.size = size;\n        this.signed = signed;\n    }\n    defaultValue() {\n        return 0;\n    }\n    encode(writer, value) {\n        let v = BigNumber.from(value);\n        // Check bounds are safe for encoding\n        let maxUintValue = MaxUint256.mask(writer.wordSize * 8);\n        if (this.signed) {\n            let bounds = maxUintValue.mask(this.size * 8 - 1);\n            if (v.gt(bounds) || v.lt(bounds.add(One).mul(NegativeOne))) {\n                this._throwError(\"value out-of-bounds\", value);\n            }\n        }\n        else if (v.lt(Zero) || v.gt(maxUintValue.mask(this.size * 8))) {\n            this._throwError(\"value out-of-bounds\", value);\n        }\n        v = v.toTwos(this.size * 8).mask(this.size * 8);\n        if (this.signed) {\n            v = v.fromTwos(this.size * 8).toTwos(8 * writer.wordSize);\n        }\n        return writer.writeValue(v);\n    }\n    decode(reader) {\n        let value = reader.readValue().mask(this.size * 8);\n        if (this.signed) {\n            value = value.fromTwos(this.size * 8);\n        }\n        return reader.coerce(this.name, value);\n    }\n}\n//# sourceMappingURL=number.js.map","\"use strict\";\nimport { toUtf8Bytes, toUtf8String } from \"@ethersproject/strings\";\nimport { DynamicBytesCoder } from \"./bytes\";\nexport class StringCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"string\", localName);\n    }\n    defaultValue() {\n        return \"\";\n    }\n    encode(writer, value) {\n        return super.encode(writer, toUtf8Bytes(value));\n    }\n    decode(reader) {\n        return toUtf8String(super.decode(reader));\n    }\n}\n//# sourceMappingURL=string.js.map","\"use strict\";\nimport { Coder } from \"./abstract-coder\";\nimport { pack, unpack } from \"./array\";\nexport class TupleCoder extends Coder {\n    constructor(coders, localName) {\n        let dynamic = false;\n        const types = [];\n        coders.forEach((coder) => {\n            if (coder.dynamic) {\n                dynamic = true;\n            }\n            types.push(coder.type);\n        });\n        const type = (\"tuple(\" + types.join(\",\") + \")\");\n        super(\"tuple\", type, localName, dynamic);\n        this.coders = coders;\n    }\n    defaultValue() {\n        const values = [];\n        this.coders.forEach((coder) => {\n            values.push(coder.defaultValue());\n        });\n        // We only output named properties for uniquely named coders\n        const uniqueNames = this.coders.reduce((accum, coder) => {\n            const name = coder.localName;\n            if (name) {\n                if (!accum[name]) {\n                    accum[name] = 0;\n                }\n                accum[name]++;\n            }\n            return accum;\n        }, {});\n        // Add named values\n        this.coders.forEach((coder, index) => {\n            let name = coder.localName;\n            if (!name || uniqueNames[name] !== 1) {\n                return;\n            }\n            if (name === \"length\") {\n                name = \"_length\";\n            }\n            if (values[name] != null) {\n                return;\n            }\n            values[name] = values[index];\n        });\n        return Object.freeze(values);\n    }\n    encode(writer, value) {\n        return pack(writer, this.coders, value);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, unpack(reader, this.coders));\n    }\n}\n//# sourceMappingURL=tuple.js.map","\"use strict\";\n// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { Reader, Writer } from \"./coders/abstract-coder\";\nimport { AddressCoder } from \"./coders/address\";\nimport { ArrayCoder } from \"./coders/array\";\nimport { BooleanCoder } from \"./coders/boolean\";\nimport { BytesCoder } from \"./coders/bytes\";\nimport { FixedBytesCoder } from \"./coders/fixed-bytes\";\nimport { NullCoder } from \"./coders/null\";\nimport { NumberCoder } from \"./coders/number\";\nimport { StringCoder } from \"./coders/string\";\nimport { TupleCoder } from \"./coders/tuple\";\nimport { ParamType } from \"./fragments\";\nconst paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\nconst paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\nexport class AbiCoder {\n    constructor(coerceFunc) {\n        defineReadOnly(this, \"coerceFunc\", coerceFunc || null);\n    }\n    _getCoder(param) {\n        switch (param.baseType) {\n            case \"address\":\n                return new AddressCoder(param.name);\n            case \"bool\":\n                return new BooleanCoder(param.name);\n            case \"string\":\n                return new StringCoder(param.name);\n            case \"bytes\":\n                return new BytesCoder(param.name);\n            case \"array\":\n                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);\n            case \"tuple\":\n                return new TupleCoder((param.components || []).map((component) => {\n                    return this._getCoder(component);\n                }), param.name);\n            case \"\":\n                return new NullCoder(param.name);\n        }\n        // u?int[0-9]*\n        let match = param.type.match(paramTypeNumber);\n        if (match) {\n            let size = parseInt(match[2] || \"256\");\n            if (size === 0 || size > 256 || (size % 8) !== 0) {\n                logger.throwArgumentError(\"invalid \" + match[1] + \" bit length\", \"param\", param);\n            }\n            return new NumberCoder(size / 8, (match[1] === \"int\"), param.name);\n        }\n        // bytes[0-9]+\n        match = param.type.match(paramTypeBytes);\n        if (match) {\n            let size = parseInt(match[1]);\n            if (size === 0 || size > 32) {\n                logger.throwArgumentError(\"invalid bytes length\", \"param\", param);\n            }\n            return new FixedBytesCoder(size, param.name);\n        }\n        return logger.throwArgumentError(\"invalid type\", \"type\", param.type);\n    }\n    _getWordSize() { return 32; }\n    _getReader(data, allowLoose) {\n        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);\n    }\n    _getWriter() {\n        return new Writer(this._getWordSize());\n    }\n    getDefaultValue(types) {\n        const coders = types.map((type) => this._getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.defaultValue();\n    }\n    encode(types, values) {\n        if (types.length !== values.length) {\n            logger.throwError(\"types/values length mismatch\", Logger.errors.INVALID_ARGUMENT, {\n                count: { types: types.length, values: values.length },\n                value: { types: types, values: values }\n            });\n        }\n        const coders = types.map((type) => this._getCoder(ParamType.from(type)));\n        const coder = (new TupleCoder(coders, \"_\"));\n        const writer = this._getWriter();\n        coder.encode(writer, values);\n        return writer.data;\n    }\n    decode(types, data, loose) {\n        const coders = types.map((type) => this._getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.decode(this._getReader(arrayify(data), loose));\n    }\n}\nexport const defaultAbiCoder = new AbiCoder();\n//# sourceMappingURL=abi-coder.js.map","\"use strict\";\nimport { getAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, concat, hexDataSlice, hexlify, hexZeroPad, isHexString } from \"@ethersproject/bytes\";\nimport { id } from \"@ethersproject/hash\";\nimport { keccak256 } from \"@ethersproject/keccak256\";\nimport { defineReadOnly, Description, getStatic } from \"@ethersproject/properties\";\nimport { defaultAbiCoder } from \"./abi-coder\";\nimport { checkResultErrors } from \"./coders/abstract-coder\";\nimport { ConstructorFragment, EventFragment, FormatTypes, Fragment, FunctionFragment, ParamType } from \"./fragments\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport { checkResultErrors };\nexport class LogDescription extends Description {\n}\nexport class TransactionDescription extends Description {\n}\nexport class ErrorDescription extends Description {\n}\nexport class Indexed extends Description {\n    static isIndexed(value) {\n        return !!(value && value._isIndexed);\n    }\n}\nconst BuiltinErrors = {\n    \"0x08c379a0\": { signature: \"Error(string)\", name: \"Error\", inputs: [\"string\"], reason: true },\n    \"0x4e487b71\": { signature: \"Panic(uint256)\", name: \"Panic\", inputs: [\"uint256\"] }\n};\nfunction wrapAccessError(property, error) {\n    const wrap = new Error(`deferred error during ABI decoding triggered accessing ${property}`);\n    wrap.error = error;\n    return wrap;\n}\n/*\nfunction checkNames(fragment: Fragment, type: \"input\" | \"output\", params: Array<ParamType>): void {\n    params.reduce((accum, param) => {\n        if (param.name) {\n            if (accum[param.name]) {\n                logger.throwArgumentError(`duplicate ${ type } parameter ${ JSON.stringify(param.name) } in ${ fragment.format(\"full\") }`, \"fragment\", fragment);\n            }\n            accum[param.name] = true;\n        }\n        return accum;\n    }, <{ [ name: string ]: boolean }>{ });\n}\n*/\nexport class Interface {\n    constructor(fragments) {\n        let abi = [];\n        if (typeof (fragments) === \"string\") {\n            abi = JSON.parse(fragments);\n        }\n        else {\n            abi = fragments;\n        }\n        defineReadOnly(this, \"fragments\", abi.map((fragment) => {\n            return Fragment.from(fragment);\n        }).filter((fragment) => (fragment != null)));\n        defineReadOnly(this, \"_abiCoder\", getStatic(new.target, \"getAbiCoder\")());\n        defineReadOnly(this, \"functions\", {});\n        defineReadOnly(this, \"errors\", {});\n        defineReadOnly(this, \"events\", {});\n        defineReadOnly(this, \"structs\", {});\n        // Add all fragments by their signature\n        this.fragments.forEach((fragment) => {\n            let bucket = null;\n            switch (fragment.type) {\n                case \"constructor\":\n                    if (this.deploy) {\n                        logger.warn(\"duplicate definition - constructor\");\n                        return;\n                    }\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    defineReadOnly(this, \"deploy\", fragment);\n                    return;\n                case \"function\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    //checkNames(fragment, \"output\", (<FunctionFragment>fragment).outputs);\n                    bucket = this.functions;\n                    break;\n                case \"event\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    bucket = this.events;\n                    break;\n                case \"error\":\n                    bucket = this.errors;\n                    break;\n                default:\n                    return;\n            }\n            let signature = fragment.format();\n            if (bucket[signature]) {\n                logger.warn(\"duplicate definition - \" + signature);\n                return;\n            }\n            bucket[signature] = fragment;\n        });\n        // If we do not have a constructor add a default\n        if (!this.deploy) {\n            defineReadOnly(this, \"deploy\", ConstructorFragment.from({\n                payable: false,\n                type: \"constructor\"\n            }));\n        }\n        defineReadOnly(this, \"_isInterface\", true);\n    }\n    format(format) {\n        if (!format) {\n            format = FormatTypes.full;\n        }\n        if (format === FormatTypes.sighash) {\n            logger.throwArgumentError(\"interface does not support formatting sighash\", \"format\", format);\n        }\n        const abi = this.fragments.map((fragment) => fragment.format(format));\n        // We need to re-bundle the JSON fragments a bit\n        if (format === FormatTypes.json) {\n            return JSON.stringify(abi.map((j) => JSON.parse(j)));\n        }\n        return abi;\n    }\n    // Sub-classes can override these to handle other blockchains\n    static getAbiCoder() {\n        return defaultAbiCoder;\n    }\n    static getAddress(address) {\n        return getAddress(address);\n    }\n    static getSighash(fragment) {\n        return hexDataSlice(id(fragment.format()), 0, 4);\n    }\n    static getEventTopic(eventFragment) {\n        return id(eventFragment.format());\n    }\n    // Find a function definition by any means necessary (unless it is ambiguous)\n    getFunction(nameOrSignatureOrSighash) {\n        if (isHexString(nameOrSignatureOrSighash)) {\n            for (const name in this.functions) {\n                if (nameOrSignatureOrSighash === this.getSighash(name)) {\n                    return this.functions[name];\n                }\n            }\n            logger.throwArgumentError(\"no matching function\", \"sighash\", nameOrSignatureOrSighash);\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (nameOrSignatureOrSighash.indexOf(\"(\") === -1) {\n            const name = nameOrSignatureOrSighash.trim();\n            const matching = Object.keys(this.functions).filter((f) => (f.split(\"(\" /* fix:) */)[0] === name));\n            if (matching.length === 0) {\n                logger.throwArgumentError(\"no matching function\", \"name\", name);\n            }\n            else if (matching.length > 1) {\n                logger.throwArgumentError(\"multiple matching functions\", \"name\", name);\n            }\n            return this.functions[matching[0]];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.functions[FunctionFragment.fromString(nameOrSignatureOrSighash).format()];\n        if (!result) {\n            logger.throwArgumentError(\"no matching function\", \"signature\", nameOrSignatureOrSighash);\n        }\n        return result;\n    }\n    // Find an event definition by any means necessary (unless it is ambiguous)\n    getEvent(nameOrSignatureOrTopic) {\n        if (isHexString(nameOrSignatureOrTopic)) {\n            const topichash = nameOrSignatureOrTopic.toLowerCase();\n            for (const name in this.events) {\n                if (topichash === this.getEventTopic(name)) {\n                    return this.events[name];\n                }\n            }\n            logger.throwArgumentError(\"no matching event\", \"topichash\", topichash);\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (nameOrSignatureOrTopic.indexOf(\"(\") === -1) {\n            const name = nameOrSignatureOrTopic.trim();\n            const matching = Object.keys(this.events).filter((f) => (f.split(\"(\" /* fix:) */)[0] === name));\n            if (matching.length === 0) {\n                logger.throwArgumentError(\"no matching event\", \"name\", name);\n            }\n            else if (matching.length > 1) {\n                logger.throwArgumentError(\"multiple matching events\", \"name\", name);\n            }\n            return this.events[matching[0]];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.events[EventFragment.fromString(nameOrSignatureOrTopic).format()];\n        if (!result) {\n            logger.throwArgumentError(\"no matching event\", \"signature\", nameOrSignatureOrTopic);\n        }\n        return result;\n    }\n    // Find a function definition by any means necessary (unless it is ambiguous)\n    getError(nameOrSignatureOrSighash) {\n        if (isHexString(nameOrSignatureOrSighash)) {\n            const getSighash = getStatic(this.constructor, \"getSighash\");\n            for (const name in this.errors) {\n                const error = this.errors[name];\n                if (nameOrSignatureOrSighash === getSighash(error)) {\n                    return this.errors[name];\n                }\n            }\n            logger.throwArgumentError(\"no matching error\", \"sighash\", nameOrSignatureOrSighash);\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (nameOrSignatureOrSighash.indexOf(\"(\") === -1) {\n            const name = nameOrSignatureOrSighash.trim();\n            const matching = Object.keys(this.errors).filter((f) => (f.split(\"(\" /* fix:) */)[0] === name));\n            if (matching.length === 0) {\n                logger.throwArgumentError(\"no matching error\", \"name\", name);\n            }\n            else if (matching.length > 1) {\n                logger.throwArgumentError(\"multiple matching errors\", \"name\", name);\n            }\n            return this.errors[matching[0]];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.errors[FunctionFragment.fromString(nameOrSignatureOrSighash).format()];\n        if (!result) {\n            logger.throwArgumentError(\"no matching error\", \"signature\", nameOrSignatureOrSighash);\n        }\n        return result;\n    }\n    // Get the sighash (the bytes4 selector) used by Solidity to identify a function\n    getSighash(fragment) {\n        if (typeof (fragment) === \"string\") {\n            try {\n                fragment = this.getFunction(fragment);\n            }\n            catch (error) {\n                try {\n                    fragment = this.getError(fragment);\n                }\n                catch (_) {\n                    throw error;\n                }\n            }\n        }\n        return getStatic(this.constructor, \"getSighash\")(fragment);\n    }\n    // Get the topic (the bytes32 hash) used by Solidity to identify an event\n    getEventTopic(eventFragment) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        return getStatic(this.constructor, \"getEventTopic\")(eventFragment);\n    }\n    _decodeParams(params, data) {\n        return this._abiCoder.decode(params, data);\n    }\n    _encodeParams(params, values) {\n        return this._abiCoder.encode(params, values);\n    }\n    encodeDeploy(values) {\n        return this._encodeParams(this.deploy.inputs, values || []);\n    }\n    decodeErrorResult(fragment, data) {\n        if (typeof (fragment) === \"string\") {\n            fragment = this.getError(fragment);\n        }\n        const bytes = arrayify(data);\n        if (hexlify(bytes.slice(0, 4)) !== this.getSighash(fragment)) {\n            logger.throwArgumentError(`data signature does not match error ${fragment.name}.`, \"data\", hexlify(bytes));\n        }\n        return this._decodeParams(fragment.inputs, bytes.slice(4));\n    }\n    encodeErrorResult(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            fragment = this.getError(fragment);\n        }\n        return hexlify(concat([\n            this.getSighash(fragment),\n            this._encodeParams(fragment.inputs, values || [])\n        ]));\n    }\n    // Decode the data for a function call (e.g. tx.data)\n    decodeFunctionData(functionFragment, data) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        const bytes = arrayify(data);\n        if (hexlify(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) {\n            logger.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, \"data\", hexlify(bytes));\n        }\n        return this._decodeParams(functionFragment.inputs, bytes.slice(4));\n    }\n    // Encode the data for a function call (e.g. tx.data)\n    encodeFunctionData(functionFragment, values) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        return hexlify(concat([\n            this.getSighash(functionFragment),\n            this._encodeParams(functionFragment.inputs, values || [])\n        ]));\n    }\n    // Decode the result from a function call (e.g. from eth_call)\n    decodeFunctionResult(functionFragment, data) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        let bytes = arrayify(data);\n        let reason = null;\n        let message = \"\";\n        let errorArgs = null;\n        let errorName = null;\n        let errorSignature = null;\n        switch (bytes.length % this._abiCoder._getWordSize()) {\n            case 0:\n                try {\n                    return this._abiCoder.decode(functionFragment.outputs, bytes);\n                }\n                catch (error) { }\n                break;\n            case 4: {\n                const selector = hexlify(bytes.slice(0, 4));\n                const builtin = BuiltinErrors[selector];\n                if (builtin) {\n                    errorArgs = this._abiCoder.decode(builtin.inputs, bytes.slice(4));\n                    errorName = builtin.name;\n                    errorSignature = builtin.signature;\n                    if (builtin.reason) {\n                        reason = errorArgs[0];\n                    }\n                    if (errorName === \"Error\") {\n                        message = `; VM Exception while processing transaction: reverted with reason string ${JSON.stringify(errorArgs[0])}`;\n                    }\n                    else if (errorName === \"Panic\") {\n                        message = `; VM Exception while processing transaction: reverted with panic code ${errorArgs[0]}`;\n                    }\n                }\n                else {\n                    try {\n                        const error = this.getError(selector);\n                        errorArgs = this._abiCoder.decode(error.inputs, bytes.slice(4));\n                        errorName = error.name;\n                        errorSignature = error.format();\n                    }\n                    catch (error) { }\n                }\n                break;\n            }\n        }\n        return logger.throwError(\"call revert exception\" + message, Logger.errors.CALL_EXCEPTION, {\n            method: functionFragment.format(),\n            data: hexlify(data), errorArgs, errorName, errorSignature, reason\n        });\n    }\n    // Encode the result for a function call (e.g. for eth_call)\n    encodeFunctionResult(functionFragment, values) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        return hexlify(this._abiCoder.encode(functionFragment.outputs, values || []));\n    }\n    // Create the filter for the event with search criteria (e.g. for eth_filterLog)\n    encodeFilterTopics(eventFragment, values) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        if (values.length > eventFragment.inputs.length) {\n            logger.throwError(\"too many arguments for \" + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, {\n                argument: \"values\",\n                value: values\n            });\n        }\n        let topics = [];\n        if (!eventFragment.anonymous) {\n            topics.push(this.getEventTopic(eventFragment));\n        }\n        const encodeTopic = (param, value) => {\n            if (param.type === \"string\") {\n                return id(value);\n            }\n            else if (param.type === \"bytes\") {\n                return keccak256(hexlify(value));\n            }\n            if (param.type === \"bool\" && typeof (value) === \"boolean\") {\n                value = (value ? \"0x01\" : \"0x00\");\n            }\n            if (param.type.match(/^u?int/)) {\n                value = BigNumber.from(value).toHexString();\n            }\n            // Check addresses are valid\n            if (param.type === \"address\") {\n                this._abiCoder.encode([\"address\"], [value]);\n            }\n            return hexZeroPad(hexlify(value), 32);\n        };\n        values.forEach((value, index) => {\n            let param = eventFragment.inputs[index];\n            if (!param.indexed) {\n                if (value != null) {\n                    logger.throwArgumentError(\"cannot filter non-indexed parameters; must be null\", (\"contract.\" + param.name), value);\n                }\n                return;\n            }\n            if (value == null) {\n                topics.push(null);\n            }\n            else if (param.baseType === \"array\" || param.baseType === \"tuple\") {\n                logger.throwArgumentError(\"filtering with tuples or arrays not supported\", (\"contract.\" + param.name), value);\n            }\n            else if (Array.isArray(value)) {\n                topics.push(value.map((value) => encodeTopic(param, value)));\n            }\n            else {\n                topics.push(encodeTopic(param, value));\n            }\n        });\n        // Trim off trailing nulls\n        while (topics.length && topics[topics.length - 1] === null) {\n            topics.pop();\n        }\n        return topics;\n    }\n    encodeEventLog(eventFragment, values) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        const topics = [];\n        const dataTypes = [];\n        const dataValues = [];\n        if (!eventFragment.anonymous) {\n            topics.push(this.getEventTopic(eventFragment));\n        }\n        if (values.length !== eventFragment.inputs.length) {\n            logger.throwArgumentError(\"event arguments/values mismatch\", \"values\", values);\n        }\n        eventFragment.inputs.forEach((param, index) => {\n            const value = values[index];\n            if (param.indexed) {\n                if (param.type === \"string\") {\n                    topics.push(id(value));\n                }\n                else if (param.type === \"bytes\") {\n                    topics.push(keccak256(value));\n                }\n                else if (param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    // @TODO\n                    throw new Error(\"not implemented\");\n                }\n                else {\n                    topics.push(this._abiCoder.encode([param.type], [value]));\n                }\n            }\n            else {\n                dataTypes.push(param);\n                dataValues.push(value);\n            }\n        });\n        return {\n            data: this._abiCoder.encode(dataTypes, dataValues),\n            topics: topics\n        };\n    }\n    // Decode a filter for the event and the search criteria\n    decodeEventLog(eventFragment, data, topics) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        if (topics != null && !eventFragment.anonymous) {\n            let topicHash = this.getEventTopic(eventFragment);\n            if (!isHexString(topics[0], 32) || topics[0].toLowerCase() !== topicHash) {\n                logger.throwError(\"fragment/topic mismatch\", Logger.errors.INVALID_ARGUMENT, { argument: \"topics[0]\", expected: topicHash, value: topics[0] });\n            }\n            topics = topics.slice(1);\n        }\n        let indexed = [];\n        let nonIndexed = [];\n        let dynamic = [];\n        eventFragment.inputs.forEach((param, index) => {\n            if (param.indexed) {\n                if (param.type === \"string\" || param.type === \"bytes\" || param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    indexed.push(ParamType.fromObject({ type: \"bytes32\", name: param.name }));\n                    dynamic.push(true);\n                }\n                else {\n                    indexed.push(param);\n                    dynamic.push(false);\n                }\n            }\n            else {\n                nonIndexed.push(param);\n                dynamic.push(false);\n            }\n        });\n        let resultIndexed = (topics != null) ? this._abiCoder.decode(indexed, concat(topics)) : null;\n        let resultNonIndexed = this._abiCoder.decode(nonIndexed, data, true);\n        let result = [];\n        let nonIndexedIndex = 0, indexedIndex = 0;\n        eventFragment.inputs.forEach((param, index) => {\n            if (param.indexed) {\n                if (resultIndexed == null) {\n                    result[index] = new Indexed({ _isIndexed: true, hash: null });\n                }\n                else if (dynamic[index]) {\n                    result[index] = new Indexed({ _isIndexed: true, hash: resultIndexed[indexedIndex++] });\n                }\n                else {\n                    try {\n                        result[index] = resultIndexed[indexedIndex++];\n                    }\n                    catch (error) {\n                        result[index] = error;\n                    }\n                }\n            }\n            else {\n                try {\n                    result[index] = resultNonIndexed[nonIndexedIndex++];\n                }\n                catch (error) {\n                    result[index] = error;\n                }\n            }\n            // Add the keyword argument if named and safe\n            if (param.name && result[param.name] == null) {\n                const value = result[index];\n                // Make error named values throw on access\n                if (value instanceof Error) {\n                    Object.defineProperty(result, param.name, {\n                        enumerable: true,\n                        get: () => { throw wrapAccessError(`property ${JSON.stringify(param.name)}`, value); }\n                    });\n                }\n                else {\n                    result[param.name] = value;\n                }\n            }\n        });\n        // Make all error indexed values throw on access\n        for (let i = 0; i < result.length; i++) {\n            const value = result[i];\n            if (value instanceof Error) {\n                Object.defineProperty(result, i, {\n                    enumerable: true,\n                    get: () => { throw wrapAccessError(`index ${i}`, value); }\n                });\n            }\n        }\n        return Object.freeze(result);\n    }\n    // Given a transaction, find the matching function fragment (if any) and\n    // determine all its properties and call parameters\n    parseTransaction(tx) {\n        let fragment = this.getFunction(tx.data.substring(0, 10).toLowerCase());\n        if (!fragment) {\n            return null;\n        }\n        return new TransactionDescription({\n            args: this._abiCoder.decode(fragment.inputs, \"0x\" + tx.data.substring(10)),\n            functionFragment: fragment,\n            name: fragment.name,\n            signature: fragment.format(),\n            sighash: this.getSighash(fragment),\n            value: BigNumber.from(tx.value || \"0\"),\n        });\n    }\n    // @TODO\n    //parseCallResult(data: BytesLike): ??\n    // Given an event log, find the matching event fragment (if any) and\n    // determine all its properties and values\n    parseLog(log) {\n        let fragment = this.getEvent(log.topics[0]);\n        if (!fragment || fragment.anonymous) {\n            return null;\n        }\n        // @TODO: If anonymous, and the only method, and the input count matches, should we parse?\n        //        Probably not, because just because it is the only event in the ABI does\n        //        not mean we have the full ABI; maybe just a fragment?\n        return new LogDescription({\n            eventFragment: fragment,\n            name: fragment.name,\n            signature: fragment.format(),\n            topic: this.getEventTopic(fragment),\n            args: this.decodeEventLog(fragment, log.data, log.topics)\n        });\n    }\n    parseError(data) {\n        const hexData = hexlify(data);\n        let fragment = this.getError(hexData.substring(0, 10).toLowerCase());\n        if (!fragment) {\n            return null;\n        }\n        return new ErrorDescription({\n            args: this._abiCoder.decode(fragment.inputs, \"0x\" + hexData.substring(10)),\n            errorFragment: fragment,\n            name: fragment.name,\n            signature: fragment.format(),\n            sighash: this.getSighash(fragment),\n        });\n    }\n    /*\n    static from(value: Array<Fragment | string | JsonAbi> | string | Interface) {\n        if (Interface.isInterface(value)) {\n            return value;\n        }\n        if (typeof(value) === \"string\") {\n            return new Interface(JSON.parse(value));\n        }\n        return new Interface(value);\n    }\n    */\n    static isInterface(value) {\n        return !!(value && value._isInterface);\n    }\n}\n//# sourceMappingURL=interface.js.map","export const version = \"contracts/5.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { checkResultErrors, Indexed, Interface } from \"@ethersproject/abi\";\nimport { Provider } from \"@ethersproject/abstract-provider\";\nimport { Signer, VoidSigner } from \"@ethersproject/abstract-signer\";\nimport { getAddress, getContractAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, concat, hexlify, isBytes, isHexString } from \"@ethersproject/bytes\";\nimport { defineReadOnly, deepCopy, getStatic, resolveProperties, shallowCopy } from \"@ethersproject/properties\";\nimport { accessListify } from \"@ethersproject/transactions\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n;\n;\n///////////////////////////////\nconst allowedTransactionKeys = {\n    chainId: true, data: true, from: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true,\n    type: true, accessList: true,\n    maxFeePerGas: true, maxPriorityFeePerGas: true,\n    customData: true,\n    ccipReadEnabled: true\n};\nfunction resolveName(resolver, nameOrPromise) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const name = yield nameOrPromise;\n        if (typeof (name) !== \"string\") {\n            logger.throwArgumentError(\"invalid address or ENS name\", \"name\", name);\n        }\n        // If it is already an address, just use it (after adding checksum)\n        try {\n            return getAddress(name);\n        }\n        catch (error) { }\n        if (!resolver) {\n            logger.throwError(\"a provider or signer is needed to resolve ENS names\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"resolveName\"\n            });\n        }\n        const address = yield resolver.resolveName(name);\n        if (address == null) {\n            logger.throwArgumentError(\"resolver or addr is not configured for ENS name\", \"name\", name);\n        }\n        return address;\n    });\n}\n// Recursively replaces ENS names with promises to resolve the name and resolves all properties\nfunction resolveAddresses(resolver, value, paramType) {\n    return __awaiter(this, void 0, void 0, function* () {\n        if (Array.isArray(paramType)) {\n            return yield Promise.all(paramType.map((paramType, index) => {\n                return resolveAddresses(resolver, ((Array.isArray(value)) ? value[index] : value[paramType.name]), paramType);\n            }));\n        }\n        if (paramType.type === \"address\") {\n            return yield resolveName(resolver, value);\n        }\n        if (paramType.type === \"tuple\") {\n            return yield resolveAddresses(resolver, value, paramType.components);\n        }\n        if (paramType.baseType === \"array\") {\n            if (!Array.isArray(value)) {\n                return Promise.reject(logger.makeError(\"invalid value for array\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"value\",\n                    value\n                }));\n            }\n            return yield Promise.all(value.map((v) => resolveAddresses(resolver, v, paramType.arrayChildren)));\n        }\n        return value;\n    });\n}\nfunction populateTransaction(contract, fragment, args) {\n    return __awaiter(this, void 0, void 0, function* () {\n        // If an extra argument is given, it is overrides\n        let overrides = {};\n        if (args.length === fragment.inputs.length + 1 && typeof (args[args.length - 1]) === \"object\") {\n            overrides = shallowCopy(args.pop());\n        }\n        // Make sure the parameter count matches\n        logger.checkArgumentCount(args.length, fragment.inputs.length, \"passed to contract\");\n        // Populate \"from\" override (allow promises)\n        if (contract.signer) {\n            if (overrides.from) {\n                // Contracts with a Signer are from the Signer's frame-of-reference;\n                // but we allow overriding \"from\" if it matches the signer\n                overrides.from = resolveProperties({\n                    override: resolveName(contract.signer, overrides.from),\n                    signer: contract.signer.getAddress()\n                }).then((check) => __awaiter(this, void 0, void 0, function* () {\n                    if (getAddress(check.signer) !== check.override) {\n                        logger.throwError(\"Contract with a Signer cannot override from\", Logger.errors.UNSUPPORTED_OPERATION, {\n                            operation: \"overrides.from\"\n                        });\n                    }\n                    return check.override;\n                }));\n            }\n            else {\n                overrides.from = contract.signer.getAddress();\n            }\n        }\n        else if (overrides.from) {\n            overrides.from = resolveName(contract.provider, overrides.from);\n            //} else {\n            // Contracts without a signer can override \"from\", and if\n            // unspecified the zero address is used\n            //overrides.from = AddressZero;\n        }\n        // Wait for all dependencies to be resolved (prefer the signer over the provider)\n        const resolved = yield resolveProperties({\n            args: resolveAddresses(contract.signer || contract.provider, args, fragment.inputs),\n            address: contract.resolvedAddress,\n            overrides: (resolveProperties(overrides) || {})\n        });\n        // The ABI coded transaction\n        const data = contract.interface.encodeFunctionData(fragment, resolved.args);\n        const tx = {\n            data: data,\n            to: resolved.address\n        };\n        // Resolved Overrides\n        const ro = resolved.overrides;\n        // Populate simple overrides\n        if (ro.nonce != null) {\n            tx.nonce = BigNumber.from(ro.nonce).toNumber();\n        }\n        if (ro.gasLimit != null) {\n            tx.gasLimit = BigNumber.from(ro.gasLimit);\n        }\n        if (ro.gasPrice != null) {\n            tx.gasPrice = BigNumber.from(ro.gasPrice);\n        }\n        if (ro.maxFeePerGas != null) {\n            tx.maxFeePerGas = BigNumber.from(ro.maxFeePerGas);\n        }\n        if (ro.maxPriorityFeePerGas != null) {\n            tx.maxPriorityFeePerGas = BigNumber.from(ro.maxPriorityFeePerGas);\n        }\n        if (ro.from != null) {\n            tx.from = ro.from;\n        }\n        if (ro.type != null) {\n            tx.type = ro.type;\n        }\n        if (ro.accessList != null) {\n            tx.accessList = accessListify(ro.accessList);\n        }\n        // If there was no \"gasLimit\" override, but the ABI specifies a default, use it\n        if (tx.gasLimit == null && fragment.gas != null) {\n            // Compute the intrinsic gas cost for this transaction\n            // @TODO: This is based on the yellow paper as of Petersburg; this is something\n            // we may wish to parameterize in v6 as part of the Network object. Since this\n            // is always a non-nil to address, we can ignore G_create, but may wish to add\n            // similar logic to the ContractFactory.\n            let intrinsic = 21000;\n            const bytes = arrayify(data);\n            for (let i = 0; i < bytes.length; i++) {\n                intrinsic += 4;\n                if (bytes[i]) {\n                    intrinsic += 64;\n                }\n            }\n            tx.gasLimit = BigNumber.from(fragment.gas).add(intrinsic);\n        }\n        // Populate \"value\" override\n        if (ro.value) {\n            const roValue = BigNumber.from(ro.value);\n            if (!roValue.isZero() && !fragment.payable) {\n                logger.throwError(\"non-payable method cannot override value\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"overrides.value\",\n                    value: overrides.value\n                });\n            }\n            tx.value = roValue;\n        }\n        if (ro.customData) {\n            tx.customData = shallowCopy(ro.customData);\n        }\n        if (ro.ccipReadEnabled) {\n            tx.ccipReadEnabled = !!ro.ccipReadEnabled;\n        }\n        // Remove the overrides\n        delete overrides.nonce;\n        delete overrides.gasLimit;\n        delete overrides.gasPrice;\n        delete overrides.from;\n        delete overrides.value;\n        delete overrides.type;\n        delete overrides.accessList;\n        delete overrides.maxFeePerGas;\n        delete overrides.maxPriorityFeePerGas;\n        delete overrides.customData;\n        delete overrides.ccipReadEnabled;\n        // Make sure there are no stray overrides, which may indicate a\n        // typo or using an unsupported key.\n        const leftovers = Object.keys(overrides).filter((key) => (overrides[key] != null));\n        if (leftovers.length) {\n            logger.throwError(`cannot override ${leftovers.map((l) => JSON.stringify(l)).join(\",\")}`, Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"overrides\",\n                overrides: leftovers\n            });\n        }\n        return tx;\n    });\n}\nfunction buildPopulate(contract, fragment) {\n    return function (...args) {\n        return populateTransaction(contract, fragment, args);\n    };\n}\nfunction buildEstimate(contract, fragment) {\n    const signerOrProvider = (contract.signer || contract.provider);\n    return function (...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (!signerOrProvider) {\n                logger.throwError(\"estimate require a provider or signer\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"estimateGas\"\n                });\n            }\n            const tx = yield populateTransaction(contract, fragment, args);\n            return yield signerOrProvider.estimateGas(tx);\n        });\n    };\n}\nfunction addContractWait(contract, tx) {\n    const wait = tx.wait.bind(tx);\n    tx.wait = (confirmations) => {\n        return wait(confirmations).then((receipt) => {\n            receipt.events = receipt.logs.map((log) => {\n                let event = deepCopy(log);\n                let parsed = null;\n                try {\n                    parsed = contract.interface.parseLog(log);\n                }\n                catch (e) { }\n                // Successfully parsed the event log; include it\n                if (parsed) {\n                    event.args = parsed.args;\n                    event.decode = (data, topics) => {\n                        return contract.interface.decodeEventLog(parsed.eventFragment, data, topics);\n                    };\n                    event.event = parsed.name;\n                    event.eventSignature = parsed.signature;\n                }\n                // Useful operations\n                event.removeListener = () => { return contract.provider; };\n                event.getBlock = () => {\n                    return contract.provider.getBlock(receipt.blockHash);\n                };\n                event.getTransaction = () => {\n                    return contract.provider.getTransaction(receipt.transactionHash);\n                };\n                event.getTransactionReceipt = () => {\n                    return Promise.resolve(receipt);\n                };\n                return event;\n            });\n            return receipt;\n        });\n    };\n}\nfunction buildCall(contract, fragment, collapseSimple) {\n    const signerOrProvider = (contract.signer || contract.provider);\n    return function (...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Extract the \"blockTag\" override if present\n            let blockTag = undefined;\n            if (args.length === fragment.inputs.length + 1 && typeof (args[args.length - 1]) === \"object\") {\n                const overrides = shallowCopy(args.pop());\n                if (overrides.blockTag != null) {\n                    blockTag = yield overrides.blockTag;\n                }\n                delete overrides.blockTag;\n                args.push(overrides);\n            }\n            // If the contract was just deployed, wait until it is mined\n            if (contract.deployTransaction != null) {\n                yield contract._deployed(blockTag);\n            }\n            // Call a node and get the result\n            const tx = yield populateTransaction(contract, fragment, args);\n            const result = yield signerOrProvider.call(tx, blockTag);\n            try {\n                let value = contract.interface.decodeFunctionResult(fragment, result);\n                if (collapseSimple && fragment.outputs.length === 1) {\n                    value = value[0];\n                }\n                return value;\n            }\n            catch (error) {\n                if (error.code === Logger.errors.CALL_EXCEPTION) {\n                    error.address = contract.address;\n                    error.args = args;\n                    error.transaction = tx;\n                }\n                throw error;\n            }\n        });\n    };\n}\nfunction buildSend(contract, fragment) {\n    return function (...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (!contract.signer) {\n                logger.throwError(\"sending a transaction requires a signer\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"sendTransaction\"\n                });\n            }\n            // If the contract was just deployed, wait until it is mined\n            if (contract.deployTransaction != null) {\n                yield contract._deployed();\n            }\n            const txRequest = yield populateTransaction(contract, fragment, args);\n            const tx = yield contract.signer.sendTransaction(txRequest);\n            // Tweak the tx.wait so the receipt has extra properties\n            addContractWait(contract, tx);\n            return tx;\n        });\n    };\n}\nfunction buildDefault(contract, fragment, collapseSimple) {\n    if (fragment.constant) {\n        return buildCall(contract, fragment, collapseSimple);\n    }\n    return buildSend(contract, fragment);\n}\nfunction getEventTag(filter) {\n    if (filter.address && (filter.topics == null || filter.topics.length === 0)) {\n        return \"*\";\n    }\n    return (filter.address || \"*\") + \"@\" + (filter.topics ? filter.topics.map((topic) => {\n        if (Array.isArray(topic)) {\n            return topic.join(\"|\");\n        }\n        return topic;\n    }).join(\":\") : \"\");\n}\nclass RunningEvent {\n    constructor(tag, filter) {\n        defineReadOnly(this, \"tag\", tag);\n        defineReadOnly(this, \"filter\", filter);\n        this._listeners = [];\n    }\n    addListener(listener, once) {\n        this._listeners.push({ listener: listener, once: once });\n    }\n    removeListener(listener) {\n        let done = false;\n        this._listeners = this._listeners.filter((item) => {\n            if (done || item.listener !== listener) {\n                return true;\n            }\n            done = true;\n            return false;\n        });\n    }\n    removeAllListeners() {\n        this._listeners = [];\n    }\n    listeners() {\n        return this._listeners.map((i) => i.listener);\n    }\n    listenerCount() {\n        return this._listeners.length;\n    }\n    run(args) {\n        const listenerCount = this.listenerCount();\n        this._listeners = this._listeners.filter((item) => {\n            const argsCopy = args.slice();\n            // Call the callback in the next event loop\n            setTimeout(() => {\n                item.listener.apply(this, argsCopy);\n            }, 0);\n            // Reschedule it if it not \"once\"\n            return !(item.once);\n        });\n        return listenerCount;\n    }\n    prepareEvent(event) {\n    }\n    // Returns the array that will be applied to an emit\n    getEmit(event) {\n        return [event];\n    }\n}\nclass ErrorRunningEvent extends RunningEvent {\n    constructor() {\n        super(\"error\", null);\n    }\n}\n// @TODO Fragment should inherit Wildcard? and just override getEmit?\n//       or have a common abstract super class, with enough constructor\n//       options to configure both.\n// A Fragment Event will populate all the properties that Wildcard\n// will, and additionally dereference the arguments when emitting\nclass FragmentRunningEvent extends RunningEvent {\n    constructor(address, contractInterface, fragment, topics) {\n        const filter = {\n            address: address\n        };\n        let topic = contractInterface.getEventTopic(fragment);\n        if (topics) {\n            if (topic !== topics[0]) {\n                logger.throwArgumentError(\"topic mismatch\", \"topics\", topics);\n            }\n            filter.topics = topics.slice();\n        }\n        else {\n            filter.topics = [topic];\n        }\n        super(getEventTag(filter), filter);\n        defineReadOnly(this, \"address\", address);\n        defineReadOnly(this, \"interface\", contractInterface);\n        defineReadOnly(this, \"fragment\", fragment);\n    }\n    prepareEvent(event) {\n        super.prepareEvent(event);\n        event.event = this.fragment.name;\n        event.eventSignature = this.fragment.format();\n        event.decode = (data, topics) => {\n            return this.interface.decodeEventLog(this.fragment, data, topics);\n        };\n        try {\n            event.args = this.interface.decodeEventLog(this.fragment, event.data, event.topics);\n        }\n        catch (error) {\n            event.args = null;\n            event.decodeError = error;\n        }\n    }\n    getEmit(event) {\n        const errors = checkResultErrors(event.args);\n        if (errors.length) {\n            throw errors[0].error;\n        }\n        const args = (event.args || []).slice();\n        args.push(event);\n        return args;\n    }\n}\n// A Wildcard Event will attempt to populate:\n//  - event            The name of the event name\n//  - eventSignature   The full signature of the event\n//  - decode           A function to decode data and topics\n//  - args             The decoded data and topics\nclass WildcardRunningEvent extends RunningEvent {\n    constructor(address, contractInterface) {\n        super(\"*\", { address: address });\n        defineReadOnly(this, \"address\", address);\n        defineReadOnly(this, \"interface\", contractInterface);\n    }\n    prepareEvent(event) {\n        super.prepareEvent(event);\n        try {\n            const parsed = this.interface.parseLog(event);\n            event.event = parsed.name;\n            event.eventSignature = parsed.signature;\n            event.decode = (data, topics) => {\n                return this.interface.decodeEventLog(parsed.eventFragment, data, topics);\n            };\n            event.args = parsed.args;\n        }\n        catch (error) {\n            // No matching event\n        }\n    }\n}\nexport class BaseContract {\n    constructor(addressOrName, contractInterface, signerOrProvider) {\n        // @TODO: Maybe still check the addressOrName looks like a valid address or name?\n        //address = getAddress(address);\n        defineReadOnly(this, \"interface\", getStatic(new.target, \"getInterface\")(contractInterface));\n        if (signerOrProvider == null) {\n            defineReadOnly(this, \"provider\", null);\n            defineReadOnly(this, \"signer\", null);\n        }\n        else if (Signer.isSigner(signerOrProvider)) {\n            defineReadOnly(this, \"provider\", signerOrProvider.provider || null);\n            defineReadOnly(this, \"signer\", signerOrProvider);\n        }\n        else if (Provider.isProvider(signerOrProvider)) {\n            defineReadOnly(this, \"provider\", signerOrProvider);\n            defineReadOnly(this, \"signer\", null);\n        }\n        else {\n            logger.throwArgumentError(\"invalid signer or provider\", \"signerOrProvider\", signerOrProvider);\n        }\n        defineReadOnly(this, \"callStatic\", {});\n        defineReadOnly(this, \"estimateGas\", {});\n        defineReadOnly(this, \"functions\", {});\n        defineReadOnly(this, \"populateTransaction\", {});\n        defineReadOnly(this, \"filters\", {});\n        {\n            const uniqueFilters = {};\n            Object.keys(this.interface.events).forEach((eventSignature) => {\n                const event = this.interface.events[eventSignature];\n                defineReadOnly(this.filters, eventSignature, (...args) => {\n                    return {\n                        address: this.address,\n                        topics: this.interface.encodeFilterTopics(event, args)\n                    };\n                });\n                if (!uniqueFilters[event.name]) {\n                    uniqueFilters[event.name] = [];\n                }\n                uniqueFilters[event.name].push(eventSignature);\n            });\n            Object.keys(uniqueFilters).forEach((name) => {\n                const filters = uniqueFilters[name];\n                if (filters.length === 1) {\n                    defineReadOnly(this.filters, name, this.filters[filters[0]]);\n                }\n                else {\n                    logger.warn(`Duplicate definition of ${name} (${filters.join(\", \")})`);\n                }\n            });\n        }\n        defineReadOnly(this, \"_runningEvents\", {});\n        defineReadOnly(this, \"_wrappedEmits\", {});\n        if (addressOrName == null) {\n            logger.throwArgumentError(\"invalid contract address or ENS name\", \"addressOrName\", addressOrName);\n        }\n        defineReadOnly(this, \"address\", addressOrName);\n        if (this.provider) {\n            defineReadOnly(this, \"resolvedAddress\", resolveName(this.provider, addressOrName));\n        }\n        else {\n            try {\n                defineReadOnly(this, \"resolvedAddress\", Promise.resolve(getAddress(addressOrName)));\n            }\n            catch (error) {\n                // Without a provider, we cannot use ENS names\n                logger.throwError(\"provider is required to use ENS name as contract address\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"new Contract\"\n                });\n            }\n        }\n        // Swallow bad ENS names to prevent Unhandled Exceptions\n        this.resolvedAddress.catch((e) => { });\n        const uniqueNames = {};\n        const uniqueSignatures = {};\n        Object.keys(this.interface.functions).forEach((signature) => {\n            const fragment = this.interface.functions[signature];\n            // Check that the signature is unique; if not the ABI generation has\n            // not been cleaned or may be incorrectly generated\n            if (uniqueSignatures[signature]) {\n                logger.warn(`Duplicate ABI entry for ${JSON.stringify(signature)}`);\n                return;\n            }\n            uniqueSignatures[signature] = true;\n            // Track unique names; we only expose bare named functions if they\n            // are ambiguous\n            {\n                const name = fragment.name;\n                if (!uniqueNames[`%${name}`]) {\n                    uniqueNames[`%${name}`] = [];\n                }\n                uniqueNames[`%${name}`].push(signature);\n            }\n            if (this[signature] == null) {\n                defineReadOnly(this, signature, buildDefault(this, fragment, true));\n            }\n            // We do not collapse simple calls on this bucket, which allows\n            // frameworks to safely use this without introspection as well as\n            // allows decoding error recovery.\n            if (this.functions[signature] == null) {\n                defineReadOnly(this.functions, signature, buildDefault(this, fragment, false));\n            }\n            if (this.callStatic[signature] == null) {\n                defineReadOnly(this.callStatic, signature, buildCall(this, fragment, true));\n            }\n            if (this.populateTransaction[signature] == null) {\n                defineReadOnly(this.populateTransaction, signature, buildPopulate(this, fragment));\n            }\n            if (this.estimateGas[signature] == null) {\n                defineReadOnly(this.estimateGas, signature, buildEstimate(this, fragment));\n            }\n        });\n        Object.keys(uniqueNames).forEach((name) => {\n            // Ambiguous names to not get attached as bare names\n            const signatures = uniqueNames[name];\n            if (signatures.length > 1) {\n                return;\n            }\n            // Strip off the leading \"%\" used for prototype protection\n            name = name.substring(1);\n            const signature = signatures[0];\n            // If overwriting a member property that is null, swallow the error\n            try {\n                if (this[name] == null) {\n                    defineReadOnly(this, name, this[signature]);\n                }\n            }\n            catch (e) { }\n            if (this.functions[name] == null) {\n                defineReadOnly(this.functions, name, this.functions[signature]);\n            }\n            if (this.callStatic[name] == null) {\n                defineReadOnly(this.callStatic, name, this.callStatic[signature]);\n            }\n            if (this.populateTransaction[name] == null) {\n                defineReadOnly(this.populateTransaction, name, this.populateTransaction[signature]);\n            }\n            if (this.estimateGas[name] == null) {\n                defineReadOnly(this.estimateGas, name, this.estimateGas[signature]);\n            }\n        });\n    }\n    static getContractAddress(transaction) {\n        return getContractAddress(transaction);\n    }\n    static getInterface(contractInterface) {\n        if (Interface.isInterface(contractInterface)) {\n            return contractInterface;\n        }\n        return new Interface(contractInterface);\n    }\n    // @TODO: Allow timeout?\n    deployed() {\n        return this._deployed();\n    }\n    _deployed(blockTag) {\n        if (!this._deployedPromise) {\n            // If we were just deployed, we know the transaction we should occur in\n            if (this.deployTransaction) {\n                this._deployedPromise = this.deployTransaction.wait().then(() => {\n                    return this;\n                });\n            }\n            else {\n                // @TODO: Once we allow a timeout to be passed in, we will wait\n                // up to that many blocks for getCode\n                // Otherwise, poll for our code to be deployed\n                this._deployedPromise = this.provider.getCode(this.address, blockTag).then((code) => {\n                    if (code === \"0x\") {\n                        logger.throwError(\"contract not deployed\", Logger.errors.UNSUPPORTED_OPERATION, {\n                            contractAddress: this.address,\n                            operation: \"getDeployed\"\n                        });\n                    }\n                    return this;\n                });\n            }\n        }\n        return this._deployedPromise;\n    }\n    // @TODO:\n    // estimateFallback(overrides?: TransactionRequest): Promise<BigNumber>\n    // @TODO:\n    // estimateDeploy(bytecode: string, ...args): Promise<BigNumber>\n    fallback(overrides) {\n        if (!this.signer) {\n            logger.throwError(\"sending a transactions require a signer\", Logger.errors.UNSUPPORTED_OPERATION, { operation: \"sendTransaction(fallback)\" });\n        }\n        const tx = shallowCopy(overrides || {});\n        [\"from\", \"to\"].forEach(function (key) {\n            if (tx[key] == null) {\n                return;\n            }\n            logger.throwError(\"cannot override \" + key, Logger.errors.UNSUPPORTED_OPERATION, { operation: key });\n        });\n        tx.to = this.resolvedAddress;\n        return this.deployed().then(() => {\n            return this.signer.sendTransaction(tx);\n        });\n    }\n    // Reconnect to a different signer or provider\n    connect(signerOrProvider) {\n        if (typeof (signerOrProvider) === \"string\") {\n            signerOrProvider = new VoidSigner(signerOrProvider, this.provider);\n        }\n        const contract = new (this.constructor)(this.address, this.interface, signerOrProvider);\n        if (this.deployTransaction) {\n            defineReadOnly(contract, \"deployTransaction\", this.deployTransaction);\n        }\n        return contract;\n    }\n    // Re-attach to a different on-chain instance of this contract\n    attach(addressOrName) {\n        return new (this.constructor)(addressOrName, this.interface, this.signer || this.provider);\n    }\n    static isIndexed(value) {\n        return Indexed.isIndexed(value);\n    }\n    _normalizeRunningEvent(runningEvent) {\n        // Already have an instance of this event running; we can re-use it\n        if (this._runningEvents[runningEvent.tag]) {\n            return this._runningEvents[runningEvent.tag];\n        }\n        return runningEvent;\n    }\n    _getRunningEvent(eventName) {\n        if (typeof (eventName) === \"string\") {\n            // Listen for \"error\" events (if your contract has an error event, include\n            // the full signature to bypass this special event keyword)\n            if (eventName === \"error\") {\n                return this._normalizeRunningEvent(new ErrorRunningEvent());\n            }\n            // Listen for any event that is registered\n            if (eventName === \"event\") {\n                return this._normalizeRunningEvent(new RunningEvent(\"event\", null));\n            }\n            // Listen for any event\n            if (eventName === \"*\") {\n                return this._normalizeRunningEvent(new WildcardRunningEvent(this.address, this.interface));\n            }\n            // Get the event Fragment (throws if ambiguous/unknown event)\n            const fragment = this.interface.getEvent(eventName);\n            return this._normalizeRunningEvent(new FragmentRunningEvent(this.address, this.interface, fragment));\n        }\n        // We have topics to filter by...\n        if (eventName.topics && eventName.topics.length > 0) {\n            // Is it a known topichash? (throws if no matching topichash)\n            try {\n                const topic = eventName.topics[0];\n                if (typeof (topic) !== \"string\") {\n                    throw new Error(\"invalid topic\"); // @TODO: May happen for anonymous events\n                }\n                const fragment = this.interface.getEvent(topic);\n                return this._normalizeRunningEvent(new FragmentRunningEvent(this.address, this.interface, fragment, eventName.topics));\n            }\n            catch (error) { }\n            // Filter by the unknown topichash\n            const filter = {\n                address: this.address,\n                topics: eventName.topics\n            };\n            return this._normalizeRunningEvent(new RunningEvent(getEventTag(filter), filter));\n        }\n        return this._normalizeRunningEvent(new WildcardRunningEvent(this.address, this.interface));\n    }\n    _checkRunningEvents(runningEvent) {\n        if (runningEvent.listenerCount() === 0) {\n            delete this._runningEvents[runningEvent.tag];\n            // If we have a poller for this, remove it\n            const emit = this._wrappedEmits[runningEvent.tag];\n            if (emit && runningEvent.filter) {\n                this.provider.off(runningEvent.filter, emit);\n                delete this._wrappedEmits[runningEvent.tag];\n            }\n        }\n    }\n    // Subclasses can override this to gracefully recover\n    // from parse errors if they wish\n    _wrapEvent(runningEvent, log, listener) {\n        const event = deepCopy(log);\n        event.removeListener = () => {\n            if (!listener) {\n                return;\n            }\n            runningEvent.removeListener(listener);\n            this._checkRunningEvents(runningEvent);\n        };\n        event.getBlock = () => { return this.provider.getBlock(log.blockHash); };\n        event.getTransaction = () => { return this.provider.getTransaction(log.transactionHash); };\n        event.getTransactionReceipt = () => { return this.provider.getTransactionReceipt(log.transactionHash); };\n        // This may throw if the topics and data mismatch the signature\n        runningEvent.prepareEvent(event);\n        return event;\n    }\n    _addEventListener(runningEvent, listener, once) {\n        if (!this.provider) {\n            logger.throwError(\"events require a provider or a signer with a provider\", Logger.errors.UNSUPPORTED_OPERATION, { operation: \"once\" });\n        }\n        runningEvent.addListener(listener, once);\n        // Track this running event and its listeners (may already be there; but no hard in updating)\n        this._runningEvents[runningEvent.tag] = runningEvent;\n        // If we are not polling the provider, start polling\n        if (!this._wrappedEmits[runningEvent.tag]) {\n            const wrappedEmit = (log) => {\n                let event = this._wrapEvent(runningEvent, log, listener);\n                // Try to emit the result for the parameterized event...\n                if (event.decodeError == null) {\n                    try {\n                        const args = runningEvent.getEmit(event);\n                        this.emit(runningEvent.filter, ...args);\n                    }\n                    catch (error) {\n                        event.decodeError = error.error;\n                    }\n                }\n                // Always emit \"event\" for fragment-base events\n                if (runningEvent.filter != null) {\n                    this.emit(\"event\", event);\n                }\n                // Emit \"error\" if there was an error\n                if (event.decodeError != null) {\n                    this.emit(\"error\", event.decodeError, event);\n                }\n            };\n            this._wrappedEmits[runningEvent.tag] = wrappedEmit;\n            // Special events, like \"error\" do not have a filter\n            if (runningEvent.filter != null) {\n                this.provider.on(runningEvent.filter, wrappedEmit);\n            }\n        }\n    }\n    queryFilter(event, fromBlockOrBlockhash, toBlock) {\n        const runningEvent = this._getRunningEvent(event);\n        const filter = shallowCopy(runningEvent.filter);\n        if (typeof (fromBlockOrBlockhash) === \"string\" && isHexString(fromBlockOrBlockhash, 32)) {\n            if (toBlock != null) {\n                logger.throwArgumentError(\"cannot specify toBlock with blockhash\", \"toBlock\", toBlock);\n            }\n            filter.blockHash = fromBlockOrBlockhash;\n        }\n        else {\n            filter.fromBlock = ((fromBlockOrBlockhash != null) ? fromBlockOrBlockhash : 0);\n            filter.toBlock = ((toBlock != null) ? toBlock : \"latest\");\n        }\n        return this.provider.getLogs(filter).then((logs) => {\n            return logs.map((log) => this._wrapEvent(runningEvent, log, null));\n        });\n    }\n    on(event, listener) {\n        this._addEventListener(this._getRunningEvent(event), listener, false);\n        return this;\n    }\n    once(event, listener) {\n        this._addEventListener(this._getRunningEvent(event), listener, true);\n        return this;\n    }\n    emit(eventName, ...args) {\n        if (!this.provider) {\n            return false;\n        }\n        const runningEvent = this._getRunningEvent(eventName);\n        const result = (runningEvent.run(args) > 0);\n        // May have drained all the \"once\" events; check for living events\n        this._checkRunningEvents(runningEvent);\n        return result;\n    }\n    listenerCount(eventName) {\n        if (!this.provider) {\n            return 0;\n        }\n        if (eventName == null) {\n            return Object.keys(this._runningEvents).reduce((accum, key) => {\n                return accum + this._runningEvents[key].listenerCount();\n            }, 0);\n        }\n        return this._getRunningEvent(eventName).listenerCount();\n    }\n    listeners(eventName) {\n        if (!this.provider) {\n            return [];\n        }\n        if (eventName == null) {\n            const result = [];\n            for (let tag in this._runningEvents) {\n                this._runningEvents[tag].listeners().forEach((listener) => {\n                    result.push(listener);\n                });\n            }\n            return result;\n        }\n        return this._getRunningEvent(eventName).listeners();\n    }\n    removeAllListeners(eventName) {\n        if (!this.provider) {\n            return this;\n        }\n        if (eventName == null) {\n            for (const tag in this._runningEvents) {\n                const runningEvent = this._runningEvents[tag];\n                runningEvent.removeAllListeners();\n                this._checkRunningEvents(runningEvent);\n            }\n            return this;\n        }\n        // Delete any listeners\n        const runningEvent = this._getRunningEvent(eventName);\n        runningEvent.removeAllListeners();\n        this._checkRunningEvents(runningEvent);\n        return this;\n    }\n    off(eventName, listener) {\n        if (!this.provider) {\n            return this;\n        }\n        const runningEvent = this._getRunningEvent(eventName);\n        runningEvent.removeListener(listener);\n        this._checkRunningEvents(runningEvent);\n        return this;\n    }\n    removeListener(eventName, listener) {\n        return this.off(eventName, listener);\n    }\n}\nexport class Contract extends BaseContract {\n}\nexport class ContractFactory {\n    constructor(contractInterface, bytecode, signer) {\n        let bytecodeHex = null;\n        if (typeof (bytecode) === \"string\") {\n            bytecodeHex = bytecode;\n        }\n        else if (isBytes(bytecode)) {\n            bytecodeHex = hexlify(bytecode);\n        }\n        else if (bytecode && typeof (bytecode.object) === \"string\") {\n            // Allow the bytecode object from the Solidity compiler\n            bytecodeHex = bytecode.object;\n        }\n        else {\n            // Crash in the next verification step\n            bytecodeHex = \"!\";\n        }\n        // Make sure it is 0x prefixed\n        if (bytecodeHex.substring(0, 2) !== \"0x\") {\n            bytecodeHex = \"0x\" + bytecodeHex;\n        }\n        // Make sure the final result is valid bytecode\n        if (!isHexString(bytecodeHex) || (bytecodeHex.length % 2)) {\n            logger.throwArgumentError(\"invalid bytecode\", \"bytecode\", bytecode);\n        }\n        // If we have a signer, make sure it is valid\n        if (signer && !Signer.isSigner(signer)) {\n            logger.throwArgumentError(\"invalid signer\", \"signer\", signer);\n        }\n        defineReadOnly(this, \"bytecode\", bytecodeHex);\n        defineReadOnly(this, \"interface\", getStatic(new.target, \"getInterface\")(contractInterface));\n        defineReadOnly(this, \"signer\", signer || null);\n    }\n    // @TODO: Future; rename to populateTransaction?\n    getDeployTransaction(...args) {\n        let tx = {};\n        // If we have 1 additional argument, we allow transaction overrides\n        if (args.length === this.interface.deploy.inputs.length + 1 && typeof (args[args.length - 1]) === \"object\") {\n            tx = shallowCopy(args.pop());\n            for (const key in tx) {\n                if (!allowedTransactionKeys[key]) {\n                    throw new Error(\"unknown transaction override \" + key);\n                }\n            }\n        }\n        // Do not allow these to be overridden in a deployment transaction\n        [\"data\", \"from\", \"to\"].forEach((key) => {\n            if (tx[key] == null) {\n                return;\n            }\n            logger.throwError(\"cannot override \" + key, Logger.errors.UNSUPPORTED_OPERATION, { operation: key });\n        });\n        if (tx.value) {\n            const value = BigNumber.from(tx.value);\n            if (!value.isZero() && !this.interface.deploy.payable) {\n                logger.throwError(\"non-payable constructor cannot override value\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"overrides.value\",\n                    value: tx.value\n                });\n            }\n        }\n        // Make sure the call matches the constructor signature\n        logger.checkArgumentCount(args.length, this.interface.deploy.inputs.length, \" in Contract constructor\");\n        // Set the data to the bytecode + the encoded constructor arguments\n        tx.data = hexlify(concat([\n            this.bytecode,\n            this.interface.encodeDeploy(args)\n        ]));\n        return tx;\n    }\n    deploy(...args) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let overrides = {};\n            // If 1 extra parameter was passed in, it contains overrides\n            if (args.length === this.interface.deploy.inputs.length + 1) {\n                overrides = args.pop();\n            }\n            // Make sure the call matches the constructor signature\n            logger.checkArgumentCount(args.length, this.interface.deploy.inputs.length, \" in Contract constructor\");\n            // Resolve ENS names and promises in the arguments\n            const params = yield resolveAddresses(this.signer, args, this.interface.deploy.inputs);\n            params.push(overrides);\n            // Get the deployment transaction (with optional overrides)\n            const unsignedTx = this.getDeployTransaction(...params);\n            // Send the deployment transaction\n            const tx = yield this.signer.sendTransaction(unsignedTx);\n            const address = getStatic(this.constructor, \"getContractAddress\")(tx);\n            const contract = getStatic(this.constructor, \"getContract\")(address, this.interface, this.signer);\n            // Add the modified wait that wraps events\n            addContractWait(contract, tx);\n            defineReadOnly(contract, \"deployTransaction\", tx);\n            return contract;\n        });\n    }\n    attach(address) {\n        return (this.constructor).getContract(address, this.interface, this.signer);\n    }\n    connect(signer) {\n        return new (this.constructor)(this.interface, this.bytecode, signer);\n    }\n    static fromSolidity(compilerOutput, signer) {\n        if (compilerOutput == null) {\n            logger.throwError(\"missing compiler output\", Logger.errors.MISSING_ARGUMENT, { argument: \"compilerOutput\" });\n        }\n        if (typeof (compilerOutput) === \"string\") {\n            compilerOutput = JSON.parse(compilerOutput);\n        }\n        const abi = compilerOutput.abi;\n        let bytecode = null;\n        if (compilerOutput.bytecode) {\n            bytecode = compilerOutput.bytecode;\n        }\n        else if (compilerOutput.evm && compilerOutput.evm.bytecode) {\n            bytecode = compilerOutput.evm.bytecode;\n        }\n        return new this(abi, bytecode, signer);\n    }\n    static getInterface(contractInterface) {\n        return Contract.getInterface(contractInterface);\n    }\n    static getContractAddress(tx) {\n        return getContractAddress(tx);\n    }\n    static getContract(address, contractInterface, signer) {\n        return new Contract(address, contractInterface, signer);\n    }\n}\n//# sourceMappingURL=index.js.map"],"names":["version","logger","Logger","_constructorGuard","ModifiersBytes","ModifiersNest","checkModifier","type","name","parseParamType","param","allowIndexed","originalParam","throwError","i","newNode","parent","node","verifyType","child","sibling","populate","object","params","key","defineReadOnly","FormatTypes","paramTypeArray","ParamType","constructorGuard","match","format","result","comp","value","ParamTypify","parseParams","allowIndex","splitNesting","Fragment","FunctionFragment","EventFragment","ConstructorFragment","ErrorFragment","input","verifyIdentifier","regexParen","anonymous","modifier","parseGas","comps","BigNumber","parseModifiers","verifyState","state","parens","output","returns","checkForbidden","fragment","sig","regexIdentifier","accum","depth","offset","c","checkResultErrors","errors","checkErrors","path","childPath","error","Coder","localName","dynamic","message","Writer","wordSize","hexConcat","data","writer","concat","bytes","arrayify","paddingOffset","Reader","coerceFunc","allowLoose","hexlify","length","loose","alignedLength","AddressCoder","getAddress","reader","hexZeroPad","AnonymousCoder","coder","pack","coders","values","arrayValues","unique","staticWriter","dynamicWriter","updateFuncs","index","dynamicOffset","updateFunc","baseOffset","func","unpack","baseReader","offsetReader","uniqueNames","ArrayCoder","defaultChild","count","BooleanCoder","DynamicBytesCoder","BytesCoder","FixedBytesCoder","size","NullCoder","NumberCoder","signed","v","maxUintValue","MaxUint256","bounds","One","NegativeOne","Zero","StringCoder","toUtf8Bytes","toUtf8String","TupleCoder","types","paramTypeBytes","paramTypeNumber","AbiCoder","component","defaultAbiCoder","LogDescription","Description","TransactionDescription","ErrorDescription","Indexed","BuiltinErrors","wrapAccessError","property","wrap","Interface","fragments","abi","getStatic","bucket","signature","j","address","hexDataSlice","id","eventFragment","nameOrSignatureOrSighash","isHexString","matching","f","nameOrSignatureOrTopic","topichash","getSighash","functionFragment","reason","errorArgs","errorName","errorSignature","selector","builtin","topics","encodeTopic","keccak256","dataTypes","dataValues","topicHash","indexed","nonIndexed","resultIndexed","resultNonIndexed","nonIndexedIndex","indexedIndex","tx","log","hexData","__awaiter","this","thisArg","_arguments","P","generator","adopt","resolve","reject","fulfilled","step","e","rejected","allowedTransactionKeys","resolveName","resolver","nameOrPromise","resolveAddresses","paramType","populateTransaction","contract","args","overrides","shallowCopy","resolveProperties","check","resolved","ro","accessListify","intrinsic","roValue","leftovers","l","buildPopulate","buildEstimate","signerOrProvider","addContractWait","wait","confirmations","receipt","event","deepCopy","parsed","buildCall","collapseSimple","blockTag","buildSend","txRequest","buildDefault","getEventTag","filter","topic","RunningEvent","tag","listener","once","done","item","listenerCount","argsCopy","ErrorRunningEvent","FragmentRunningEvent","contractInterface","WildcardRunningEvent","BaseContract","addressOrName","Signer","Provider","uniqueFilters","eventSignature","filters","uniqueSignatures","signatures","transaction","getContractAddress","code","VoidSigner","runningEvent","eventName","emit","wrappedEmit","fromBlockOrBlockhash","toBlock","logs","Contract","ContractFactory","bytecode","signer","bytecodeHex","isBytes","unsignedTx","compilerOutput"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]}