{"version":3,"sources":["webpack:///./node_modules/web3-eth-accounts/lib/index.js","webpack:///./node_modules/web3-eth-accounts/node_modules/uuid/index.js","webpack:///./node_modules/web3-eth-accounts/node_modules/uuid/lib/rng-browser.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/_version.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/fragments.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/abstract-coder.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/address.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/anonymous.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/array.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/boolean.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/bytes.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/fixed-bytes.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/null.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/number.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/string.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/coders/tuple.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/abi-coder.js","webpack:///./node_modules/web3-eth-abi/node_modules/@ethersproject/abi/lib.esm/interface.js","webpack:///./node_modules/web3-eth-contract/lib/index.js","webpack:///./node_modules/web3-eth-accounts/node_modules/uuid/lib/bytesToUuid.js","webpack:///./node_modules/web3-eth-accounts/node_modules/uuid/v1.js","webpack:///./node_modules/web3-eth-abi/lib/index.js","webpack:///./node_modules/web3-eth-accounts/node_modules/uuid/v4.js"],"names":["core","r","Method","Account","cryp","scrypt","uuid","utils","helpers","TransactionFactory","Common","default","HardForks","Hardfork","ethereumjsUtil","isNot","value","isExist","Accounts","_this","this","packageInit","arguments","BatchRequest","extend","_ethereumCall","name","call","params","outputFormatter","parseInt","hexToNumber","inputFormatter","address","isAddress","Error","blockNumber","toHex","forEach","method","attachToObject","setRequestManager","_requestManager","wallet","Wallet","_handleTxPricing","tx","Promise","resolve","reject","type","gasPrice","all","getBlockByNumber","getGasPrice","then","responses","block","baseFeePerGas","maxPriorityFeePerGas","maxFeePerGas","toBN","mul","add","error","accounts","_accounts","length","defaultKeyName","prototype","_addAccountFunctions","account","signTransaction","callback","privateKey","sign","data","encrypt","password","options","create","entropy","randomHex","privateKeyToAccount","ignoreLength","startsWith","fromPrivate","transactionOptions","hasTxSigningOptions","chain","hardfork","common","customChain","chainId","signed","gas","gasLimit","nonce","_validateTransactionForSigning","transaction","formatters","inputCallFormatter","Object","assign","accessList","forCustomChain","baseChain","networkId","London","substring","signedTx","fromTxData","Buffer","from","validationErrors","validate","errorString","validationError","rawTransaction","serialize","toString","transactionHash","keccak256","result","messageHash","getMessageToSign","v","s","e","hasEip1559","txType","toLowerCase","Berlin","_handleTxType","getChainId","getTransactionCount","getNetworkId","args","txchainId","txnonce","txnetworkId","txgasInfo","JSON","stringify","recoverTransaction","rawTx","txOptions","slice","fromSerializedData","toChecksumAddress","getSenderAddress","hashMessage","messageHex","isHexStrict","utf8ToHex","messageBytes","hexToBytes","messageBuffer","preamble","preambleBuffer","ethMessage","concat","bufferToHex","hash","signature","vrs","decodeSignature","message","recover","preFixed","apply","encodeSignature","decrypt","v3Keystore","nonStrict","derivedKey","kdfparams","json","parse","version","crypto","kdf","syncScrypt","salt","n","p","dklen","prf","pbkdf2Sync","c","ciphertext","sha3","replace","mac","decipher","createDecipheriv","cipher","cipherparams","iv","seed","update","final","randomBytes","createCipheriv","id","v4","random","_findSafeIndex","pointer","hasOwnProperty","_currentIndexes","keys","map","key","filter","numberOfAccounts","i","index","remove","addressOrIndex","clear","encryptedWallet","keystore","save","keyName","localStorage","setItem","load","getItem","storage","self","x","removeItem","code","storageAvailable","module","exports","v1","getRandomValues","bind","window","msCrypto","rnds8","Uint8Array","rnds","Array","Math","logger","_constructorGuard","ModifiersBytes","calldata","memory","ModifiersNest","checkModifier","indexOf","throwArgumentError","populate","object","FormatTypes","freeze","sighash","minimal","full","paramTypeArray","RegExp","constructor","constructorGuard","throwError","errors","UNSUPPORTED_OPERATION","operation","match","arrayLength","arrayChildren","fromObject","components","baseType","_isParamType","format","indexed","comp","String","join","static","allowIndexed","fromString","isParamType","verifyType","node","ParamTypify","param","originalParam","newNode","parent","state","allowType","allowParams","child","allowName","allowArray","sibling","push","readArray","parseParamType","parseParams","allowIndex","trim","accum","depth","offset","splitNesting","_isFragment","isFragment","EventFragment","split","anonymous","inputs","input","isEventFragment","verifyIdentifier","regexParen","modifier","warn","parseGas","comps","parseModifiers","constant","payable","stateMutability","console","log","verifyState","payble","toNumber","isConstructorFragment","parens","ouputs","outputs","output","isFunctionFragment","returns","regexIdentifier","checkResultErrors","checkErrors","path","isArray","childPath","Coder","localName","dynamic","_throwError","wordSize","_data","_dataLength","_padding","_writeData","appendWriter","writer","writeBytes","bytes","paddingOffset","_getValue","BUFFER_OVERRUN","writeValue","writeUpdatableValue","coerceFunc","allowLoose","_offset","consumed","coerce","_coerceFunc","_peekBytes","loose","alignedLength","ceil","subReader","readBytes","readValue","super","encode","decode","reader","toHexString","coder","pack","coders","values","arrayValues","unique","INVALID_ARGUMENT","argument","staticWriter","dynamicWriter","updateFuncs","dynamicOffset","updateFunc","baseOffset","func","unpack","baseReader","offsetReader","uniqueNames","reduce","defineProperty","get","count","checkArgumentCount","isZero","size","maxUintValue","mask","bounds","gt","lt","toTwos","fromTwos","types","paramTypeBytes","paramTypeNumber","checkNew","_getCoder","component","_getWordSize","_getReader","_getWriter","defaultAbiCoder","_isIndexed","wrapAccessError","property","wrap","fragments","abi","fragment","bucket","deploy","functions","events","j","functionFragment","eventFragment","getFunction","nameOrSignatureOrSighash","getSighash","matching","f","getEvent","nameOrSignatureOrTopic","topichash","getEventTopic","_decodeParams","_abiCoder","_encodeParams","encodeDeploy","decodeFunctionData","encodeFunctionData","decodeFunctionResult","reason","errorSignature","CALL_EXCEPTION","errorArgs","encodeFunctionResult","encodeFilterTopics","UNEXPECTED_ARGUMENT","topics","encodeTopic","pop","encodeEventLog","dataTypes","dataValues","decodeEventLog","topicHash","expected","nonIndexed","resultIndexed","resultNonIndexed","nonIndexedIndex","indexedIndex","parseTransaction","parseLog","topic","_isInterface","Subscription","subscription","promiEvent","Contract","jsonInterface","setProvider","clearSubscriptions","ContractMissingABIError","lastArg","_getOrSetDefaultOptions","set","_address","inputAddressFormatter","enumerable","methods","_jsonInterface","funcName","_jsonInterfaceMethodToString","encodeFunctionSignature","_createTxObject","cascadeFunc","nextMethod","encodeEventSignature","event","_on","allEvents","defaultAccount","defaultBlock","handleRevert","val","defaultCommon","defaultHardfork","defaultChain","transactionPollingTimeout","transactionPollingInterval","transactionConfirmationBlocks","transactionBlockTimeout","blockHeaderTimeout","provider","_ethAccounts","_getCallback","_checkListener","ContractReservedEventError","_encodeEventABI","inputBlockNumberFormatter","indexedTopics","encodeParameter","_decodeEventABI","outputLogFormatter","find","intf","indexedInputs","argTopics","returnValues","decodeLog","__length__","raw","_encodeMethodABI","methodSignature","_method","paramsABI","_parent","inputLength","encodeParameters","_deployData","returnValue","_decodeMethodReturn","decodeParameters","ContractMissingDeployDataError","deployData","_generateEventOptions","eventName","ContractEventDoesNotExistError","ContractNoAddressDefinedError","clone","once","ContractOnceRequiresCallbackError","fromBlock","err","res","sub","unsubscribe","subOptions","toBlock","inputLogFormatter","subscriptionHandler","removed","emit","requestManager","subscribe","getPastEvents","getPastLogs","buildCall","txObject","_executeMethod","request","send","encodeABI","estimateGas","createAccessList","InvalidNumberOfParams","_processExecuteArguments","defer","processedArgs","shift","isFinite","generateRequest","to","_fireError","eventEmitter","ethAccounts","payload","inputDefaultBlockNumberFormatter","ContractNoFromAddressDefinedError","inputTransactionFormatter","createFunction","abiCoder","extraFormatters","receiptFormatter","receipt","logs","ev","contractDeployFormatter","newContract","contractAddress","sendTransaction","byteToHex","substr","buf","bth","_nodeId","_clockseq","rng","bytesToUuid","_lastMSecs","_lastNSecs","b","clockseq","seedBytes","msecs","Date","getTime","nsecs","dt","tl","tmh","EthersAbiCoder","AbiCoder","ParamType","ethersAbiCoder","Result","ABICoder","functionName","mapTypes","formatParam","includes","modifyParams","mappedTypes","isSimplifiedStructFormat","structName","mapStructNameAndType","mapStructToCoderFormat","struct","paramTypeBytesArray","paramTypeNumberArray","isBN","isBigNumber","leftPad","isBuffer","maxSize","rightPad","encodeFunctionCall","decodeParameter","decodeParametersWith","decodedValue","isStringObject","notIndexedInputs","indexedParams","topicCount","staticType","nonIndexedData","notIndexedParams","ii"],"mappings":"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","file":"js/chunk-vendors~0e4a1902.65be8268.js","sourcesContent":["/*\n This file is part of web3.js.\n\n web3.js is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n web3.js is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n */\n/**\n * @file accounts.js\n * @author Fabian Vogelsteller <fabian@ethereum.org>\n * @date 2017\n */\n'use strict';\nvar core = require('web3-core');\nvar Method = require('web3-core-method');\nvar Account = require('eth-lib/lib/account');\nvar cryp = (typeof global === 'undefined') ? require('crypto-browserify') : require('crypto');\nvar scrypt = require('scrypt-js');\nvar uuid = require('uuid');\nvar utils = require('web3-utils');\nvar helpers = require('web3-core-helpers');\nvar { TransactionFactory } = require('@ethereumjs/tx');\nvar Common = require('@ethereumjs/common').default;\nvar HardForks = require('@ethereumjs/common').Hardfork;\nvar ethereumjsUtil = require('ethereumjs-util');\nvar isNot = function (value) {\n    return (typeof value === 'undefined') || value === null;\n};\nvar isExist = function (value) {\n    return (typeof value !== 'undefined') && value !== null;\n};\nvar Accounts = function Accounts() {\n    var _this = this;\n    // sets _requestmanager\n    core.packageInit(this, arguments);\n    // remove unecessary core functions\n    delete this.BatchRequest;\n    delete this.extend;\n    var _ethereumCall = [\n        new Method({\n            name: 'getNetworkId',\n            call: 'net_version',\n            params: 0,\n            outputFormatter: parseInt\n        }),\n        new Method({\n            name: 'getChainId',\n            call: 'eth_chainId',\n            params: 0,\n            outputFormatter: utils.hexToNumber\n        }),\n        new Method({\n            name: 'getGasPrice',\n            call: 'eth_gasPrice',\n            params: 0\n        }),\n        new Method({\n            name: 'getTransactionCount',\n            call: 'eth_getTransactionCount',\n            params: 2,\n            inputFormatter: [function (address) {\n                    if (utils.isAddress(address)) {\n                        return address;\n                    }\n                    else {\n                        throw new Error('Address ' + address + ' is not a valid address to get the \"transactionCount\".');\n                    }\n                }, function () {\n                    return 'latest';\n                }]\n        }),\n        new Method({\n            name: 'getBlockByNumber',\n            call: 'eth_getBlockByNumber',\n            params: 2,\n            inputFormatter: [function (blockNumber) {\n                    return blockNumber ? utils.toHex(blockNumber) : 'latest';\n                }, function () {\n                    return false;\n                }]\n        }),\n    ];\n    // attach methods to this._ethereumCall\n    this._ethereumCall = {};\n    _ethereumCall.forEach((method) => {\n        method.attachToObject(_this._ethereumCall);\n        method.setRequestManager(_this._requestManager);\n    });\n    this.wallet = new Wallet(this);\n};\nAccounts.prototype._addAccountFunctions = function (account) {\n    var _this = this;\n    // add sign functions\n    account.signTransaction = function signTransaction(tx, callback) {\n        return _this.signTransaction(tx, account.privateKey, callback);\n    };\n    account.sign = function sign(data) {\n        return _this.sign(data, account.privateKey);\n    };\n    account.encrypt = function encrypt(password, options) {\n        return _this.encrypt(account.privateKey, password, options);\n    };\n    return account;\n};\nAccounts.prototype.create = function create(entropy) {\n    return this._addAccountFunctions(Account.create(entropy || utils.randomHex(32)));\n};\nAccounts.prototype.privateKeyToAccount = function privateKeyToAccount(privateKey, ignoreLength) {\n    if (!privateKey.startsWith('0x')) {\n        privateKey = '0x' + privateKey;\n    }\n    // 64 hex characters + hex-prefix\n    if (!ignoreLength && privateKey.length !== 66) {\n        throw new Error(\"Private key must be 32 bytes long\");\n    }\n    return this._addAccountFunctions(Account.fromPrivate(privateKey));\n};\nAccounts.prototype.signTransaction = function signTransaction(tx, privateKey, callback) {\n    var _this = this, error = false, transactionOptions = {}, hasTxSigningOptions = !!(tx && ((tx.chain && tx.hardfork) || tx.common));\n    callback = callback || function () { };\n    if (!tx) {\n        error = new Error('No transaction object given!');\n        callback(error);\n        return Promise.reject(error);\n    }\n    if (isExist(tx.common) && isNot(tx.common.customChain)) {\n        error = new Error('If tx.common is provided it must have tx.common.customChain');\n        callback(error);\n        return Promise.reject(error);\n    }\n    if (isExist(tx.common) && isNot(tx.common.customChain.chainId)) {\n        error = new Error('If tx.common is provided it must have tx.common.customChain and tx.common.customChain.chainId');\n        callback(error);\n        return Promise.reject(error);\n    }\n    if (isExist(tx.common) && isExist(tx.common.customChain.chainId) && isExist(tx.chainId) && tx.chainId !== tx.common.customChain.chainId) {\n        error = new Error('Chain Id doesnt match in tx.chainId tx.common.customChain.chainId');\n        callback(error);\n        return Promise.reject(error);\n    }\n    function signed(tx) {\n        const error = _validateTransactionForSigning(tx);\n        if (error) {\n            callback(error);\n            return Promise.reject(error);\n        }\n        try {\n            var transaction = helpers.formatters.inputCallFormatter(Object.assign({}, tx));\n            transaction.data = transaction.data || '0x';\n            transaction.value = transaction.value || '0x';\n            transaction.gasLimit = transaction.gasLimit || transaction.gas;\n            if (transaction.type === '0x1' && transaction.accessList === undefined)\n                transaction.accessList = [];\n            // Because tx has no @ethereumjs/tx signing options we use fetched vals.\n            if (!hasTxSigningOptions) {\n                transactionOptions.common = Common.forCustomChain('mainnet', {\n                    name: 'custom-network',\n                    networkId: transaction.networkId,\n                    chainId: transaction.chainId\n                }, transaction.hardfork || HardForks.London);\n                delete transaction.networkId;\n            }\n            else {\n                if (transaction.common) {\n                    transactionOptions.common = Common.forCustomChain(transaction.common.baseChain || 'mainnet', {\n                        name: transaction.common.customChain.name || 'custom-network',\n                        networkId: transaction.common.customChain.networkId,\n                        chainId: transaction.common.customChain.chainId\n                    }, transaction.common.hardfork || HardForks.London);\n                    delete transaction.common;\n                }\n                if (transaction.chain) {\n                    transactionOptions.chain = transaction.chain;\n                    delete transaction.chain;\n                }\n                if (transaction.hardfork) {\n                    transactionOptions.hardfork = transaction.hardfork;\n                    delete transaction.hardfork;\n                }\n            }\n            if (privateKey.startsWith('0x')) {\n                privateKey = privateKey.substring(2);\n            }\n            var ethTx = TransactionFactory.fromTxData(transaction, transactionOptions);\n            var signedTx = ethTx.sign(Buffer.from(privateKey, 'hex'));\n            var validationErrors = signedTx.validate(true);\n            if (validationErrors.length > 0) {\n                let errorString = 'Signer Error: ';\n                for (const validationError of validationErrors) {\n                    errorString += `${errorString} ${validationError}.`;\n                }\n                throw new Error(errorString);\n            }\n            var rlpEncoded = signedTx.serialize().toString('hex');\n            var rawTransaction = '0x' + rlpEncoded;\n            var transactionHash = utils.keccak256(rawTransaction);\n            var result = {\n                messageHash: '0x' + Buffer.from(signedTx.getMessageToSign(true)).toString('hex'),\n                v: '0x' + signedTx.v.toString('hex'),\n                r: '0x' + signedTx.r.toString('hex'),\n                s: '0x' + signedTx.s.toString('hex'),\n                rawTransaction: rawTransaction,\n                transactionHash: transactionHash\n            };\n            callback(null, result);\n            return result;\n        }\n        catch (e) {\n            callback(e);\n            return Promise.reject(e);\n        }\n    }\n    tx.type = _handleTxType(tx);\n    // Resolve immediately if nonce, chainId, price and signing options are provided\n    if (tx.nonce !== undefined &&\n        tx.chainId !== undefined &&\n        (tx.gasPrice !== undefined ||\n            (tx.maxFeePerGas !== undefined &&\n                tx.maxPriorityFeePerGas !== undefined)) &&\n        hasTxSigningOptions) {\n        return Promise.resolve(signed(tx));\n    }\n    // Otherwise, get the missing info from the Ethereum Node\n    return Promise.all([\n        ((isNot(tx.common) || isNot(tx.common.customChain.chainId)) ? //tx.common.customChain.chainId is not optional inside tx.common if tx.common is provided\n            (isNot(tx.chainId) ? _this._ethereumCall.getChainId() : tx.chainId)\n            : undefined),\n        isNot(tx.nonce) ? _this._ethereumCall.getTransactionCount(_this.privateKeyToAccount(privateKey).address) : tx.nonce,\n        isNot(hasTxSigningOptions) ? _this._ethereumCall.getNetworkId() : 1,\n        _handleTxPricing(_this, tx)\n    ]).then(function (args) {\n        const [txchainId, txnonce, txnetworkId, txgasInfo] = args;\n        if ((isNot(txchainId) && isNot(tx.common) && isNot(tx.common.customChain.chainId)) || isNot(txnonce) || isNot(txnetworkId) || isNot(txgasInfo)) {\n            throw new Error('One of the values \"chainId\", \"networkId\", \"gasPrice\", or \"nonce\" couldn\\'t be fetched: ' + JSON.stringify(args));\n        }\n        return signed({\n            ...tx,\n            ...((isNot(tx.common) || isNot(tx.common.customChain.chainId)) ? { chainId: txchainId } : {}),\n            nonce: txnonce,\n            networkId: txnetworkId,\n            ...txgasInfo // Will either be gasPrice or maxFeePerGas and maxPriorityFeePerGas\n        });\n    });\n};\nfunction _validateTransactionForSigning(tx) {\n    if (tx.common && (tx.chain && tx.hardfork)) {\n        return new Error('Please provide the @ethereumjs/common object or the chain and hardfork property but not all together.');\n    }\n    if ((tx.chain && !tx.hardfork) || (tx.hardfork && !tx.chain)) {\n        return new Error('When specifying chain and hardfork, both values must be defined. ' +\n            'Received \"chain\": ' + tx.chain + ', \"hardfork\": ' + tx.hardfork);\n    }\n    if ((!tx.gas && !tx.gasLimit) &&\n        (!tx.maxPriorityFeePerGas && !tx.maxFeePerGas)) {\n        return new Error('\"gas\" is missing');\n    }\n    if (tx.gas && tx.gasPrice) {\n        if (tx.gas < 0 || tx.gasPrice < 0) {\n            return new Error('Gas or gasPrice is lower than 0');\n        }\n    }\n    else {\n        if (tx.maxPriorityFeePerGas < 0 || tx.maxFeePerGas < 0) {\n            return new Error('maxPriorityFeePerGas or maxFeePerGas is lower than 0');\n        }\n    }\n    if (tx.nonce < 0 || tx.chainId < 0) {\n        return new Error('Nonce or chainId is lower than 0');\n    }\n    return;\n}\nfunction _handleTxType(tx) {\n    // Taken from https://github.com/ethers-io/ethers.js/blob/2a7ce0e72a1e0c9469e10392b0329e75e341cf18/packages/abstract-signer/src.ts/index.ts#L215\n    const hasEip1559 = (tx.maxFeePerGas !== undefined || tx.maxPriorityFeePerGas !== undefined);\n    let txType;\n    if (tx.type !== undefined) {\n        txType = utils.toHex(tx.type);\n    }\n    else if (tx.type === undefined && hasEip1559) {\n        txType = '0x2';\n    }\n    if (tx.gasPrice !== undefined && (txType === '0x2' || hasEip1559))\n        throw Error(\"eip-1559 transactions don't support gasPrice\");\n    if ((txType === '0x1' || txType === '0x0') && hasEip1559)\n        throw Error(\"pre-eip-1559 transaction don't support maxFeePerGas/maxPriorityFeePerGas\");\n    if (hasEip1559 ||\n        ((tx.common && tx.common.hardfork && tx.common.hardfork.toLowerCase() === HardForks.London) ||\n            (tx.hardfork && tx.hardfork.toLowerCase() === HardForks.London))) {\n        txType = '0x2';\n    }\n    else if (tx.accessList ||\n        ((tx.common && tx.common.hardfork && tx.common.hardfork.toLowerCase() === HardForks.Berlin) ||\n            (tx.hardfork && tx.hardfork.toLowerCase() === HardForks.Berlin))) {\n        txType = '0x1';\n    }\n    return txType;\n}\nfunction _handleTxPricing(_this, tx) {\n    return new Promise((resolve, reject) => {\n        try {\n            if ((tx.type === undefined || tx.type < '0x2')\n                && tx.gasPrice !== undefined) {\n                // Legacy transaction, return provided gasPrice\n                resolve({ gasPrice: tx.gasPrice });\n            }\n            else {\n                Promise.all([\n                    _this._ethereumCall.getBlockByNumber(),\n                    _this._ethereumCall.getGasPrice()\n                ]).then(responses => {\n                    const [block, gasPrice] = responses;\n                    if ((tx.type === '0x2') &&\n                        block && block.baseFeePerGas) {\n                        // The network supports EIP-1559\n                        // Taken from https://github.com/ethers-io/ethers.js/blob/ba6854bdd5a912fe873d5da494cb5c62c190adde/packages/abstract-provider/src.ts/index.ts#L230\n                        let maxPriorityFeePerGas, maxFeePerGas;\n                        if (tx.gasPrice) {\n                            // Using legacy gasPrice property on an eip-1559 network,\n                            // so use gasPrice as both fee properties\n                            maxPriorityFeePerGas = tx.gasPrice;\n                            maxFeePerGas = tx.gasPrice;\n                            delete tx.gasPrice;\n                        }\n                        else {\n                            maxPriorityFeePerGas = tx.maxPriorityFeePerGas || '0x9502F900'; // 2.5 Gwei\n                            maxFeePerGas = tx.maxFeePerGas ||\n                                utils.toHex(utils.toBN(block.baseFeePerGas)\n                                    .mul(utils.toBN(2))\n                                    .add(utils.toBN(maxPriorityFeePerGas)));\n                        }\n                        resolve({ maxFeePerGas, maxPriorityFeePerGas });\n                    }\n                    else {\n                        if (tx.maxPriorityFeePerGas || tx.maxFeePerGas)\n                            throw Error(\"Network doesn't support eip-1559\");\n                        resolve({ gasPrice });\n                    }\n                });\n            }\n        }\n        catch (error) {\n            reject(error);\n        }\n    });\n}\n/* jshint ignore:start */\nAccounts.prototype.recoverTransaction = function recoverTransaction(rawTx, txOptions = {}) {\n    // Rely on EthereumJs/tx to determine the type of transaction\n    const data = Buffer.from(rawTx.slice(2), \"hex\");\n    const tx = TransactionFactory.fromSerializedData(data);\n    //update checksum\n    return utils.toChecksumAddress(tx.getSenderAddress().toString(\"hex\"));\n};\n/* jshint ignore:end */\nAccounts.prototype.hashMessage = function hashMessage(data) {\n    var messageHex = utils.isHexStrict(data) ? data : utils.utf8ToHex(data);\n    var messageBytes = utils.hexToBytes(messageHex);\n    var messageBuffer = Buffer.from(messageBytes);\n    var preamble = '\\x19Ethereum Signed Message:\\n' + messageBytes.length;\n    var preambleBuffer = Buffer.from(preamble);\n    var ethMessage = Buffer.concat([preambleBuffer, messageBuffer]);\n    return ethereumjsUtil.bufferToHex(ethereumjsUtil.keccak256(ethMessage));\n};\nAccounts.prototype.sign = function sign(data, privateKey) {\n    if (!privateKey.startsWith('0x')) {\n        privateKey = '0x' + privateKey;\n    }\n    // 64 hex characters + hex-prefix\n    if (privateKey.length !== 66) {\n        throw new Error(\"Private key must be 32 bytes long\");\n    }\n    var hash = this.hashMessage(data);\n    var signature = Account.sign(hash, privateKey);\n    var vrs = Account.decodeSignature(signature);\n    return {\n        message: data,\n        messageHash: hash,\n        v: vrs[0],\n        r: vrs[1],\n        s: vrs[2],\n        signature: signature\n    };\n};\nAccounts.prototype.recover = function recover(message, signature, preFixed) {\n    var args = [].slice.apply(arguments);\n    if (!!message && typeof message === 'object') {\n        return this.recover(message.messageHash, Account.encodeSignature([message.v, message.r, message.s]), true);\n    }\n    if (!preFixed) {\n        message = this.hashMessage(message);\n    }\n    if (args.length >= 4) {\n        preFixed = args.slice(-1)[0];\n        preFixed = typeof preFixed === 'boolean' ? !!preFixed : false;\n        return this.recover(message, Account.encodeSignature(args.slice(1, 4)), preFixed); // v, r, s\n    }\n    return Account.recover(message, signature);\n};\n// Taken from https://github.com/ethereumjs/ethereumjs-wallet\nAccounts.prototype.decrypt = function (v3Keystore, password, nonStrict) {\n    /* jshint maxcomplexity: 10 */\n    if (!(typeof password === 'string')) {\n        throw new Error('No password given.');\n    }\n    var json = (!!v3Keystore && typeof v3Keystore === 'object') ? v3Keystore : JSON.parse(nonStrict ? v3Keystore.toLowerCase() : v3Keystore);\n    if (json.version !== 3) {\n        throw new Error('Not a valid V3 wallet');\n    }\n    var derivedKey;\n    var kdfparams;\n    if (json.crypto.kdf === 'scrypt') {\n        kdfparams = json.crypto.kdfparams;\n        // FIXME: support progress reporting callback\n        derivedKey = scrypt.syncScrypt(Buffer.from(password), Buffer.from(kdfparams.salt, 'hex'), kdfparams.n, kdfparams.r, kdfparams.p, kdfparams.dklen);\n    }\n    else if (json.crypto.kdf === 'pbkdf2') {\n        kdfparams = json.crypto.kdfparams;\n        if (kdfparams.prf !== 'hmac-sha256') {\n            throw new Error('Unsupported parameters to PBKDF2');\n        }\n        derivedKey = cryp.pbkdf2Sync(Buffer.from(password), Buffer.from(kdfparams.salt, 'hex'), kdfparams.c, kdfparams.dklen, 'sha256');\n    }\n    else {\n        throw new Error('Unsupported key derivation scheme');\n    }\n    var ciphertext = Buffer.from(json.crypto.ciphertext, 'hex');\n    var mac = utils.sha3(Buffer.from([...derivedKey.slice(16, 32), ...ciphertext])).replace('0x', '');\n    if (mac !== json.crypto.mac) {\n        throw new Error('Key derivation failed - possibly wrong password');\n    }\n    var decipher = cryp.createDecipheriv(json.crypto.cipher, derivedKey.slice(0, 16), Buffer.from(json.crypto.cipherparams.iv, 'hex'));\n    var seed = '0x' + Buffer.from([...decipher.update(ciphertext), ...decipher.final()]).toString('hex');\n    return this.privateKeyToAccount(seed, true);\n};\nAccounts.prototype.encrypt = function (privateKey, password, options) {\n    /* jshint maxcomplexity: 20 */\n    var account = this.privateKeyToAccount(privateKey, true);\n    options = options || {};\n    var salt = options.salt || cryp.randomBytes(32);\n    var iv = options.iv || cryp.randomBytes(16);\n    var derivedKey;\n    var kdf = options.kdf || 'scrypt';\n    var kdfparams = {\n        dklen: options.dklen || 32,\n        salt: salt.toString('hex')\n    };\n    if (kdf === 'pbkdf2') {\n        kdfparams.c = options.c || 262144;\n        kdfparams.prf = 'hmac-sha256';\n        derivedKey = cryp.pbkdf2Sync(Buffer.from(password), Buffer.from(kdfparams.salt, 'hex'), kdfparams.c, kdfparams.dklen, 'sha256');\n    }\n    else if (kdf === 'scrypt') {\n        // FIXME: support progress reporting callback\n        kdfparams.n = options.n || 8192; // 2048 4096 8192 16384\n        kdfparams.r = options.r || 8;\n        kdfparams.p = options.p || 1;\n        derivedKey = scrypt.syncScrypt(Buffer.from(password), Buffer.from(kdfparams.salt, 'hex'), kdfparams.n, kdfparams.r, kdfparams.p, kdfparams.dklen);\n    }\n    else {\n        throw new Error('Unsupported kdf');\n    }\n    var cipher = cryp.createCipheriv(options.cipher || 'aes-128-ctr', derivedKey.slice(0, 16), iv);\n    if (!cipher) {\n        throw new Error('Unsupported cipher');\n    }\n    var ciphertext = Buffer.from([\n        ...cipher.update(Buffer.from(account.privateKey.replace('0x', ''), 'hex')),\n        ...cipher.final()\n    ]);\n    var mac = utils.sha3(Buffer.from([...derivedKey.slice(16, 32), ...ciphertext])).replace('0x', '');\n    return {\n        version: 3,\n        id: uuid.v4({ random: options.uuid || cryp.randomBytes(16) }),\n        address: account.address.toLowerCase().replace('0x', ''),\n        crypto: {\n            ciphertext: ciphertext.toString('hex'),\n            cipherparams: {\n                iv: iv.toString('hex')\n            },\n            cipher: options.cipher || 'aes-128-ctr',\n            kdf: kdf,\n            kdfparams: kdfparams,\n            mac: mac.toString('hex')\n        }\n    };\n};\n// Note: this is trying to follow closely the specs on\n// http://web3js.readthedocs.io/en/1.0/web3-eth-accounts.html\nfunction Wallet(accounts) {\n    this._accounts = accounts;\n    this.length = 0;\n    this.defaultKeyName = 'web3js_wallet';\n}\nWallet.prototype._findSafeIndex = function (pointer) {\n    pointer = pointer || 0;\n    if (this.hasOwnProperty(pointer)) {\n        return this._findSafeIndex(pointer + 1);\n    }\n    else {\n        return pointer;\n    }\n};\nWallet.prototype._currentIndexes = function () {\n    var keys = Object.keys(this);\n    var indexes = keys\n        .map(function (key) {\n        return parseInt(key);\n    })\n        .filter(function (n) {\n        return (n < 9e20);\n    });\n    return indexes;\n};\nWallet.prototype.create = function (numberOfAccounts, entropy) {\n    for (var i = 0; i < numberOfAccounts; ++i) {\n        this.add(this._accounts.create(entropy).privateKey);\n    }\n    return this;\n};\nWallet.prototype.add = function (account) {\n    if (typeof account === 'string') {\n        account = this._accounts.privateKeyToAccount(account);\n    }\n    if (!this[account.address]) {\n        account = this._accounts.privateKeyToAccount(account.privateKey);\n        account.index = this._findSafeIndex();\n        this[account.index] = account;\n        this[account.address] = account;\n        this[account.address.toLowerCase()] = account;\n        this.length++;\n        return account;\n    }\n    else {\n        return this[account.address];\n    }\n};\nWallet.prototype.remove = function (addressOrIndex) {\n    var account = this[addressOrIndex];\n    if (account && account.address) {\n        // address\n        this[account.address].privateKey = null;\n        delete this[account.address];\n        // address lowercase\n        this[account.address.toLowerCase()].privateKey = null;\n        delete this[account.address.toLowerCase()];\n        // index\n        this[account.index].privateKey = null;\n        delete this[account.index];\n        this.length--;\n        return true;\n    }\n    else {\n        return false;\n    }\n};\nWallet.prototype.clear = function () {\n    var _this = this;\n    var indexes = this._currentIndexes();\n    indexes.forEach(function (index) {\n        _this.remove(index);\n    });\n    return this;\n};\nWallet.prototype.encrypt = function (password, options) {\n    var _this = this;\n    var indexes = this._currentIndexes();\n    var accounts = indexes.map(function (index) {\n        return _this[index].encrypt(password, options);\n    });\n    return accounts;\n};\nWallet.prototype.decrypt = function (encryptedWallet, password) {\n    var _this = this;\n    encryptedWallet.forEach(function (keystore) {\n        var account = _this._accounts.decrypt(keystore, password);\n        if (account) {\n            _this.add(account);\n        }\n        else {\n            throw new Error('Couldn\\'t decrypt accounts. Password wrong?');\n        }\n    });\n    return this;\n};\nWallet.prototype.save = function (password, keyName) {\n    localStorage.setItem(keyName || this.defaultKeyName, JSON.stringify(this.encrypt(password)));\n    return true;\n};\nWallet.prototype.load = function (password, keyName) {\n    var keystore = localStorage.getItem(keyName || this.defaultKeyName);\n    if (keystore) {\n        try {\n            keystore = JSON.parse(keystore);\n        }\n        catch (e) {\n        }\n    }\n    return this.decrypt(keystore || [], password);\n};\nif (!storageAvailable('localStorage')) {\n    delete Wallet.prototype.save;\n    delete Wallet.prototype.load;\n}\n/**\n * Checks whether a storage type is available or not\n * For more info on how this works, please refer to MDN documentation\n * https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API#Feature-detecting_localStorage\n *\n * @method storageAvailable\n * @param {String} type the type of storage ('localStorage', 'sessionStorage')\n * @returns {Boolean} a boolean indicating whether the specified storage is available or not\n */\nfunction storageAvailable(type) {\n    var storage;\n    try {\n        storage = self[type];\n        var x = '__storage_test__';\n        storage.setItem(x, x);\n        storage.removeItem(x);\n        return true;\n    }\n    catch (e) {\n        return e && (\n        // everything except Firefox\n        e.code === 22 ||\n            // Firefox\n            e.code === 1014 ||\n            // test name field too, because code might not be present\n            // everything except Firefox\n            e.name === 'QuotaExceededError' ||\n            // Firefox\n            e.name === 'NS_ERROR_DOM_QUOTA_REACHED') &&\n            // acknowledge QuotaExceededError only if there's something already stored\n            (storage && storage.length !== 0);\n    }\n}\nmodule.exports = Accounts;\n","var v1 = require('./v1');\nvar v4 = require('./v4');\n\nvar uuid = v4;\nuuid.v1 = v1;\nuuid.v4 = v4;\n\nmodule.exports = uuid;\n","// Unique ID creation requires a high quality random # generator.  In the\n// browser this is a little complicated due to unknown quality of Math.random()\n// and inconsistent support for the `crypto` API.  We do the best we can via\n// feature-detection\n\n// getRandomValues needs to be invoked in a context where \"this\" is a Crypto\n// implementation. Also, find the complete implementation of crypto on IE11.\nvar getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||\n                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));\n\nif (getRandomValues) {\n  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef\n\n  module.exports = function whatwgRNG() {\n    getRandomValues(rnds8);\n    return rnds8;\n  };\n} else {\n  // Math.random()-based (RNG)\n  //\n  // If all else fails, use Math.random().  It's fast, but is of unspecified\n  // quality.\n  var rnds = new Array(16);\n\n  module.exports = function mathRNG() {\n    for (var i = 0, r; i < 16; i++) {\n      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;\n      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return rnds;\n  };\n}\n","export const version = \"abi/5.0.7\";\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-Readble 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, addres 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 \"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        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                payble: 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                payble: this.payable,\n                gas: (this.gas ? this.gas.toNumber() : undefined),\n                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),\n                ouputs: 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 ErrorFragment extends Fragment {\n//}\n//export class StructFragment extends Fragment {\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}\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    encode(writer, value) {\n        try {\n            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    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                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                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    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        }\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    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    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    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    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    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    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    encode(writer, value) {\n        return pack(writer, this.coders, value);\n    }\n    decode(reader) {\n        return reader.coerce(this.name, unpack(reader, this.coders));\n    }\n}\n//# sourceMappingURL=tuple.js.map","\"use strict\";\n// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { Reader, Writer } from \"./coders/abstract-coder\";\nimport { AddressCoder } from \"./coders/address\";\nimport { ArrayCoder } from \"./coders/array\";\nimport { BooleanCoder } from \"./coders/boolean\";\nimport { BytesCoder } from \"./coders/bytes\";\nimport { FixedBytesCoder } from \"./coders/fixed-bytes\";\nimport { NullCoder } from \"./coders/null\";\nimport { NumberCoder } from \"./coders/number\";\nimport { StringCoder } from \"./coders/string\";\nimport { TupleCoder } from \"./coders/tuple\";\nimport { ParamType } from \"./fragments\";\nconst paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\nconst paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\nexport class AbiCoder {\n    constructor(coerceFunc) {\n        logger.checkNew(new.target, AbiCoder);\n        defineReadOnly(this, \"coerceFunc\", coerceFunc || null);\n    }\n    _getCoder(param) {\n        switch (param.baseType) {\n            case \"address\":\n                return new AddressCoder(param.name);\n            case \"bool\":\n                return new BooleanCoder(param.name);\n            case \"string\":\n                return new StringCoder(param.name);\n            case \"bytes\":\n                return new BytesCoder(param.name);\n            case \"array\":\n                return new ArrayCoder(this._getCoder(param.arrayChildren), param.arrayLength, param.name);\n            case \"tuple\":\n                return new TupleCoder((param.components || []).map((component) => {\n                    return this._getCoder(component);\n                }), param.name);\n            case \"\":\n                return new NullCoder(param.name);\n        }\n        // u?int[0-9]*\n        let match = param.type.match(paramTypeNumber);\n        if (match) {\n            let size = parseInt(match[2] || \"256\");\n            if (size === 0 || size > 256 || (size % 8) !== 0) {\n                logger.throwArgumentError(\"invalid \" + match[1] + \" bit length\", \"param\", param);\n            }\n            return new NumberCoder(size / 8, (match[1] === \"int\"), param.name);\n        }\n        // bytes[0-9]+\n        match = param.type.match(paramTypeBytes);\n        if (match) {\n            let size = parseInt(match[1]);\n            if (size === 0 || size > 32) {\n                logger.throwArgumentError(\"invalid bytes length\", \"param\", param);\n            }\n            return new FixedBytesCoder(size, param.name);\n        }\n        return logger.throwArgumentError(\"invalid type\", \"type\", param.type);\n    }\n    _getWordSize() { return 32; }\n    _getReader(data, allowLoose) {\n        return new Reader(data, this._getWordSize(), this.coerceFunc, allowLoose);\n    }\n    _getWriter() {\n        return new Writer(this._getWordSize());\n    }\n    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 Indexed extends Description {\n    static isIndexed(value) {\n        return !!(value && value._isIndexed);\n    }\n}\nfunction wrapAccessError(property, error) {\n    const wrap = new Error(`deferred error during ABI decoding triggered accessing ${property}`);\n    wrap.error = error;\n    return wrap;\n}\n/*\nfunction checkNames(fragment: Fragment, type: \"input\" | \"output\", params: Array<ParamType>): void {\n    params.reduce((accum, param) => {\n        if (param.name) {\n            if (accum[param.name]) {\n                logger.throwArgumentError(`duplicate ${ type } parameter ${ JSON.stringify(param.name) } in ${ fragment.format(\"full\") }`, \"fragment\", fragment);\n            }\n            accum[param.name] = true;\n        }\n        return accum;\n    }, <{ [ name: string ]: boolean }>{ });\n}\n*/\nexport class Interface {\n    constructor(fragments) {\n        logger.checkNew(new.target, Interface);\n        let abi = [];\n        if (typeof (fragments) === \"string\") {\n            abi = JSON.parse(fragments);\n        }\n        else {\n            abi = fragments;\n        }\n        defineReadOnly(this, \"fragments\", abi.map((fragment) => {\n            return Fragment.from(fragment);\n        }).filter((fragment) => (fragment != null)));\n        defineReadOnly(this, \"_abiCoder\", getStatic((new.target), \"getAbiCoder\")());\n        defineReadOnly(this, \"functions\", {});\n        defineReadOnly(this, \"errors\", {});\n        defineReadOnly(this, \"events\", {});\n        defineReadOnly(this, \"structs\", {});\n        // Add all fragments by their signature\n        this.fragments.forEach((fragment) => {\n            let bucket = null;\n            switch (fragment.type) {\n                case \"constructor\":\n                    if (this.deploy) {\n                        logger.warn(\"duplicate definition - constructor\");\n                        return;\n                    }\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    defineReadOnly(this, \"deploy\", fragment);\n                    return;\n                case \"function\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    //checkNames(fragment, \"output\", (<FunctionFragment>fragment).outputs);\n                    bucket = this.functions;\n                    break;\n                case \"event\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    bucket = this.events;\n                    break;\n                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(functionFragment) {\n        return hexDataSlice(id(functionFragment.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        // Normlize 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        // Normlize 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    // Get the sighash (the bytes4 selector) used by Solidity to identify a function\n    getSighash(functionFragment) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        return getStatic(this.constructor, \"getSighash\")(functionFragment);\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    // 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 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                if (hexlify(bytes.slice(0, 4)) === \"0x08c379a0\") {\n                    errorSignature = \"Error(string)\";\n                    reason = this._abiCoder.decode([\"string\"], bytes.slice(4))[0];\n                }\n                break;\n        }\n        return logger.throwError(\"call revert exception\", Logger.errors.CALL_EXCEPTION, {\n            method: functionFragment.format(),\n            errorSignature: errorSignature,\n            errorArgs: [reason],\n            reason: reason\n        });\n    }\n    // Encode the result for a function call (e.g. for eth_call)\n    encodeFunctionResult(functionFragment, values) {\n        if (typeof (functionFragment) === \"string\") {\n            functionFragment = this.getFunction(functionFragment);\n        }\n        return hexlify(this._abiCoder.encode(functionFragment.outputs, values || []));\n    }\n    // Create the filter for the event with search criteria (e.g. for eth_filterLog)\n    encodeFilterTopics(eventFragment, values) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        if (values.length > eventFragment.inputs.length) {\n            logger.throwError(\"too many arguments for \" + eventFragment.format(), Logger.errors.UNEXPECTED_ARGUMENT, {\n                argument: \"values\",\n                value: values\n            });\n        }\n        let topics = [];\n        if (!eventFragment.anonymous) {\n            topics.push(this.getEventTopic(eventFragment));\n        }\n        const encodeTopic = (param, value) => {\n            if (param.type === \"string\") {\n                return id(value);\n            }\n            else if (param.type === \"bytes\") {\n                return keccak256(hexlify(value));\n            }\n            // Check addresses are valid\n            if (param.type === \"address\") {\n                this._abiCoder.encode([\"address\"], [value]);\n            }\n            return hexZeroPad(hexlify(value), 32);\n        };\n        values.forEach((value, index) => {\n            let param = eventFragment.inputs[index];\n            if (!param.indexed) {\n                if (value != null) {\n                    logger.throwArgumentError(\"cannot filter non-indexed parameters; must be null\", (\"contract.\" + param.name), value);\n                }\n                return;\n            }\n            if (value == null) {\n                topics.push(null);\n            }\n            else if (param.baseType === \"array\" || param.baseType === \"tuple\") {\n                logger.throwArgumentError(\"filtering with tuples or arrays not supported\", (\"contract.\" + param.name), value);\n            }\n            else if (Array.isArray(value)) {\n                topics.push(value.map((value) => encodeTopic(param, value)));\n            }\n            else {\n                topics.push(encodeTopic(param, value));\n            }\n        });\n        // Trim off trailing nulls\n        while (topics.length && topics[topics.length - 1] === null) {\n            topics.pop();\n        }\n        return topics;\n    }\n    encodeEventLog(eventFragment, values) {\n        if (typeof (eventFragment) === \"string\") {\n            eventFragment = this.getEvent(eventFragment);\n        }\n        const topics = [];\n        const dataTypes = [];\n        const dataValues = [];\n        if (!eventFragment.anonymous) {\n            topics.push(this.getEventTopic(eventFragment));\n        }\n        if (values.length !== eventFragment.inputs.length) {\n            logger.throwArgumentError(\"event arguments/values mismatch\", \"values\", values);\n        }\n        eventFragment.inputs.forEach((param, index) => {\n            const value = values[index];\n            if (param.indexed) {\n                if (param.type === \"string\") {\n                    topics.push(id(value));\n                }\n                else if (param.type === \"bytes\") {\n                    topics.push(keccak256(value));\n                }\n                else if (param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    // @TOOD\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                        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                    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    // 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 jsut 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    /*\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","/*\n    This file is part of web3.js.\n\n    web3.js is free software: you can redistribute it and/or modify\n    it under the terms of the GNU Lesser General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    web3.js is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU Lesser General Public License for more details.\n\n    You should have received a copy of the GNU Lesser General Public License\n    along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n*/\n/**\n * @file contract.js\n *\n * To initialize a contract use:\n *\n *  var Contract = require('web3-eth-contract');\n *  Contract.setProvider('ws://localhost:8546');\n *  var contract = new Contract(abi, address, ...);\n *\n * @author Fabian Vogelsteller <fabian@ethereum.org>\n * @date 2017\n */\n\"use strict\";\nvar core = require('web3-core');\nvar Method = require('web3-core-method');\nvar utils = require('web3-utils');\nvar Subscription = require('web3-core-subscriptions').subscription;\nvar formatters = require('web3-core-helpers').formatters;\nvar errors = require('web3-core-helpers').errors;\nvar promiEvent = require('web3-core-promievent');\nvar abi = require('web3-eth-abi');\n/**\n * Should be called to create new contract instance\n *\n * @method Contract\n * @constructor\n * @param {Array} jsonInterface\n * @param {String} address\n * @param {Object} options\n */\nvar Contract = function Contract(jsonInterface, address, options) {\n    var _this = this, args = Array.prototype.slice.call(arguments);\n    if (!(this instanceof Contract)) {\n        throw new Error('Please use the \"new\" keyword to instantiate a web3.eth.Contract() object!');\n    }\n    this.setProvider = function () {\n        core.packageInit(_this, arguments);\n        _this.clearSubscriptions = _this._requestManager.clearSubscriptions;\n    };\n    // sets _requestmanager\n    core.packageInit(this, [this.constructor]);\n    this.clearSubscriptions = this._requestManager.clearSubscriptions;\n    if (!jsonInterface || !(Array.isArray(jsonInterface))) {\n        throw errors.ContractMissingABIError();\n    }\n    // create the options object\n    this.options = {};\n    var lastArg = args[args.length - 1];\n    if (!!lastArg && typeof lastArg === 'object' && !Array.isArray(lastArg)) {\n        options = lastArg;\n        this.options = { ...this.options, ...this._getOrSetDefaultOptions(options) };\n        if (!!address && typeof address === 'object') {\n            address = null;\n        }\n    }\n    // set address\n    Object.defineProperty(this.options, 'address', {\n        set: function (value) {\n            if (value) {\n                _this._address = utils.toChecksumAddress(formatters.inputAddressFormatter(value));\n            }\n        },\n        get: function () {\n            return _this._address;\n        },\n        enumerable: true\n    });\n    // add method and event signatures, when the jsonInterface gets set\n    Object.defineProperty(this.options, 'jsonInterface', {\n        set: function (value) {\n            _this.methods = {};\n            _this.events = {};\n            _this._jsonInterface = value.map(function (method) {\n                var func, funcName;\n                // make constant and payable backwards compatible\n                method.constant = (method.stateMutability === \"view\" || method.stateMutability === \"pure\" || method.constant);\n                method.payable = (method.stateMutability === \"payable\" || method.payable);\n                if (method.name) {\n                    funcName = utils._jsonInterfaceMethodToString(method);\n                }\n                // function\n                if (method.type === 'function') {\n                    method.signature = abi.encodeFunctionSignature(funcName);\n                    func = _this._createTxObject.bind({\n                        method: method,\n                        parent: _this\n                    });\n                    // add method only if not one already exists\n                    if (!_this.methods[method.name]) {\n                        _this.methods[method.name] = func;\n                    }\n                    else {\n                        var cascadeFunc = _this._createTxObject.bind({\n                            method: method,\n                            parent: _this,\n                            nextMethod: _this.methods[method.name]\n                        });\n                        _this.methods[method.name] = cascadeFunc;\n                    }\n                    // definitely add the method based on its signature\n                    _this.methods[method.signature] = func;\n                    // add method by name\n                    _this.methods[funcName] = func;\n                    // event\n                }\n                else if (method.type === 'event') {\n                    method.signature = abi.encodeEventSignature(funcName);\n                    var event = _this._on.bind(_this, method.signature);\n                    // add method only if not already exists\n                    if (!_this.events[method.name] || _this.events[method.name].name === 'bound ')\n                        _this.events[method.name] = event;\n                    // definitely add the method based on its signature\n                    _this.events[method.signature] = event;\n                    // add event by name\n                    _this.events[funcName] = event;\n                }\n                return method;\n            });\n            // add allEvents\n            _this.events.allEvents = _this._on.bind(_this, 'allevents');\n            return _this._jsonInterface;\n        },\n        get: function () {\n            return _this._jsonInterface;\n        },\n        enumerable: true\n    });\n    // get default account from the Class\n    var defaultAccount = this.constructor.defaultAccount;\n    var defaultBlock = this.constructor.defaultBlock || 'latest';\n    Object.defineProperty(this, 'handleRevert', {\n        get: function () {\n            if (_this.options.handleRevert === false || _this.options.handleRevert === true) {\n                return _this.options.handleRevert;\n            }\n            return this.constructor.handleRevert;\n        },\n        set: function (val) {\n            _this.options.handleRevert = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'defaultCommon', {\n        get: function () {\n            return _this.options.common || this.constructor.defaultCommon;\n        },\n        set: function (val) {\n            _this.options.common = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'defaultHardfork', {\n        get: function () {\n            return _this.options.hardfork || this.constructor.defaultHardfork;\n        },\n        set: function (val) {\n            _this.options.hardfork = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'defaultChain', {\n        get: function () {\n            return _this.options.chain || this.constructor.defaultChain;\n        },\n        set: function (val) {\n            _this.options.chain = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'transactionPollingTimeout', {\n        get: function () {\n            if (_this.options.transactionPollingTimeout === 0) {\n                return _this.options.transactionPollingTimeout;\n            }\n            return _this.options.transactionPollingTimeout || this.constructor.transactionPollingTimeout;\n        },\n        set: function (val) {\n            _this.options.transactionPollingTimeout = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'transactionPollingInterval', {\n        get: function () {\n            if (_this.options.transactionPollingInterval === 0) {\n                return _this.options.transactionPollingInterval;\n            }\n            return _this.options.transactionPollingInterval || this.constructor.transactionPollingInterval;\n        },\n        set: function (val) {\n            _this.options.transactionPollingInterval = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'transactionConfirmationBlocks', {\n        get: function () {\n            if (_this.options.transactionConfirmationBlocks === 0) {\n                return _this.options.transactionConfirmationBlocks;\n            }\n            return _this.options.transactionConfirmationBlocks || this.constructor.transactionConfirmationBlocks;\n        },\n        set: function (val) {\n            _this.options.transactionConfirmationBlocks = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'transactionBlockTimeout', {\n        get: function () {\n            if (_this.options.transactionBlockTimeout === 0) {\n                return _this.options.transactionBlockTimeout;\n            }\n            return _this.options.transactionBlockTimeout || this.constructor.transactionBlockTimeout;\n        },\n        set: function (val) {\n            _this.options.transactionBlockTimeout = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'blockHeaderTimeout', {\n        get: function () {\n            if (_this.options.blockHeaderTimeout === 0) {\n                return _this.options.blockHeaderTimeout;\n            }\n            return _this.options.blockHeaderTimeout || this.constructor.blockHeaderTimeout;\n        },\n        set: function (val) {\n            _this.options.blockHeaderTimeout = val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'defaultAccount', {\n        get: function () {\n            return defaultAccount;\n        },\n        set: function (val) {\n            if (val) {\n                defaultAccount = utils.toChecksumAddress(formatters.inputAddressFormatter(val));\n            }\n            return val;\n        },\n        enumerable: true\n    });\n    Object.defineProperty(this, 'defaultBlock', {\n        get: function () {\n            return defaultBlock;\n        },\n        set: function (val) {\n            defaultBlock = val;\n            return val;\n        },\n        enumerable: true\n    });\n    // properties\n    this.methods = {};\n    this.events = {};\n    this._address = null;\n    this._jsonInterface = [];\n    // set getter/setter properties\n    this.options.address = address;\n    this.options.jsonInterface = jsonInterface;\n};\n/**\n * Sets the new provider, creates a new requestManager, registers the \"data\" listener on the provider and sets the\n * accounts module for the Contract class.\n *\n * @method setProvider\n *\n * @param {string|provider} provider\n * @param {Accounts} accounts\n *\n * @returns void\n */\nContract.setProvider = function (provider, accounts) {\n    // Contract.currentProvider = provider;\n    core.packageInit(this, [provider]);\n    this._ethAccounts = accounts;\n};\n/**\n * Get the callback and modify the array if necessary\n *\n * @method _getCallback\n * @param {Array} args\n * @return {Function} the callback\n */\nContract.prototype._getCallback = function getCallback(args) {\n    if (args && !!args[args.length - 1] && typeof args[args.length - 1] === 'function') {\n        return args.pop(); // modify the args array!\n    }\n};\n/**\n * Checks that no listener with name \"newListener\" or \"removeListener\" is added.\n *\n * @method _checkListener\n * @param {String} type\n * @param {String} event\n * @return {Object} the contract instance\n */\nContract.prototype._checkListener = function (type, event) {\n    if (event === type) {\n        throw errors.ContractReservedEventError(type);\n    }\n};\n/**\n * Use default values, if options are not available\n *\n * @method _getOrSetDefaultOptions\n * @param {Object} options the options gived by the user\n * @return {Object} the options with gaps filled by defaults\n */\nContract.prototype._getOrSetDefaultOptions = function getOrSetDefaultOptions(options) {\n    var gasPrice = options.gasPrice ? String(options.gasPrice) : null;\n    var from = options.from ? utils.toChecksumAddress(formatters.inputAddressFormatter(options.from)) : null;\n    options.data = options.data || this.options.data;\n    options.from = from || this.options.from;\n    options.gasPrice = gasPrice || this.options.gasPrice;\n    options.gas = options.gas || options.gasLimit || this.options.gas;\n    // TODO replace with only gasLimit?\n    delete options.gasLimit;\n    return options;\n};\n/**\n * Should be used to encode indexed params and options to one final object\n *\n * @method _encodeEventABI\n * @param {Object} event\n * @param {Object} options\n * @return {Object} everything combined together and encoded\n */\nContract.prototype._encodeEventABI = function (event, options) {\n    options = options || {};\n    var filter = options.filter || {}, result = {};\n    ['fromBlock', 'toBlock'].filter(function (f) {\n        return options[f] !== undefined;\n    }).forEach(function (f) {\n        result[f] = formatters.inputBlockNumberFormatter(options[f]);\n    });\n    // use given topics\n    if (Array.isArray(options.topics)) {\n        result.topics = options.topics;\n        // create topics based on filter\n    }\n    else {\n        result.topics = [];\n        // add event signature\n        if (event && !event.anonymous && event.name !== 'ALLEVENTS') {\n            result.topics.push(event.signature);\n        }\n        // add event topics (indexed arguments)\n        if (event.name !== 'ALLEVENTS') {\n            var indexedTopics = event.inputs.filter(function (i) {\n                return i.indexed === true;\n            }).map(function (i) {\n                var value = filter[i.name];\n                if (!value) {\n                    return null;\n                }\n                // TODO: https://github.com/ethereum/web3.js/issues/344\n                // TODO: deal properly with components\n                if (Array.isArray(value)) {\n                    return value.map(function (v) {\n                        return abi.encodeParameter(i.type, v);\n                    });\n                }\n                return abi.encodeParameter(i.type, value);\n            });\n            result.topics = result.topics.concat(indexedTopics);\n        }\n        if (!result.topics.length)\n            delete result.topics;\n    }\n    if (this.options.address) {\n        result.address = this.options.address.toLowerCase();\n    }\n    return result;\n};\n/**\n * Should be used to decode indexed params and options\n *\n * @method _decodeEventABI\n * @param {Object} data\n * @return {Object} result object with decoded indexed && not indexed params\n */\nContract.prototype._decodeEventABI = function (data) {\n    var event = this;\n    data.data = data.data || '';\n    data.topics = data.topics || [];\n    var result = formatters.outputLogFormatter(data);\n    // if allEvents get the right event\n    if (event.name === 'ALLEVENTS') {\n        event = event.jsonInterface.find(function (intf) {\n            return (intf.signature === data.topics[0]);\n        }) || { anonymous: true };\n    }\n    // create empty inputs if none are present (e.g. anonymous events on allEvents)\n    event.inputs = event.inputs || [];\n    // Handle case where an event signature shadows the current ABI with non-identical\n    // arg indexing. If # of topics doesn't match, event is anon.\n    if (!event.anonymous) {\n        let indexedInputs = 0;\n        event.inputs.forEach(input => input.indexed ? indexedInputs++ : null);\n        if (indexedInputs > 0 && (data.topics.length !== indexedInputs + 1)) {\n            event = {\n                anonymous: true,\n                inputs: []\n            };\n        }\n    }\n    var argTopics = event.anonymous ? data.topics : data.topics.slice(1);\n    result.returnValues = abi.decodeLog(event.inputs, data.data, argTopics);\n    delete result.returnValues.__length__;\n    // add name\n    result.event = event.name;\n    // add signature\n    result.signature = (event.anonymous || !data.topics[0]) ? null : data.topics[0];\n    // move the data and topics to \"raw\"\n    result.raw = {\n        data: result.data,\n        topics: result.topics\n    };\n    delete result.data;\n    delete result.topics;\n    return result;\n};\n/**\n * Encodes an ABI for a method, including signature or the method.\n * Or when constructor encodes only the constructor parameters.\n *\n * @method _encodeMethodABI\n * @param {Mixed} args the arguments to encode\n * @param {String} the encoded ABI\n */\nContract.prototype._encodeMethodABI = function _encodeMethodABI() {\n    var methodSignature = this._method.signature, args = this.arguments || [];\n    var signature = false, paramsABI = this._parent.options.jsonInterface.filter(function (json) {\n        return ((methodSignature === 'constructor' && json.type === methodSignature) ||\n            ((json.signature === methodSignature || json.signature === methodSignature.replace('0x', '') || json.name === methodSignature) && json.type === 'function'));\n    }).map(function (json) {\n        var inputLength = (Array.isArray(json.inputs)) ? json.inputs.length : 0;\n        if (inputLength !== args.length) {\n            throw new Error('The number of arguments is not matching the methods required number. You need to pass ' + inputLength + ' arguments.');\n        }\n        if (json.type === 'function') {\n            signature = json.signature;\n        }\n        return Array.isArray(json.inputs) ? json.inputs : [];\n    }).map(function (inputs) {\n        return abi.encodeParameters(inputs, args).replace('0x', '');\n    })[0] || '';\n    // return constructor\n    if (methodSignature === 'constructor') {\n        if (!this._deployData)\n            throw new Error('The contract has no contract data option set. This is necessary to append the constructor parameters.');\n        if (!this._deployData.startsWith('0x')) {\n            this._deployData = '0x' + this._deployData;\n        }\n        return this._deployData + paramsABI;\n    }\n    // return method\n    var returnValue = (signature) ? signature + paramsABI : paramsABI;\n    if (!returnValue) {\n        throw new Error('Couldn\\'t find a matching contract method named \"' + this._method.name + '\".');\n    }\n    return returnValue;\n};\n/**\n * Decode method return values\n *\n * @method _decodeMethodReturn\n * @param {Array} outputs\n * @param {String} returnValues\n * @return {Object} decoded output return values\n */\nContract.prototype._decodeMethodReturn = function (outputs, returnValues) {\n    if (!returnValues) {\n        return null;\n    }\n    returnValues = returnValues.length >= 2 ? returnValues.slice(2) : returnValues;\n    var result = abi.decodeParameters(outputs, returnValues);\n    if (result.__length__ === 1) {\n        return result[0];\n    }\n    delete result.__length__;\n    return result;\n};\n/**\n * Deploys a contract and fire events based on its state: transactionHash, receipt\n *\n * All event listeners will be removed, once the last possible event is fired (\"error\", or \"receipt\")\n *\n * @method deploy\n * @param {Object} options\n * @param {Function} callback\n * @return {Object} EventEmitter possible events are \"error\", \"transactionHash\" and \"receipt\"\n */\nContract.prototype.deploy = function (options, callback) {\n    options = options || {};\n    options.arguments = options.arguments || [];\n    options = this._getOrSetDefaultOptions(options);\n    // throw error, if no \"data\" is specified\n    if (!options.data) {\n        if (typeof callback === 'function') {\n            return callback(errors.ContractMissingDeployDataError());\n        }\n        throw errors.ContractMissingDeployDataError();\n    }\n    var constructor = this.options.jsonInterface.find((method) => {\n        return (method.type === 'constructor');\n    }) || {};\n    constructor.signature = 'constructor';\n    return this._createTxObject.apply({\n        method: constructor,\n        parent: this,\n        deployData: options.data,\n        _ethAccounts: this.constructor._ethAccounts\n    }, options.arguments);\n};\n/**\n * Gets the event signature and outputFormatters\n *\n * @method _generateEventOptions\n * @param {Object} event\n * @param {Object} options\n * @param {Function} callback\n * @return {Object} the event options object\n */\nContract.prototype._generateEventOptions = function () {\n    var args = Array.prototype.slice.call(arguments);\n    // get the callback\n    var callback = this._getCallback(args);\n    // get the options\n    var options = (!!args[args.length - 1] && typeof args[args.length - 1]) === 'object' ? args.pop() : {};\n    var eventName = (typeof args[0] === 'string') ? args[0] : 'allevents';\n    var event = (eventName.toLowerCase() === 'allevents') ? {\n        name: 'ALLEVENTS',\n        jsonInterface: this.options.jsonInterface\n    } : this.options.jsonInterface.find(function (json) {\n        return (json.type === 'event' && (json.name === eventName || json.signature === '0x' + eventName.replace('0x', '')));\n    });\n    if (!event) {\n        throw errors.ContractEventDoesNotExistError(eventName);\n    }\n    if (!utils.isAddress(this.options.address)) {\n        throw errors.ContractNoAddressDefinedError();\n    }\n    return {\n        params: this._encodeEventABI(event, options),\n        event: event,\n        callback: callback\n    };\n};\n/**\n * Adds event listeners and creates a subscription, and remove it once its fired.\n *\n * @method clone\n * @return {Object} the event subscription\n */\nContract.prototype.clone = function () {\n    return new this.constructor(this.options.jsonInterface, this.options.address, this.options);\n};\n/**\n * Adds event listeners and creates a subscription, and remove it once its fired.\n *\n * @method once\n * @param {String} event\n * @param {Object} options\n * @param {Function} callback\n * @return {Object} the event subscription\n */\nContract.prototype.once = function (event, options, callback) {\n    var args = Array.prototype.slice.call(arguments);\n    // get the callback\n    callback = this._getCallback(args);\n    if (!callback) {\n        throw errors.ContractOnceRequiresCallbackError();\n    }\n    // don't allow fromBlock\n    if (options)\n        delete options.fromBlock;\n    // don't return as once shouldn't provide \"on\"\n    this._on(event, options, function (err, res, sub) {\n        sub.unsubscribe();\n        if (typeof callback === 'function') {\n            callback(err, res, sub);\n        }\n    });\n    return undefined;\n};\n/**\n * Adds event listeners and creates a subscription.\n *\n * @method _on\n *\n * @param {String} event\n * @param {Object} options\n * @param {Function} callback\n *\n * @return {Object} the event subscription\n */\nContract.prototype._on = function () {\n    var subOptions = this._generateEventOptions.apply(this, arguments);\n    if (subOptions.params && subOptions.params.toBlock) {\n        delete subOptions.params.toBlock;\n        console.warn('Invalid option: toBlock. Use getPastEvents for specific range.');\n    }\n    // prevent the event \"newListener\" and \"removeListener\" from being overwritten\n    this._checkListener('newListener', subOptions.event.name);\n    this._checkListener('removeListener', subOptions.event.name);\n    // TODO check if listener already exists? and reuse subscription if options are the same.\n    // create new subscription\n    var subscription = new Subscription({\n        subscription: {\n            params: 1,\n            inputFormatter: [formatters.inputLogFormatter],\n            outputFormatter: this._decodeEventABI.bind(subOptions.event),\n            // DUBLICATE, also in web3-eth\n            subscriptionHandler: function (output) {\n                if (output.removed) {\n                    this.emit('changed', output);\n                }\n                else {\n                    this.emit('data', output);\n                }\n                if (typeof this.callback === 'function') {\n                    this.callback(null, output, this);\n                }\n            }\n        },\n        type: 'eth',\n        requestManager: this._requestManager\n    });\n    subscription.subscribe('logs', subOptions.params, subOptions.callback || function () { });\n    return subscription;\n};\n/**\n * Get past events from contracts\n *\n * @method getPastEvents\n * @param {String} event\n * @param {Object} options\n * @param {Function} callback\n * @return {Object} the promievent\n */\nContract.prototype.getPastEvents = function () {\n    var subOptions = this._generateEventOptions.apply(this, arguments);\n    var getPastLogs = new Method({\n        name: 'getPastLogs',\n        call: 'eth_getLogs',\n        params: 1,\n        inputFormatter: [formatters.inputLogFormatter],\n        outputFormatter: this._decodeEventABI.bind(subOptions.event)\n    });\n    getPastLogs.setRequestManager(this._requestManager);\n    var call = getPastLogs.buildCall();\n    getPastLogs = null;\n    return call(subOptions.params, subOptions.callback);\n};\n/**\n * returns the an object with call, send, estimate functions\n *\n * @method _createTxObject\n * @returns {Object} an object with functions to call the methods\n */\nContract.prototype._createTxObject = function _createTxObject() {\n    var args = Array.prototype.slice.call(arguments);\n    var txObject = {};\n    if (this.method.type === 'function') {\n        txObject.call = this.parent._executeMethod.bind(txObject, 'call');\n        txObject.call.request = this.parent._executeMethod.bind(txObject, 'call', true); // to make batch requests\n    }\n    txObject.send = this.parent._executeMethod.bind(txObject, 'send');\n    txObject.send.request = this.parent._executeMethod.bind(txObject, 'send', true); // to make batch requests\n    txObject.encodeABI = this.parent._encodeMethodABI.bind(txObject);\n    txObject.estimateGas = this.parent._executeMethod.bind(txObject, 'estimate');\n    txObject.createAccessList = this.parent._executeMethod.bind(txObject, 'createAccessList');\n    if (args && this.method.inputs && args.length !== this.method.inputs.length) {\n        if (this.nextMethod) {\n            return this.nextMethod.apply(null, args);\n        }\n        throw errors.InvalidNumberOfParams(args.length, this.method.inputs.length, this.method.name);\n    }\n    txObject.arguments = args || [];\n    txObject._method = this.method;\n    txObject._parent = this.parent;\n    txObject._ethAccounts = this.parent.constructor._ethAccounts || this._ethAccounts;\n    if (this.deployData) {\n        txObject._deployData = this.deployData;\n    }\n    return txObject;\n};\n/**\n * Generates the options for the execute call\n *\n * @method _processExecuteArguments\n * @param {Array} args\n * @param {Promise} defer\n */\nContract.prototype._processExecuteArguments = function _processExecuteArguments(args, defer) {\n    var processedArgs = {};\n    processedArgs.type = args.shift();\n    // get the callback\n    processedArgs.callback = this._parent._getCallback(args);\n    // get block number to use for call\n    if (processedArgs.type === 'call' && args[args.length - 1] !== true && (typeof args[args.length - 1] === 'string' || isFinite(args[args.length - 1])))\n        processedArgs.defaultBlock = args.pop();\n    // get the options\n    processedArgs.options = (!!args[args.length - 1] && typeof args[args.length - 1]) === 'object' ? args.pop() : {};\n    // get the generateRequest argument for batch requests\n    processedArgs.generateRequest = (args[args.length - 1] === true) ? args.pop() : false;\n    processedArgs.options = this._parent._getOrSetDefaultOptions(processedArgs.options);\n    processedArgs.options.data = this.encodeABI();\n    // add contract address\n    if (!this._deployData && !utils.isAddress(this._parent.options.address))\n        throw errors.ContractNoAddressDefinedError();\n    if (!this._deployData)\n        processedArgs.options.to = this._parent.options.address;\n    // return error, if no \"data\" is specified\n    if (!processedArgs.options.data)\n        return utils._fireError(new Error('Couldn\\'t find a matching contract method, or the number of parameters is wrong.'), defer.eventEmitter, defer.reject, processedArgs.callback);\n    return processedArgs;\n};\n/**\n * Executes a call, transact or estimateGas on a contract function\n *\n * @method _executeMethod\n * @param {String} type the type this execute function should execute\n * @param {Boolean} makeRequest if true, it simply returns the request parameters, rather than executing it\n */\nContract.prototype._executeMethod = function _executeMethod() {\n    var _this = this, args = this._parent._processExecuteArguments.call(this, Array.prototype.slice.call(arguments), defer), defer = promiEvent((args.type !== 'send')), ethAccounts = _this.constructor._ethAccounts || _this._ethAccounts;\n    // simple return request for batch requests\n    if (args.generateRequest) {\n        var payload = {\n            params: [formatters.inputCallFormatter.call(this._parent, args.options)],\n            callback: args.callback\n        };\n        if (args.type === 'call') {\n            payload.params.push(formatters.inputDefaultBlockNumberFormatter.call(this._parent, args.defaultBlock));\n            payload.method = 'eth_call';\n            payload.format = this._parent._decodeMethodReturn.bind(null, this._method.outputs);\n        }\n        else {\n            payload.method = 'eth_sendTransaction';\n        }\n        return payload;\n    }\n    switch (args.type) {\n        case 'createAccessList':\n            // return error, if no \"from\" is specified\n            if (!utils.isAddress(args.options.from)) {\n                return utils._fireError(errors.ContractNoFromAddressDefinedError(), defer.eventEmitter, defer.reject, args.callback);\n            }\n            var createAccessList = (new Method({\n                name: 'createAccessList',\n                call: 'eth_createAccessList',\n                params: 2,\n                inputFormatter: [formatters.inputTransactionFormatter, formatters.inputDefaultBlockNumberFormatter],\n                requestManager: _this._parent._requestManager,\n                accounts: ethAccounts,\n                defaultAccount: _this._parent.defaultAccount,\n                defaultBlock: _this._parent.defaultBlock\n            })).createFunction();\n            return createAccessList(args.options, args.callback);\n        case 'estimate':\n            var estimateGas = (new Method({\n                name: 'estimateGas',\n                call: 'eth_estimateGas',\n                params: 1,\n                inputFormatter: [formatters.inputCallFormatter],\n                outputFormatter: utils.hexToNumber,\n                requestManager: _this._parent._requestManager,\n                accounts: ethAccounts,\n                defaultAccount: _this._parent.defaultAccount,\n                defaultBlock: _this._parent.defaultBlock\n            })).createFunction();\n            return estimateGas(args.options, args.callback);\n        case 'call':\n            // TODO check errors: missing \"from\" should give error on deploy and send, call ?\n            var call = (new Method({\n                name: 'call',\n                call: 'eth_call',\n                params: 2,\n                inputFormatter: [formatters.inputCallFormatter, formatters.inputDefaultBlockNumberFormatter],\n                // add output formatter for decoding\n                outputFormatter: function (result) {\n                    return _this._parent._decodeMethodReturn(_this._method.outputs, result);\n                },\n                requestManager: _this._parent._requestManager,\n                accounts: ethAccounts,\n                defaultAccount: _this._parent.defaultAccount,\n                defaultBlock: _this._parent.defaultBlock,\n                handleRevert: _this._parent.handleRevert,\n                abiCoder: abi\n            })).createFunction();\n            return call(args.options, args.defaultBlock, args.callback);\n        case 'send':\n            // return error, if no \"from\" is specified\n            if (!utils.isAddress(args.options.from)) {\n                return utils._fireError(errors.ContractNoFromAddressDefinedError(), defer.eventEmitter, defer.reject, args.callback);\n            }\n            if (typeof this._method.payable === 'boolean' && !this._method.payable && args.options.value && args.options.value > 0) {\n                return utils._fireError(new Error('Can not send value to non-payable contract method or constructor'), defer.eventEmitter, defer.reject, args.callback);\n            }\n            // make sure receipt logs are decoded\n            var extraFormatters = {\n                receiptFormatter: function (receipt) {\n                    if (Array.isArray(receipt.logs)) {\n                        // decode logs\n                        var events = receipt.logs.map((log) => {\n                            return _this._parent._decodeEventABI.call({\n                                name: 'ALLEVENTS',\n                                jsonInterface: _this._parent.options.jsonInterface\n                            }, log);\n                        });\n                        // make log names keys\n                        receipt.events = {};\n                        var count = 0;\n                        events.forEach(function (ev) {\n                            if (ev.event) {\n                                // if > 1 of the same event, don't overwrite any existing events\n                                if (receipt.events[ev.event]) {\n                                    if (Array.isArray(receipt.events[ev.event])) {\n                                        receipt.events[ev.event].push(ev);\n                                    }\n                                    else {\n                                        receipt.events[ev.event] = [receipt.events[ev.event], ev];\n                                    }\n                                }\n                                else {\n                                    receipt.events[ev.event] = ev;\n                                }\n                            }\n                            else {\n                                receipt.events[count] = ev;\n                                count++;\n                            }\n                        });\n                        delete receipt.logs;\n                    }\n                    return receipt;\n                },\n                contractDeployFormatter: function (receipt) {\n                    var newContract = _this._parent.clone();\n                    newContract.options.address = receipt.contractAddress;\n                    return newContract;\n                }\n            };\n            var sendTransaction = (new Method({\n                name: 'sendTransaction',\n                call: 'eth_sendTransaction',\n                params: 1,\n                inputFormatter: [formatters.inputTransactionFormatter],\n                requestManager: _this._parent._requestManager,\n                accounts: _this.constructor._ethAccounts || _this._ethAccounts,\n                defaultAccount: _this._parent.defaultAccount,\n                defaultBlock: _this._parent.defaultBlock,\n                transactionBlockTimeout: _this._parent.transactionBlockTimeout,\n                transactionConfirmationBlocks: _this._parent.transactionConfirmationBlocks,\n                transactionPollingTimeout: _this._parent.transactionPollingTimeout,\n                transactionPollingInterval: _this._parent.transactionPollingInterval,\n                defaultCommon: _this._parent.defaultCommon,\n                defaultChain: _this._parent.defaultChain,\n                defaultHardfork: _this._parent.defaultHardfork,\n                handleRevert: _this._parent.handleRevert,\n                extraFormatters: extraFormatters,\n                abiCoder: abi\n            })).createFunction();\n            return sendTransaction(args.options, args.callback);\n        default:\n            throw new Error('Method \"' + args.type + '\" not implemented.');\n    }\n};\nmodule.exports = Contract;\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n  byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n  var i = offset || 0;\n  var bth = byteToHex;\n  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n  return ([bth[buf[i++]], bth[buf[i++]], \n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]],\n\tbth[buf[i++]], bth[buf[i++]],\n\tbth[buf[i++]], bth[buf[i++]]]).join('');\n}\n\nmodule.exports = bytesToUuid;\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\n// **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\nvar _clockseq;\n\n// Previous uuid creation time\nvar _lastMSecs = 0;\nvar _lastNSecs = 0;\n\n// See https://github.com/broofa/node-uuid for API details\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || [];\n\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;\n\n  // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n  if (node == null || clockseq == null) {\n    var seedBytes = rng();\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [\n        seedBytes[0] | 0x01,\n        seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]\n      ];\n    }\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  }\n\n  // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();\n\n  // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;\n\n  // Time since last uuid creation (in msecs)\n  var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;\n\n  // Per 4.2.1.2, Bump clockseq on clock regression\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  }\n\n  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  }\n\n  // Per 4.2.1.2 Throw error if too many uuids are requested\n  if (nsecs >= 10000) {\n    throw new Error('uuid.v1(): Can\\'t create more than 10M uuids/sec');\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq;\n\n  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n  msecs += 12219292800000;\n\n  // `time_low`\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff;\n\n  // `time_mid`\n  var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff;\n\n  // `time_high_and_version`\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n  b[i++] = tmh >>> 16 & 0xff;\n\n  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n  b[i++] = clockseq >>> 8 | 0x80;\n\n  // `clock_seq_low`\n  b[i++] = clockseq & 0xff;\n\n  // `node`\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf ? buf : bytesToUuid(b);\n}\n\nmodule.exports = v1;\n","/*\n This file is part of web3.js.\n\n web3.js is free software: you can redistribute it and/or modify\n it under the terms of the GNU Lesser General Public License as published by\n the Free Software Foundation, either version 3 of the License, or\n (at your option) any later version.\n\n web3.js is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n GNU Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public License\n along with web3.js.  If not, see <http://www.gnu.org/licenses/>.\n */\n/**\n * @file index.js\n * @author Marek Kotewicz <marek@parity.io>\n * @author Fabian Vogelsteller <fabian@frozeman.de>\n * @date 2018\n */\nvar Buffer = require('buffer').Buffer;\nvar utils = require('web3-utils');\nvar EthersAbiCoder = require('@ethersproject/abi').AbiCoder;\nvar ParamType = require('@ethersproject/abi').ParamType;\nvar ethersAbiCoder = new EthersAbiCoder(function (type, value) {\n    if (type.match(/^u?int/) && !Array.isArray(value) && (!(!!value && typeof value === 'object') || value.constructor.name !== 'BN')) {\n        return value.toString();\n    }\n    return value;\n});\n// result method\nfunction Result() {\n}\n/**\n * ABICoder prototype should be used to encode/decode solidity params of any type\n */\nvar ABICoder = function () {\n};\n/**\n * Encodes the function name to its ABI representation, which are the first 4 bytes of the sha3 of the function name including  types.\n *\n * @method encodeFunctionSignature\n * @param {String|Object} functionName\n * @return {String} encoded function name\n */\nABICoder.prototype.encodeFunctionSignature = function (functionName) {\n    if (typeof functionName === 'function' || typeof functionName === 'object' && functionName) {\n        functionName = utils._jsonInterfaceMethodToString(functionName);\n    }\n    return utils.sha3(functionName).slice(0, 10);\n};\n/**\n * Encodes the function name to its ABI representation, which are the first 4 bytes of the sha3 of the function name including  types.\n *\n * @method encodeEventSignature\n * @param {String|Object} functionName\n * @return {String} encoded function name\n */\nABICoder.prototype.encodeEventSignature = function (functionName) {\n    if (typeof functionName === 'function' || typeof functionName === 'object' && functionName) {\n        functionName = utils._jsonInterfaceMethodToString(functionName);\n    }\n    return utils.sha3(functionName);\n};\n/**\n * Should be used to encode plain param\n *\n * @method encodeParameter\n *\n * @param {String|Object} type\n * @param {any} param\n *\n * @return {String} encoded plain param\n */\nABICoder.prototype.encodeParameter = function (type, param) {\n    return this.encodeParameters([type], [param]);\n};\n/**\n * Should be used to encode list of params\n *\n * @method encodeParameters\n *\n * @param {Array<String|Object>} types\n * @param {Array<any>} params\n *\n * @return {String} encoded list of params\n */\nABICoder.prototype.encodeParameters = function (types, params) {\n    var self = this;\n    types = self.mapTypes(types);\n    params = params.map(function (param, index) {\n        let type = types[index];\n        if (typeof type === 'object' && type.type) {\n            // We may get a named type of shape {name, type}\n            type = type.type;\n        }\n        param = self.formatParam(type, param);\n        // Format params for tuples\n        if (typeof type === 'string' && type.includes('tuple')) {\n            const coder = ethersAbiCoder._getCoder(ParamType.from(type));\n            const modifyParams = (coder, param) => {\n                if (coder.name === 'array') {\n                    return param.map(p => modifyParams(ethersAbiCoder._getCoder(ParamType.from(coder.type.replace('[]', ''))), p));\n                }\n                coder.coders.forEach((c, i) => {\n                    if (c.name === 'tuple') {\n                        modifyParams(c, param[i]);\n                    }\n                    else {\n                        param[i] = self.formatParam(c.name, param[i]);\n                    }\n                });\n            };\n            modifyParams(coder, param);\n        }\n        return param;\n    });\n    return ethersAbiCoder.encode(types, params);\n};\n/**\n * Map types if simplified format is used\n *\n * @method mapTypes\n * @param {Array} types\n * @return {Array}\n */\nABICoder.prototype.mapTypes = function (types) {\n    var self = this;\n    var mappedTypes = [];\n    types.forEach(function (type) {\n        // Remap `function` type params to bytes24 since Ethers does not\n        // recognize former type. Solidity docs say `Function` is a bytes24\n        // encoding the contract address followed by the function selector hash.\n        if (typeof type === 'object' && type.type === 'function') {\n            type = Object.assign({}, type, { type: \"bytes24\" });\n        }\n        if (self.isSimplifiedStructFormat(type)) {\n            var structName = Object.keys(type)[0];\n            mappedTypes.push(Object.assign(self.mapStructNameAndType(structName), {\n                components: self.mapStructToCoderFormat(type[structName])\n            }));\n            return;\n        }\n        mappedTypes.push(type);\n    });\n    return mappedTypes;\n};\n/**\n * Check if type is simplified struct format\n *\n * @method isSimplifiedStructFormat\n * @param {string | Object} type\n * @returns {boolean}\n */\nABICoder.prototype.isSimplifiedStructFormat = function (type) {\n    return typeof type === 'object' && typeof type.components === 'undefined' && typeof type.name === 'undefined';\n};\n/**\n * Maps the correct tuple type and name when the simplified format in encode/decodeParameter is used\n *\n * @method mapStructNameAndType\n * @param {string} structName\n * @return {{type: string, name: *}}\n */\nABICoder.prototype.mapStructNameAndType = function (structName) {\n    var type = 'tuple';\n    if (structName.indexOf('[]') > -1) {\n        type = 'tuple[]';\n        structName = structName.slice(0, -2);\n    }\n    return { type: type, name: structName };\n};\n/**\n * Maps the simplified format in to the expected format of the ABICoder\n *\n * @method mapStructToCoderFormat\n * @param {Object} struct\n * @return {Array}\n */\nABICoder.prototype.mapStructToCoderFormat = function (struct) {\n    var self = this;\n    var components = [];\n    Object.keys(struct).forEach(function (key) {\n        if (typeof struct[key] === 'object') {\n            components.push(Object.assign(self.mapStructNameAndType(key), {\n                components: self.mapStructToCoderFormat(struct[key])\n            }));\n            return;\n        }\n        components.push({\n            name: key,\n            type: struct[key]\n        });\n    });\n    return components;\n};\n/**\n * Handle some formatting of params for backwards compatability with Ethers V4\n *\n * @method formatParam\n * @param {String} - type\n * @param {any} - param\n * @return {any} - The formatted param\n */\nABICoder.prototype.formatParam = function (type, param) {\n    const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\n    const paramTypeBytesArray = new RegExp(/^bytes([0-9]*)\\[\\]$/);\n    const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\n    const paramTypeNumberArray = new RegExp(/^(u?int)([0-9]*)\\[\\]$/);\n    // Format BN to string\n    if (utils.isBN(param) || utils.isBigNumber(param)) {\n        return param.toString(10);\n    }\n    if (type.match(paramTypeBytesArray) || type.match(paramTypeNumberArray)) {\n        return param.map(p => this.formatParam(type.replace('[]', ''), p));\n    }\n    // Format correct width for u?int[0-9]*\n    let match = type.match(paramTypeNumber);\n    if (match) {\n        let size = parseInt(match[2] || \"256\");\n        if (size / 8 < param.length) {\n            // pad to correct bit width\n            param = utils.leftPad(param, size);\n        }\n    }\n    // Format correct length for bytes[0-9]+\n    match = type.match(paramTypeBytes);\n    if (match) {\n        if (Buffer.isBuffer(param)) {\n            param = utils.toHex(param);\n        }\n        // format to correct length\n        let size = parseInt(match[1]);\n        if (size) {\n            let maxSize = size * 2;\n            if (param.substring(0, 2) === '0x') {\n                maxSize += 2;\n            }\n            if (param.length < maxSize) {\n                // pad to correct length\n                param = utils.rightPad(param, size * 2);\n            }\n        }\n        // format odd-length bytes to even-length\n        if (param.length % 2 === 1) {\n            param = '0x0' + param.substring(2);\n        }\n    }\n    return param;\n};\n/**\n * Encodes a function call from its json interface and parameters.\n *\n * @method encodeFunctionCall\n * @param {Array} jsonInterface\n * @param {Array} params\n * @return {String} The encoded ABI for this function call\n */\nABICoder.prototype.encodeFunctionCall = function (jsonInterface, params) {\n    return this.encodeFunctionSignature(jsonInterface) + this.encodeParameters(jsonInterface.inputs, params).replace('0x', '');\n};\n/**\n * Should be used to decode bytes to plain param\n *\n * @method decodeParameter\n * @param {String} type\n * @param {String} bytes\n * @return {Object} plain param\n */\nABICoder.prototype.decodeParameter = function (type, bytes) {\n    return this.decodeParameters([type], bytes)[0];\n};\n/**\n * Should be used to decode list of params\n *\n * @method decodeParameter\n * @param {Array} outputs\n * @param {String} bytes\n * @return {Array} array of plain params\n */\nABICoder.prototype.decodeParameters = function (outputs, bytes) {\n    return this.decodeParametersWith(outputs, bytes, false);\n};\n/**\n * Should be used to decode list of params\n *\n * @method decodeParameter\n * @param {Array} outputs\n * @param {String} bytes\n * @param {Boolean} loose\n * @return {Array} array of plain params\n */\nABICoder.prototype.decodeParametersWith = function (outputs, bytes, loose) {\n    if (outputs.length > 0 && (!bytes || bytes === '0x' || bytes === '0X')) {\n        throw new Error('Returned values aren\\'t valid, did it run Out of Gas? ' +\n            'You might also see this error if you are not using the ' +\n            'correct ABI for the contract you are retrieving data from, ' +\n            'requesting data from a block number that does not exist, ' +\n            'or querying a node which is not fully synced.');\n    }\n    var res = ethersAbiCoder.decode(this.mapTypes(outputs), '0x' + bytes.replace(/0x/i, ''), loose);\n    var returnValue = new Result();\n    returnValue.__length__ = 0;\n    outputs.forEach(function (output, i) {\n        var decodedValue = res[returnValue.__length__];\n        const isStringObject = typeof output === 'object' && output.type && output.type === 'string';\n        const isStringType = typeof output === 'string' && output === 'string';\n        // only convert `0x` to null if it's not string value\n        decodedValue = (decodedValue === '0x' && !isStringObject && !isStringType) ? null : decodedValue;\n        returnValue[i] = decodedValue;\n        if ((typeof output === 'function' || !!output && typeof output === 'object') && output.name) {\n            returnValue[output.name] = decodedValue;\n        }\n        returnValue.__length__++;\n    });\n    return returnValue;\n};\n/**\n * Decodes events non- and indexed parameters.\n *\n * @method decodeLog\n * @param {Object} inputs\n * @param {String} data\n * @param {Array} topics\n * @return {Array} array of plain params\n */\nABICoder.prototype.decodeLog = function (inputs, data, topics) {\n    var _this = this;\n    topics = Array.isArray(topics) ? topics : [topics];\n    data = data || '';\n    var notIndexedInputs = [];\n    var indexedParams = [];\n    var topicCount = 0;\n    // TODO check for anonymous logs?\n    inputs.forEach(function (input, i) {\n        if (input.indexed) {\n            indexedParams[i] = (['bool', 'int', 'uint', 'address', 'fixed', 'ufixed'].find(function (staticType) {\n                return input.type.indexOf(staticType) !== -1;\n            })) ? _this.decodeParameter(input.type, topics[topicCount]) : topics[topicCount];\n            topicCount++;\n        }\n        else {\n            notIndexedInputs[i] = input;\n        }\n    });\n    var nonIndexedData = data;\n    var notIndexedParams = (nonIndexedData) ? this.decodeParametersWith(notIndexedInputs, nonIndexedData, true) : [];\n    var returnValue = new Result();\n    returnValue.__length__ = 0;\n    inputs.forEach(function (res, i) {\n        returnValue[i] = (res.type === 'string') ? '' : null;\n        if (typeof notIndexedParams[i] !== 'undefined') {\n            returnValue[i] = notIndexedParams[i];\n        }\n        if (typeof indexedParams[i] !== 'undefined') {\n            returnValue[i] = indexedParams[i];\n        }\n        if (res.name) {\n            returnValue[res.name] = returnValue[i];\n        }\n        returnValue.__length__++;\n    });\n    return returnValue;\n};\nvar coder = new ABICoder();\nmodule.exports = coder;\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n  var i = buf && offset || 0;\n\n  if (typeof(options) == 'string') {\n    buf = options === 'binary' ? new Array(16) : null;\n    options = null;\n  }\n  options = options || {};\n\n  var rnds = options.random || (options.rng || rng)();\n\n  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n  rnds[6] = (rnds[6] & 0x0f) | 0x40;\n  rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n  // Copy bytes to buffer, if provided\n  if (buf) {\n    for (var ii = 0; ii < 16; ++ii) {\n      buf[i + ii] = rnds[ii];\n    }\n  }\n\n  return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n"],"sourceRoot":""}