{"version":3,"sources":["webpack:///./node_modules/@ethersproject/networks/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/networks/lib.esm/index.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/formatter.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/base-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/json-rpc-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/ws.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/websocket-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/url-json-rpc-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/alchemy-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/ankr-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/cloudflare-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/etherscan-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/fallback-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/ipc-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/infura-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/json-rpc-batch-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/nodesmith-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/pocket-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/web3-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/index.js","webpack:///./node_modules/@ethersproject/pbkdf2/lib.esm/pbkdf2.js","webpack:///./node_modules/@ethersproject/random/lib.esm/shuffle.js","webpack:///./node_modules/@ethersproject/random/lib.esm/random.js","webpack:///./node_modules/@ethersproject/properties/lib.esm/index.js","webpack:///./node_modules/@ethersproject/properties/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/rlp/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/rlp/lib.esm/index.js","webpack:///./node_modules/@ethersproject/random/lib.esm/_version.js"],"names":["ethDefaultProvider","network","func","providers","options","providerList","InfuraProvider","infura","push","error","EtherscanProvider","etherscan","AlchemyProvider","alchemy","PocketProvider","pocket","skip","provider","indexOf","name","CloudflareProvider","cloudflare","AnkrProvider","ankr","length","FallbackProvider","quorum","renetwork","etcDefaultProvider","url","JsonRpcProvider","homestead","chainId","ensAddress","_defaultProvider","ropsten","classicMordor","networks","unspecified","mainnet","morden","testnet","rinkeby","kovan","goerli","kintsugi","classic","classicMorden","classicTestnet","classicKotti","xdai","matic","maticmum","optimism","arbitrum","bnb","bnbt","standard","throwArgumentError","defaultProvider","value","isRenetworkable","constructor","checkNew","this","formats","getDefaultFormats","address","bind","bigNumber","blockTag","data","hash","hex","number","type","transaction","accessList","allowNull","blockHash","blockNumber","transactionIndex","confirmations","from","gasPrice","maxPriorityFeePerGas","maxFeePerGas","gasLimit","to","nonce","r","uint256","s","v","creates","raw","transactionRequest","receiptLog","transactionHash","topics","arrayOf","logIndex","receipt","contractAddress","root","gasUsed","logsBloom","logs","cumulativeGasUsed","effectiveGasPrice","status","block","parentHash","timestamp","difficulty","miner","extraData","transactions","baseFeePerGas","blockWithTransactions","transactionResponse","filter","fromBlock","toBlock","filterLog","removed","boolean","allowFalsish","toNumber","toLowerCase","Error","strict","substring","result","callAddress","_block","format","author","_difficulty","check","gas","isZero","input","networkId","parseInt","replace","byzantium","Array","isArray","map","static","object","key","checkKey","checkValue","nullValue","replaceValue","array","forEach","isCommunityResourcable","isCommunityResource","throttleMessage","showThrottleMessage","console","log","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","next","e","rejected","done","then","apply","checkTopic","topic","serializeTopics","slice","pop","unique","sorted","Object","keys","sort","join","getEventTag","eventName","isForkEvent","warn","getTime","Date","stall","duration","setTimeout","PollableEvents","tag","listener","once","_lastBlockNumber","_inflight","event","split","comps","deserializeTopics","pollable","coinInfos","symbol","p2pkh","p2sh","prefix","ilk","bytes32ify","toHexString","base58Encode","encode","sha2","matcherIpfs","RegExp","matchers","_parseString","start","_parseBytes","offset","getIpfsLink","link","match","numPad","padded","Uint8Array","set","bytesPad","Math","ceil","encodeBytes","datas","byteCount","i","resolvedAddress","formatter","supportsWildcard","_supportsEip2544","call","eq","catch","code","errors","CALL_EXCEPTION","_fetch","selector","parameters","tx","ccipReadEnabled","namehash","parseBytes","throwError","_fetchBytes","_getAddress","coinType","hexBytes","coinInfo","String","UNSUPPORTED_OPERATION","operation","bytes","version","words","toWords","unshift","getAddress","getAvatar","linkage","content","avatar","getText","scheme","owner","_resolvedAddress","addr","tokenId","tokenOwner","balance","toString","metadataUrl","metadata","JSON","stringify","imageUrl","image","getContentHash","ipfs","ipns","swarm","keyBytes","defaultFormatter","nextPollId","super","_events","_emitted","disableCcipRead","getFormatter","anyNetwork","detectNetwork","_networkPromise","_ready","knownNetwork","emit","_maxInternalBlockNumber","_maxFilterBlockRange","_pollingInterval","_fastQueryDate","_network","UNKNOWN_ERROR","ready","NETWORK_ERROR","ccipReadFetch","calldata","urls","sender","errorMessages","href","json","errorPassThrough","response","statusCode","errorMessage","message","SERVER_ERROR","m","_getInternalBlockNumber","maxAge","_internalBlockNumber","internalBlockNumber","respTime","reqTime","checkInternalBlockNumber","perform","networkError","getNetwork","_setFastBlockNumber","poll","pollId","runners","pollingInterval","abs","makeError","previousBlockNumber","eventBlockNumber","runner","getTransactionReceipt","getLogs","all","resetEventsBlock","polling","currentNetwork","_fastBlockNumber","_fastBlockNumberPromise","detectedNetwork","_poller","setInterval","_bootstrapPoll","clearInterval","_getFastBlockNumber","now","getBlockNumber","waitForTransaction","timeout","_waitForTransaction","replaceable","cancelFuncs","alreadyDone","minedHandler","on","removeListener","lastBlockNumber","startBlock","scannedBlock","replaceHandler","getTransactionCount","mined","getTransaction","getBlockWithTransactions","ti","reason","TRANSACTION_REPLACED","cancelled","replacement","_wrapTransaction","timer","TIMEOUT","unref","clearTimeout","getGasPrice","method","getBalance","addressOrName","params","_getBlockTag","getCode","getStorageAt","position","p","expectedHash","returnedHash","wait","confirms","sendTransaction","signedTransaction","hexTx","t","_getTransactionRequest","values","_getFilter","_call","attempt","redirects","txSender","signature","urlsOffset","urlsLength","urlsData","u","callbackSelector","ccipResult","resolved","estimateGas","resolveName","_getBlock","blockHashOrBlockTag","includeTransactions","blockWithTxs","oncePoll","getBlock","getEtherPrice","getResolver","currentName","_getResolver","resolver","addrData","lookupAddress","node","resolverAddr","nameOrAddress","resolverAddress","NOT_IMPLEMENTED","_startEvent","_stopEvent","_addEventListener","args","stopped","eventTag","listenerCount","listeners","off","removeAllListeners","found","errorGas","spelunk","parse","checkError","body","responseText","INSUFFICIENT_FUNDS","NONCE_EXPIRED","REPLACEMENT_UNDERPRICED","UNPREDICTABLE_GAS_LIMIT","getResult","payload","getLowerCase","_constructorGuard","constructorGuard","addressOrIndex","connect","connectUnchecked","UncheckedJsonRpcSigner","_address","_index","send","accounts","sendUncheckedTransaction","fromAddress","estimate","hexlifyTransaction","signTransaction","signMessage","_legacySignMessage","_signTypedData","domain","types","populated","resolveNames","getPayload","unlock","password","allowedTransactionKeys","networkOrReady","freeze","_nextId","_cache","_eventLoopCache","_uncachedDetectNetwork","serverError","getSigner","getUncheckedSigner","listAccounts","a","request","id","jsonrpc","action","cache","connection","prepareRequest","feeData","getFeeData","_startPending","_pendingFilter","self","pendingFilter","filterId","hashes","seq","allowExtra","allowed","WS","WebSocket","logger","NextId","_wsReady","websocket","onopen","_requests","onmessage","messageEvent","callback","sub","_subs","subscription","processFunc","fauxPoll","_websocket","_detectNetwork","rid","_subscribe","param","subIdPromise","_subIds","subId","emitReceipt","destroy","readyState","CONNECTING","onerror","close","_super","create","get","apiKey","checkAbstract","defaultApiKey","host","arguments","allowGzip","throttleCallback","getHost","projectSecret","user","getTransactionPostData","maxFeePerGs","storageKeys","throttleRetry","getJsonResult","checkLogTag","getBaseUrl","getUrl","module","query","reduce","accum","baseUrl","getPostUrl","getPostData","apikey","fetch","post","procFunc","throttleSlotInterval","payloadStr","headers","txhash","postData","topic0","blocks","parseFloat","ethusd","getHistory","endBlock","startblock","endblock","item","timeStamp","checkNetworks","median","maxDelta","middle","floor","b","serialize","isBigNumber","nextRid","cancel","promise","getPromise","ForwardErrors","ForwardProperties","exposeDebugConfig","config","weight","defineProperty","getProcessFunc","normalize","configs","c","_highestBlockNumber","tally","count","normalizedTally","waitForSync","getRunner","currentBlockNumber","providerConfigs","configOrProvider","index","isProvider","stallTimeout","priority","total","results","shuffle","first","t0","inflightWeight","staller","backend","waiting","race","errorCode","props","IpcProvider","defaultProjectId","projectId","apiKeyObj","assertArgument","INVALID_ARGUMENT","argument","_pendingBatch","inflightRequest","_pendingBatchAggregator","batch","inflight","defaultApplicationIds","n","applicationId","loadBalancer","applicationSecretKey","buildWeb3LegacyFetcher","sendFunc","fetcher","path","jsonRpcFetchFunc","subprovider","isMetaMask","buildEip1193Fetcher","sendAsync","getDefaultProvider","NodesmithProvider","Web3Provider","pbkdf2","salt","iterations","keylen","hashAlgorithm","hLen","l","DK","block1","T","U","j","k","destPos","len","shuffled","random","tmp","anyGlobal","window","global","getGlobal","crypto","msCrypto","randomBytes","getRandomValues","buffer","defineReadOnly","enumerable","writable","getStatic","ctor","prototype","getPrototypeOf","resolveProperties","promises","checkProperties","properties","shallowCopy","opaque","bigint","string","_isFrozen","isFrozen","_deepCopy","deepCopy","Description","info","arrayifyInteger","unarrayifyInteger","_encode","child","concat","_decodeChildren","childOffset","decoded","_decode","consumed","BUFFER_OVERRUN","lengthLength","decode"],"mappings":"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","file":"js/chunk-vendors~d6b3b356.fda7c5a4.js","sourcesContent":["export const version = \"networks/5.6.2\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n;\nfunction isRenetworkable(value) {\n    return (value && typeof (value.renetwork) === \"function\");\n}\nfunction ethDefaultProvider(network) {\n    const func = function (providers, options) {\n        if (options == null) {\n            options = {};\n        }\n        const providerList = [];\n        if (providers.InfuraProvider && options.infura !== \"-\") {\n            try {\n                providerList.push(new providers.InfuraProvider(network, options.infura));\n            }\n            catch (error) { }\n        }\n        if (providers.EtherscanProvider && options.etherscan !== \"-\") {\n            try {\n                providerList.push(new providers.EtherscanProvider(network, options.etherscan));\n            }\n            catch (error) { }\n        }\n        if (providers.AlchemyProvider && options.alchemy !== \"-\") {\n            try {\n                providerList.push(new providers.AlchemyProvider(network, options.alchemy));\n            }\n            catch (error) { }\n        }\n        if (providers.PocketProvider && options.pocket !== \"-\") {\n            // These networks are currently faulty on Pocket as their\n            // network does not handle the Berlin hardfork, which is\n            // live on these ones.\n            // @TODO: This goes away once Pocket has upgraded their nodes\n            const skip = [\"goerli\", \"ropsten\", \"rinkeby\"];\n            try {\n                const provider = new providers.PocketProvider(network, options.pocket);\n                if (provider.network && skip.indexOf(provider.network.name) === -1) {\n                    providerList.push(provider);\n                }\n            }\n            catch (error) { }\n        }\n        if (providers.CloudflareProvider && options.cloudflare !== \"-\") {\n            try {\n                providerList.push(new providers.CloudflareProvider(network));\n            }\n            catch (error) { }\n        }\n        if (providers.AnkrProvider && options.ankr !== \"-\") {\n            try {\n                providerList.push(new providers.AnkrProvider(network, options.ankr));\n            }\n            catch (error) { }\n        }\n        if (providerList.length === 0) {\n            return null;\n        }\n        if (providers.FallbackProvider) {\n            let quorum = 1;\n            if (options.quorum != null) {\n                quorum = options.quorum;\n            }\n            else if (network === \"homestead\") {\n                quorum = 2;\n            }\n            return new providers.FallbackProvider(providerList, quorum);\n        }\n        return providerList[0];\n    };\n    func.renetwork = function (network) {\n        return ethDefaultProvider(network);\n    };\n    return func;\n}\nfunction etcDefaultProvider(url, network) {\n    const func = function (providers, options) {\n        if (providers.JsonRpcProvider) {\n            return new providers.JsonRpcProvider(url, network);\n        }\n        return null;\n    };\n    func.renetwork = function (network) {\n        return etcDefaultProvider(url, network);\n    };\n    return func;\n}\nconst homestead = {\n    chainId: 1,\n    ensAddress: \"0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e\",\n    name: \"homestead\",\n    _defaultProvider: ethDefaultProvider(\"homestead\")\n};\nconst ropsten = {\n    chainId: 3,\n    ensAddress: \"0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e\",\n    name: \"ropsten\",\n    _defaultProvider: ethDefaultProvider(\"ropsten\")\n};\nconst classicMordor = {\n    chainId: 63,\n    name: \"classicMordor\",\n    _defaultProvider: etcDefaultProvider(\"https://www.ethercluster.com/mordor\", \"classicMordor\")\n};\n// See: https://chainlist.org\nconst networks = {\n    unspecified: { chainId: 0, name: \"unspecified\" },\n    homestead: homestead,\n    mainnet: homestead,\n    morden: { chainId: 2, name: \"morden\" },\n    ropsten: ropsten,\n    testnet: ropsten,\n    rinkeby: {\n        chainId: 4,\n        ensAddress: \"0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e\",\n        name: \"rinkeby\",\n        _defaultProvider: ethDefaultProvider(\"rinkeby\")\n    },\n    kovan: {\n        chainId: 42,\n        name: \"kovan\",\n        _defaultProvider: ethDefaultProvider(\"kovan\")\n    },\n    goerli: {\n        chainId: 5,\n        ensAddress: \"0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e\",\n        name: \"goerli\",\n        _defaultProvider: ethDefaultProvider(\"goerli\")\n    },\n    kintsugi: { chainId: 1337702, name: \"kintsugi\" },\n    // ETC (See: #351)\n    classic: {\n        chainId: 61,\n        name: \"classic\",\n        _defaultProvider: etcDefaultProvider(\"https:/\\/www.ethercluster.com/etc\", \"classic\")\n    },\n    classicMorden: { chainId: 62, name: \"classicMorden\" },\n    classicMordor: classicMordor,\n    classicTestnet: classicMordor,\n    classicKotti: {\n        chainId: 6,\n        name: \"classicKotti\",\n        _defaultProvider: etcDefaultProvider(\"https:/\\/www.ethercluster.com/kotti\", \"classicKotti\")\n    },\n    xdai: { chainId: 100, name: \"xdai\" },\n    matic: { chainId: 137, name: \"matic\" },\n    maticmum: { chainId: 80001, name: \"maticmum\" },\n    optimism: { chainId: 10, name: \"optimism\" },\n    \"optimism-kovan\": { chainId: 69, name: \"optimism-kovan\" },\n    \"optimism-goerli\": { chainId: 420, name: \"optimism-goerli\" },\n    arbitrum: { chainId: 42161, name: \"arbitrum\" },\n    \"arbitrum-rinkeby\": { chainId: 421611, name: \"arbitrum-rinkeby\" },\n    bnb: { chainId: 56, name: \"bnb\" },\n    bnbt: { chainId: 97, name: \"bnbt\" },\n};\n/**\n *  getNetwork\n *\n *  Converts a named common networks or chain ID (network ID) to a Network\n *  and verifies a network is a valid Network..\n */\nexport function getNetwork(network) {\n    // No network (null)\n    if (network == null) {\n        return null;\n    }\n    if (typeof (network) === \"number\") {\n        for (const name in networks) {\n            const standard = networks[name];\n            if (standard.chainId === network) {\n                return {\n                    name: standard.name,\n                    chainId: standard.chainId,\n                    ensAddress: (standard.ensAddress || null),\n                    _defaultProvider: (standard._defaultProvider || null)\n                };\n            }\n        }\n        return {\n            chainId: network,\n            name: \"unknown\"\n        };\n    }\n    if (typeof (network) === \"string\") {\n        const standard = networks[network];\n        if (standard == null) {\n            return null;\n        }\n        return {\n            name: standard.name,\n            chainId: standard.chainId,\n            ensAddress: standard.ensAddress,\n            _defaultProvider: (standard._defaultProvider || null)\n        };\n    }\n    const standard = networks[network.name];\n    // Not a standard network; check that it is a valid network in general\n    if (!standard) {\n        if (typeof (network.chainId) !== \"number\") {\n            logger.throwArgumentError(\"invalid network chainId\", \"network\", network);\n        }\n        return network;\n    }\n    // Make sure the chainId matches the expected network chainId (or is 0; disable EIP-155)\n    if (network.chainId !== 0 && network.chainId !== standard.chainId) {\n        logger.throwArgumentError(\"network chainId mismatch\", \"network\", network);\n    }\n    // @TODO: In the next major version add an attach function to a defaultProvider\n    // class and move the _defaultProvider internal to this file (extend Network)\n    let defaultProvider = network._defaultProvider || null;\n    if (defaultProvider == null && standard._defaultProvider) {\n        if (isRenetworkable(standard._defaultProvider)) {\n            defaultProvider = standard._defaultProvider.renetwork(network);\n        }\n        else {\n            defaultProvider = standard._defaultProvider;\n        }\n    }\n    // Standard Network (allow overriding the ENS address)\n    return {\n        name: network.name,\n        chainId: standard.chainId,\n        ensAddress: (network.ensAddress || standard.ensAddress || null),\n        _defaultProvider: defaultProvider\n    };\n}\n//# sourceMappingURL=index.js.map","export const version = \"providers/5.6.4\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nimport { getAddress, getContractAddress } from \"@ethersproject/address\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { hexDataLength, hexDataSlice, hexValue, hexZeroPad, isHexString } from \"@ethersproject/bytes\";\nimport { AddressZero } from \"@ethersproject/constants\";\nimport { shallowCopy } from \"@ethersproject/properties\";\nimport { accessListify, parse as parseTransaction } from \"@ethersproject/transactions\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport class Formatter {\n    constructor() {\n        logger.checkNew(new.target, Formatter);\n        this.formats = this.getDefaultFormats();\n    }\n    getDefaultFormats() {\n        const formats = ({});\n        const address = this.address.bind(this);\n        const bigNumber = this.bigNumber.bind(this);\n        const blockTag = this.blockTag.bind(this);\n        const data = this.data.bind(this);\n        const hash = this.hash.bind(this);\n        const hex = this.hex.bind(this);\n        const number = this.number.bind(this);\n        const type = this.type.bind(this);\n        const strictData = (v) => { return this.data(v, true); };\n        formats.transaction = {\n            hash: hash,\n            type: type,\n            accessList: Formatter.allowNull(this.accessList.bind(this), null),\n            blockHash: Formatter.allowNull(hash, null),\n            blockNumber: Formatter.allowNull(number, null),\n            transactionIndex: Formatter.allowNull(number, null),\n            confirmations: Formatter.allowNull(number, null),\n            from: address,\n            // either (gasPrice) or (maxPriorityFeePerGas + maxFeePerGas)\n            // must be set\n            gasPrice: Formatter.allowNull(bigNumber),\n            maxPriorityFeePerGas: Formatter.allowNull(bigNumber),\n            maxFeePerGas: Formatter.allowNull(bigNumber),\n            gasLimit: bigNumber,\n            to: Formatter.allowNull(address, null),\n            value: bigNumber,\n            nonce: number,\n            data: data,\n            r: Formatter.allowNull(this.uint256),\n            s: Formatter.allowNull(this.uint256),\n            v: Formatter.allowNull(number),\n            creates: Formatter.allowNull(address, null),\n            raw: Formatter.allowNull(data),\n        };\n        formats.transactionRequest = {\n            from: Formatter.allowNull(address),\n            nonce: Formatter.allowNull(number),\n            gasLimit: Formatter.allowNull(bigNumber),\n            gasPrice: Formatter.allowNull(bigNumber),\n            maxPriorityFeePerGas: Formatter.allowNull(bigNumber),\n            maxFeePerGas: Formatter.allowNull(bigNumber),\n            to: Formatter.allowNull(address),\n            value: Formatter.allowNull(bigNumber),\n            data: Formatter.allowNull(strictData),\n            type: Formatter.allowNull(number),\n            accessList: Formatter.allowNull(this.accessList.bind(this), null),\n        };\n        formats.receiptLog = {\n            transactionIndex: number,\n            blockNumber: number,\n            transactionHash: hash,\n            address: address,\n            topics: Formatter.arrayOf(hash),\n            data: data,\n            logIndex: number,\n            blockHash: hash,\n        };\n        formats.receipt = {\n            to: Formatter.allowNull(this.address, null),\n            from: Formatter.allowNull(this.address, null),\n            contractAddress: Formatter.allowNull(address, null),\n            transactionIndex: number,\n            // should be allowNull(hash), but broken-EIP-658 support is handled in receipt\n            root: Formatter.allowNull(hex),\n            gasUsed: bigNumber,\n            logsBloom: Formatter.allowNull(data),\n            blockHash: hash,\n            transactionHash: hash,\n            logs: Formatter.arrayOf(this.receiptLog.bind(this)),\n            blockNumber: number,\n            confirmations: Formatter.allowNull(number, null),\n            cumulativeGasUsed: bigNumber,\n            effectiveGasPrice: Formatter.allowNull(bigNumber),\n            status: Formatter.allowNull(number),\n            type: type\n        };\n        formats.block = {\n            hash: Formatter.allowNull(hash),\n            parentHash: hash,\n            number: number,\n            timestamp: number,\n            nonce: Formatter.allowNull(hex),\n            difficulty: this.difficulty.bind(this),\n            gasLimit: bigNumber,\n            gasUsed: bigNumber,\n            miner: Formatter.allowNull(address),\n            extraData: data,\n            transactions: Formatter.allowNull(Formatter.arrayOf(hash)),\n            baseFeePerGas: Formatter.allowNull(bigNumber)\n        };\n        formats.blockWithTransactions = shallowCopy(formats.block);\n        formats.blockWithTransactions.transactions = Formatter.allowNull(Formatter.arrayOf(this.transactionResponse.bind(this)));\n        formats.filter = {\n            fromBlock: Formatter.allowNull(blockTag, undefined),\n            toBlock: Formatter.allowNull(blockTag, undefined),\n            blockHash: Formatter.allowNull(hash, undefined),\n            address: Formatter.allowNull(address, undefined),\n            topics: Formatter.allowNull(this.topics.bind(this), undefined),\n        };\n        formats.filterLog = {\n            blockNumber: Formatter.allowNull(number),\n            blockHash: Formatter.allowNull(hash),\n            transactionIndex: number,\n            removed: Formatter.allowNull(this.boolean.bind(this)),\n            address: address,\n            data: Formatter.allowFalsish(data, \"0x\"),\n            topics: Formatter.arrayOf(hash),\n            transactionHash: hash,\n            logIndex: number,\n        };\n        return formats;\n    }\n    accessList(accessList) {\n        return accessListify(accessList || []);\n    }\n    // Requires a BigNumberish that is within the IEEE754 safe integer range; returns a number\n    // Strict! Used on input.\n    number(number) {\n        if (number === \"0x\") {\n            return 0;\n        }\n        return BigNumber.from(number).toNumber();\n    }\n    type(number) {\n        if (number === \"0x\" || number == null) {\n            return 0;\n        }\n        return BigNumber.from(number).toNumber();\n    }\n    // Strict! Used on input.\n    bigNumber(value) {\n        return BigNumber.from(value);\n    }\n    // Requires a boolean, \"true\" or  \"false\"; returns a boolean\n    boolean(value) {\n        if (typeof (value) === \"boolean\") {\n            return value;\n        }\n        if (typeof (value) === \"string\") {\n            value = value.toLowerCase();\n            if (value === \"true\") {\n                return true;\n            }\n            if (value === \"false\") {\n                return false;\n            }\n        }\n        throw new Error(\"invalid boolean - \" + value);\n    }\n    hex(value, strict) {\n        if (typeof (value) === \"string\") {\n            if (!strict && value.substring(0, 2) !== \"0x\") {\n                value = \"0x\" + value;\n            }\n            if (isHexString(value)) {\n                return value.toLowerCase();\n            }\n        }\n        return logger.throwArgumentError(\"invalid hash\", \"value\", value);\n    }\n    data(value, strict) {\n        const result = this.hex(value, strict);\n        if ((result.length % 2) !== 0) {\n            throw new Error(\"invalid data; odd-length - \" + value);\n        }\n        return result;\n    }\n    // Requires an address\n    // Strict! Used on input.\n    address(value) {\n        return getAddress(value);\n    }\n    callAddress(value) {\n        if (!isHexString(value, 32)) {\n            return null;\n        }\n        const address = getAddress(hexDataSlice(value, 12));\n        return (address === AddressZero) ? null : address;\n    }\n    contractAddress(value) {\n        return getContractAddress(value);\n    }\n    // Strict! Used on input.\n    blockTag(blockTag) {\n        if (blockTag == null) {\n            return \"latest\";\n        }\n        if (blockTag === \"earliest\") {\n            return \"0x0\";\n        }\n        if (blockTag === \"latest\" || blockTag === \"pending\") {\n            return blockTag;\n        }\n        if (typeof (blockTag) === \"number\" || isHexString(blockTag)) {\n            return hexValue(blockTag);\n        }\n        throw new Error(\"invalid blockTag\");\n    }\n    // Requires a hash, optionally requires 0x prefix; returns prefixed lowercase hash.\n    hash(value, strict) {\n        const result = this.hex(value, strict);\n        if (hexDataLength(result) !== 32) {\n            return logger.throwArgumentError(\"invalid hash\", \"value\", value);\n        }\n        return result;\n    }\n    // Returns the difficulty as a number, or if too large (i.e. PoA network) null\n    difficulty(value) {\n        if (value == null) {\n            return null;\n        }\n        const v = BigNumber.from(value);\n        try {\n            return v.toNumber();\n        }\n        catch (error) { }\n        return null;\n    }\n    uint256(value) {\n        if (!isHexString(value)) {\n            throw new Error(\"invalid uint256\");\n        }\n        return hexZeroPad(value, 32);\n    }\n    _block(value, format) {\n        if (value.author != null && value.miner == null) {\n            value.miner = value.author;\n        }\n        // The difficulty may need to come from _difficulty in recursed blocks\n        const difficulty = (value._difficulty != null) ? value._difficulty : value.difficulty;\n        const result = Formatter.check(format, value);\n        result._difficulty = ((difficulty == null) ? null : BigNumber.from(difficulty));\n        return result;\n    }\n    block(value) {\n        return this._block(value, this.formats.block);\n    }\n    blockWithTransactions(value) {\n        return this._block(value, this.formats.blockWithTransactions);\n    }\n    // Strict! Used on input.\n    transactionRequest(value) {\n        return Formatter.check(this.formats.transactionRequest, value);\n    }\n    transactionResponse(transaction) {\n        // Rename gas to gasLimit\n        if (transaction.gas != null && transaction.gasLimit == null) {\n            transaction.gasLimit = transaction.gas;\n        }\n        // Some clients (TestRPC) do strange things like return 0x0 for the\n        // 0 address; correct this to be a real address\n        if (transaction.to && BigNumber.from(transaction.to).isZero()) {\n            transaction.to = \"0x0000000000000000000000000000000000000000\";\n        }\n        // Rename input to data\n        if (transaction.input != null && transaction.data == null) {\n            transaction.data = transaction.input;\n        }\n        // If to and creates are empty, populate the creates from the transaction\n        if (transaction.to == null && transaction.creates == null) {\n            transaction.creates = this.contractAddress(transaction);\n        }\n        if ((transaction.type === 1 || transaction.type === 2) && transaction.accessList == null) {\n            transaction.accessList = [];\n        }\n        const result = Formatter.check(this.formats.transaction, transaction);\n        if (transaction.chainId != null) {\n            let chainId = transaction.chainId;\n            if (isHexString(chainId)) {\n                chainId = BigNumber.from(chainId).toNumber();\n            }\n            result.chainId = chainId;\n        }\n        else {\n            let chainId = transaction.networkId;\n            // geth-etc returns chainId\n            if (chainId == null && result.v == null) {\n                chainId = transaction.chainId;\n            }\n            if (isHexString(chainId)) {\n                chainId = BigNumber.from(chainId).toNumber();\n            }\n            if (typeof (chainId) !== \"number\" && result.v != null) {\n                chainId = (result.v - 35) / 2;\n                if (chainId < 0) {\n                    chainId = 0;\n                }\n                chainId = parseInt(chainId);\n            }\n            if (typeof (chainId) !== \"number\") {\n                chainId = 0;\n            }\n            result.chainId = chainId;\n        }\n        // 0x0000... should actually be null\n        if (result.blockHash && result.blockHash.replace(/0/g, \"\") === \"x\") {\n            result.blockHash = null;\n        }\n        return result;\n    }\n    transaction(value) {\n        return parseTransaction(value);\n    }\n    receiptLog(value) {\n        return Formatter.check(this.formats.receiptLog, value);\n    }\n    receipt(value) {\n        const result = Formatter.check(this.formats.receipt, value);\n        // RSK incorrectly implemented EIP-658, so we munge things a bit here for it\n        if (result.root != null) {\n            if (result.root.length <= 4) {\n                // Could be 0x00, 0x0, 0x01 or 0x1\n                const value = BigNumber.from(result.root).toNumber();\n                if (value === 0 || value === 1) {\n                    // Make sure if both are specified, they match\n                    if (result.status != null && (result.status !== value)) {\n                        logger.throwArgumentError(\"alt-root-status/status mismatch\", \"value\", { root: result.root, status: result.status });\n                    }\n                    result.status = value;\n                    delete result.root;\n                }\n                else {\n                    logger.throwArgumentError(\"invalid alt-root-status\", \"value.root\", result.root);\n                }\n            }\n            else if (result.root.length !== 66) {\n                // Must be a valid bytes32\n                logger.throwArgumentError(\"invalid root hash\", \"value.root\", result.root);\n            }\n        }\n        if (result.status != null) {\n            result.byzantium = true;\n        }\n        return result;\n    }\n    topics(value) {\n        if (Array.isArray(value)) {\n            return value.map((v) => this.topics(v));\n        }\n        else if (value != null) {\n            return this.hash(value, true);\n        }\n        return null;\n    }\n    filter(value) {\n        return Formatter.check(this.formats.filter, value);\n    }\n    filterLog(value) {\n        return Formatter.check(this.formats.filterLog, value);\n    }\n    static check(format, object) {\n        const result = {};\n        for (const key in format) {\n            try {\n                const value = format[key](object[key]);\n                if (value !== undefined) {\n                    result[key] = value;\n                }\n            }\n            catch (error) {\n                error.checkKey = key;\n                error.checkValue = object[key];\n                throw error;\n            }\n        }\n        return result;\n    }\n    // if value is null-ish, nullValue is returned\n    static allowNull(format, nullValue) {\n        return (function (value) {\n            if (value == null) {\n                return nullValue;\n            }\n            return format(value);\n        });\n    }\n    // If value is false-ish, replaceValue is returned\n    static allowFalsish(format, replaceValue) {\n        return (function (value) {\n            if (!value) {\n                return replaceValue;\n            }\n            return format(value);\n        });\n    }\n    // Requires an Array satisfying check\n    static arrayOf(format) {\n        return (function (array) {\n            if (!Array.isArray(array)) {\n                throw new Error(\"not an array\");\n            }\n            const result = [];\n            array.forEach(function (value) {\n                result.push(format(value));\n            });\n            return result;\n        });\n    }\n}\nexport function isCommunityResourcable(value) {\n    return (value && typeof (value.isCommunityResource) === \"function\");\n}\nexport function isCommunityResource(value) {\n    return (isCommunityResourcable(value) && value.isCommunityResource());\n}\n// Show the throttle message only once\nlet throttleMessage = false;\nexport function showThrottleMessage() {\n    if (throttleMessage) {\n        return;\n    }\n    throttleMessage = true;\n    console.log(\"========= NOTICE =========\");\n    console.log(\"Request-Rate Exceeded  (this message will not be repeated)\");\n    console.log(\"\");\n    console.log(\"The default API keys for each service are provided as a highly-throttled,\");\n    console.log(\"community resource for low-traffic projects and early prototyping.\");\n    console.log(\"\");\n    console.log(\"While your application will continue to function, we highly recommended\");\n    console.log(\"signing up for your own API keys to improve performance, increase your\");\n    console.log(\"request rate/limit and enable other perks, such as metrics and advanced APIs.\");\n    console.log(\"\");\n    console.log(\"For more details: https:/\\/docs.ethers.io/api-keys/\");\n    console.log(\"==========================\");\n}\n//# sourceMappingURL=formatter.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { ForkEvent, Provider } from \"@ethersproject/abstract-provider\";\nimport { Base58 } from \"@ethersproject/basex\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { arrayify, concat, hexConcat, hexDataLength, hexDataSlice, hexlify, hexValue, hexZeroPad, isHexString } from \"@ethersproject/bytes\";\nimport { HashZero } from \"@ethersproject/constants\";\nimport { dnsEncode, namehash } from \"@ethersproject/hash\";\nimport { getNetwork } from \"@ethersproject/networks\";\nimport { defineReadOnly, getStatic, resolveProperties } from \"@ethersproject/properties\";\nimport { sha256 } from \"@ethersproject/sha2\";\nimport { toUtf8Bytes, toUtf8String } from \"@ethersproject/strings\";\nimport { fetchJson, poll } from \"@ethersproject/web\";\nimport bech32 from \"bech32\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { Formatter } from \"./formatter\";\nconst MAX_CCIP_REDIRECTS = 10;\n//////////////////////////////\n// Event Serializeing\nfunction checkTopic(topic) {\n    if (topic == null) {\n        return \"null\";\n    }\n    if (hexDataLength(topic) !== 32) {\n        logger.throwArgumentError(\"invalid topic\", \"topic\", topic);\n    }\n    return topic.toLowerCase();\n}\nfunction serializeTopics(topics) {\n    // Remove trailing null AND-topics; they are redundant\n    topics = topics.slice();\n    while (topics.length > 0 && topics[topics.length - 1] == null) {\n        topics.pop();\n    }\n    return topics.map((topic) => {\n        if (Array.isArray(topic)) {\n            // Only track unique OR-topics\n            const unique = {};\n            topic.forEach((topic) => {\n                unique[checkTopic(topic)] = true;\n            });\n            // The order of OR-topics does not matter\n            const sorted = Object.keys(unique);\n            sorted.sort();\n            return sorted.join(\"|\");\n        }\n        else {\n            return checkTopic(topic);\n        }\n    }).join(\"&\");\n}\nfunction deserializeTopics(data) {\n    if (data === \"\") {\n        return [];\n    }\n    return data.split(/&/g).map((topic) => {\n        if (topic === \"\") {\n            return [];\n        }\n        const comps = topic.split(\"|\").map((topic) => {\n            return ((topic === \"null\") ? null : topic);\n        });\n        return ((comps.length === 1) ? comps[0] : comps);\n    });\n}\nfunction getEventTag(eventName) {\n    if (typeof (eventName) === \"string\") {\n        eventName = eventName.toLowerCase();\n        if (hexDataLength(eventName) === 32) {\n            return \"tx:\" + eventName;\n        }\n        if (eventName.indexOf(\":\") === -1) {\n            return eventName;\n        }\n    }\n    else if (Array.isArray(eventName)) {\n        return \"filter:*:\" + serializeTopics(eventName);\n    }\n    else if (ForkEvent.isForkEvent(eventName)) {\n        logger.warn(\"not implemented\");\n        throw new Error(\"not implemented\");\n    }\n    else if (eventName && typeof (eventName) === \"object\") {\n        return \"filter:\" + (eventName.address || \"*\") + \":\" + serializeTopics(eventName.topics || []);\n    }\n    throw new Error(\"invalid event - \" + eventName);\n}\n//////////////////////////////\n// Helper Object\nfunction getTime() {\n    return (new Date()).getTime();\n}\nfunction stall(duration) {\n    return new Promise((resolve) => {\n        setTimeout(resolve, duration);\n    });\n}\n//////////////////////////////\n// Provider Object\n/**\n *  EventType\n *   - \"block\"\n *   - \"poll\"\n *   - \"didPoll\"\n *   - \"pending\"\n *   - \"error\"\n *   - \"network\"\n *   - filter\n *   - topics array\n *   - transaction hash\n */\nconst PollableEvents = [\"block\", \"network\", \"pending\", \"poll\"];\nexport class Event {\n    constructor(tag, listener, once) {\n        defineReadOnly(this, \"tag\", tag);\n        defineReadOnly(this, \"listener\", listener);\n        defineReadOnly(this, \"once\", once);\n        this._lastBlockNumber = -2;\n        this._inflight = false;\n    }\n    get event() {\n        switch (this.type) {\n            case \"tx\":\n                return this.hash;\n            case \"filter\":\n                return this.filter;\n        }\n        return this.tag;\n    }\n    get type() {\n        return this.tag.split(\":\")[0];\n    }\n    get hash() {\n        const comps = this.tag.split(\":\");\n        if (comps[0] !== \"tx\") {\n            return null;\n        }\n        return comps[1];\n    }\n    get filter() {\n        const comps = this.tag.split(\":\");\n        if (comps[0] !== \"filter\") {\n            return null;\n        }\n        const address = comps[1];\n        const topics = deserializeTopics(comps[2]);\n        const filter = {};\n        if (topics.length > 0) {\n            filter.topics = topics;\n        }\n        if (address && address !== \"*\") {\n            filter.address = address;\n        }\n        return filter;\n    }\n    pollable() {\n        return (this.tag.indexOf(\":\") >= 0 || PollableEvents.indexOf(this.tag) >= 0);\n    }\n}\n;\n// https://github.com/satoshilabs/slips/blob/master/slip-0044.md\nconst coinInfos = {\n    \"0\": { symbol: \"btc\", p2pkh: 0x00, p2sh: 0x05, prefix: \"bc\" },\n    \"2\": { symbol: \"ltc\", p2pkh: 0x30, p2sh: 0x32, prefix: \"ltc\" },\n    \"3\": { symbol: \"doge\", p2pkh: 0x1e, p2sh: 0x16 },\n    \"60\": { symbol: \"eth\", ilk: \"eth\" },\n    \"61\": { symbol: \"etc\", ilk: \"eth\" },\n    \"700\": { symbol: \"xdai\", ilk: \"eth\" },\n};\nfunction bytes32ify(value) {\n    return hexZeroPad(BigNumber.from(value).toHexString(), 32);\n}\n// Compute the Base58Check encoded data (checksum is first 4 bytes of sha256d)\nfunction base58Encode(data) {\n    return Base58.encode(concat([data, hexDataSlice(sha256(sha256(data)), 0, 4)]));\n}\nconst matcherIpfs = new RegExp(\"^(ipfs):/\\/(.*)$\", \"i\");\nconst matchers = [\n    new RegExp(\"^(https):/\\/(.*)$\", \"i\"),\n    new RegExp(\"^(data):(.*)$\", \"i\"),\n    matcherIpfs,\n    new RegExp(\"^eip155:[0-9]+/(erc[0-9]+):(.*)$\", \"i\"),\n];\nfunction _parseString(result, start) {\n    try {\n        return toUtf8String(_parseBytes(result, start));\n    }\n    catch (error) { }\n    return null;\n}\nfunction _parseBytes(result, start) {\n    if (result === \"0x\") {\n        return null;\n    }\n    const offset = BigNumber.from(hexDataSlice(result, start, start + 32)).toNumber();\n    const length = BigNumber.from(hexDataSlice(result, offset, offset + 32)).toNumber();\n    return hexDataSlice(result, offset + 32, offset + 32 + length);\n}\n// Trim off the ipfs:// prefix and return the default gateway URL\nfunction getIpfsLink(link) {\n    if (link.match(/^ipfs:\\/\\/ipfs\\//i)) {\n        link = link.substring(12);\n    }\n    else if (link.match(/^ipfs:\\/\\//i)) {\n        link = link.substring(7);\n    }\n    else {\n        logger.throwArgumentError(\"unsupported IPFS format\", \"link\", link);\n    }\n    return `https:/\\/gateway.ipfs.io/ipfs/${link}`;\n}\nfunction numPad(value) {\n    const result = arrayify(value);\n    if (result.length > 32) {\n        throw new Error(\"internal; should not happen\");\n    }\n    const padded = new Uint8Array(32);\n    padded.set(result, 32 - result.length);\n    return padded;\n}\nfunction bytesPad(value) {\n    if ((value.length % 32) === 0) {\n        return value;\n    }\n    const result = new Uint8Array(Math.ceil(value.length / 32) * 32);\n    result.set(value);\n    return result;\n}\n// ABI Encodes a series of (bytes, bytes, ...)\nfunction encodeBytes(datas) {\n    const result = [];\n    let byteCount = 0;\n    // Add place-holders for pointers as we add items\n    for (let i = 0; i < datas.length; i++) {\n        result.push(null);\n        byteCount += 32;\n    }\n    for (let i = 0; i < datas.length; i++) {\n        const data = arrayify(datas[i]);\n        // Update the bytes offset\n        result[i] = numPad(byteCount);\n        // The length and padded value of data\n        result.push(numPad(data.length));\n        result.push(bytesPad(data));\n        byteCount += 32 + Math.ceil(data.length / 32) * 32;\n    }\n    return hexConcat(result);\n}\nexport class Resolver {\n    // The resolvedAddress is only for creating a ReverseLookup resolver\n    constructor(provider, address, name, resolvedAddress) {\n        defineReadOnly(this, \"provider\", provider);\n        defineReadOnly(this, \"name\", name);\n        defineReadOnly(this, \"address\", provider.formatter.address(address));\n        defineReadOnly(this, \"_resolvedAddress\", resolvedAddress);\n    }\n    supportsWildcard() {\n        if (!this._supportsEip2544) {\n            // supportsInterface(bytes4 = selector(\"resolve(bytes,bytes)\"))\n            this._supportsEip2544 = this.provider.call({\n                to: this.address,\n                data: \"0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000\"\n            }).then((result) => {\n                return BigNumber.from(result).eq(1);\n            }).catch((error) => {\n                if (error.code === Logger.errors.CALL_EXCEPTION) {\n                    return false;\n                }\n                // Rethrow the error: link is down, etc. Let future attempts retry.\n                this._supportsEip2544 = null;\n                throw error;\n            });\n        }\n        return this._supportsEip2544;\n    }\n    _fetch(selector, parameters) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // e.g. keccak256(\"addr(bytes32,uint256)\")\n            const tx = {\n                to: this.address,\n                ccipReadEnabled: true,\n                data: hexConcat([selector, namehash(this.name), (parameters || \"0x\")])\n            };\n            // Wildcard support; use EIP-2544 to resolve the request\n            let parseBytes = false;\n            if (yield this.supportsWildcard()) {\n                parseBytes = true;\n                // selector(\"resolve(bytes,bytes)\")\n                tx.data = hexConcat([\"0x9061b923\", encodeBytes([dnsEncode(this.name), tx.data])]);\n            }\n            try {\n                let result = yield this.provider.call(tx);\n                if ((arrayify(result).length % 32) === 4) {\n                    logger.throwError(\"resolver threw error\", Logger.errors.CALL_EXCEPTION, {\n                        transaction: tx, data: result\n                    });\n                }\n                if (parseBytes) {\n                    result = _parseBytes(result, 0);\n                }\n                return result;\n            }\n            catch (error) {\n                if (error.code === Logger.errors.CALL_EXCEPTION) {\n                    return null;\n                }\n                throw error;\n            }\n        });\n    }\n    _fetchBytes(selector, parameters) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const result = yield this._fetch(selector, parameters);\n            if (result != null) {\n                return _parseBytes(result, 0);\n            }\n            return null;\n        });\n    }\n    _getAddress(coinType, hexBytes) {\n        const coinInfo = coinInfos[String(coinType)];\n        if (coinInfo == null) {\n            logger.throwError(`unsupported coin type: ${coinType}`, Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: `getAddress(${coinType})`\n            });\n        }\n        if (coinInfo.ilk === \"eth\") {\n            return this.provider.formatter.address(hexBytes);\n        }\n        const bytes = arrayify(hexBytes);\n        // P2PKH: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG\n        if (coinInfo.p2pkh != null) {\n            const p2pkh = hexBytes.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);\n            if (p2pkh) {\n                const length = parseInt(p2pkh[1], 16);\n                if (p2pkh[2].length === length * 2 && length >= 1 && length <= 75) {\n                    return base58Encode(concat([[coinInfo.p2pkh], (\"0x\" + p2pkh[2])]));\n                }\n            }\n        }\n        // P2SH: OP_HASH160 <scriptHash> OP_EQUAL\n        if (coinInfo.p2sh != null) {\n            const p2sh = hexBytes.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/);\n            if (p2sh) {\n                const length = parseInt(p2sh[1], 16);\n                if (p2sh[2].length === length * 2 && length >= 1 && length <= 75) {\n                    return base58Encode(concat([[coinInfo.p2sh], (\"0x\" + p2sh[2])]));\n                }\n            }\n        }\n        // Bech32\n        if (coinInfo.prefix != null) {\n            const length = bytes[1];\n            // https://github.com/bitcoin/bips/blob/master/bip-0141.mediawiki#witness-program\n            let version = bytes[0];\n            if (version === 0x00) {\n                if (length !== 20 && length !== 32) {\n                    version = -1;\n                }\n            }\n            else {\n                version = -1;\n            }\n            if (version >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {\n                const words = bech32.toWords(bytes.slice(2));\n                words.unshift(version);\n                return bech32.encode(coinInfo.prefix, words);\n            }\n        }\n        return null;\n    }\n    getAddress(coinType) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (coinType == null) {\n                coinType = 60;\n            }\n            // If Ethereum, use the standard `addr(bytes32)`\n            if (coinType === 60) {\n                try {\n                    // keccak256(\"addr(bytes32)\")\n                    const result = yield this._fetch(\"0x3b3b57de\");\n                    // No address\n                    if (result === \"0x\" || result === HashZero) {\n                        return null;\n                    }\n                    return this.provider.formatter.callAddress(result);\n                }\n                catch (error) {\n                    if (error.code === Logger.errors.CALL_EXCEPTION) {\n                        return null;\n                    }\n                    throw error;\n                }\n            }\n            // keccak256(\"addr(bytes32,uint256\")\n            const hexBytes = yield this._fetchBytes(\"0xf1cb7e06\", bytes32ify(coinType));\n            // No address\n            if (hexBytes == null || hexBytes === \"0x\") {\n                return null;\n            }\n            // Compute the address\n            const address = this._getAddress(coinType, hexBytes);\n            if (address == null) {\n                logger.throwError(`invalid or unsupported coin data`, Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: `getAddress(${coinType})`,\n                    coinType: coinType,\n                    data: hexBytes\n                });\n            }\n            return address;\n        });\n    }\n    getAvatar() {\n        return __awaiter(this, void 0, void 0, function* () {\n            const linkage = [{ type: \"name\", content: this.name }];\n            try {\n                // test data for ricmoo.eth\n                //const avatar = \"eip155:1/erc721:0x265385c7f4132228A0d54EB1A9e7460b91c0cC68/29233\";\n                const avatar = yield this.getText(\"avatar\");\n                if (avatar == null) {\n                    return null;\n                }\n                for (let i = 0; i < matchers.length; i++) {\n                    const match = avatar.match(matchers[i]);\n                    if (match == null) {\n                        continue;\n                    }\n                    const scheme = match[1].toLowerCase();\n                    switch (scheme) {\n                        case \"https\":\n                            linkage.push({ type: \"url\", content: avatar });\n                            return { linkage, url: avatar };\n                        case \"data\":\n                            linkage.push({ type: \"data\", content: avatar });\n                            return { linkage, url: avatar };\n                        case \"ipfs\":\n                            linkage.push({ type: \"ipfs\", content: avatar });\n                            return { linkage, url: getIpfsLink(avatar) };\n                        case \"erc721\":\n                        case \"erc1155\": {\n                            // Depending on the ERC type, use tokenURI(uint256) or url(uint256)\n                            const selector = (scheme === \"erc721\") ? \"0xc87b56dd\" : \"0x0e89341c\";\n                            linkage.push({ type: scheme, content: avatar });\n                            // The owner of this name\n                            const owner = (this._resolvedAddress || (yield this.getAddress()));\n                            const comps = (match[2] || \"\").split(\"/\");\n                            if (comps.length !== 2) {\n                                return null;\n                            }\n                            const addr = yield this.provider.formatter.address(comps[0]);\n                            const tokenId = hexZeroPad(BigNumber.from(comps[1]).toHexString(), 32);\n                            // Check that this account owns the token\n                            if (scheme === \"erc721\") {\n                                // ownerOf(uint256 tokenId)\n                                const tokenOwner = this.provider.formatter.callAddress(yield this.provider.call({\n                                    to: addr, data: hexConcat([\"0x6352211e\", tokenId])\n                                }));\n                                if (owner !== tokenOwner) {\n                                    return null;\n                                }\n                                linkage.push({ type: \"owner\", content: tokenOwner });\n                            }\n                            else if (scheme === \"erc1155\") {\n                                // balanceOf(address owner, uint256 tokenId)\n                                const balance = BigNumber.from(yield this.provider.call({\n                                    to: addr, data: hexConcat([\"0x00fdd58e\", hexZeroPad(owner, 32), tokenId])\n                                }));\n                                if (balance.isZero()) {\n                                    return null;\n                                }\n                                linkage.push({ type: \"balance\", content: balance.toString() });\n                            }\n                            // Call the token contract for the metadata URL\n                            const tx = {\n                                to: this.provider.formatter.address(comps[0]),\n                                data: hexConcat([selector, tokenId])\n                            };\n                            let metadataUrl = _parseString(yield this.provider.call(tx), 0);\n                            if (metadataUrl == null) {\n                                return null;\n                            }\n                            linkage.push({ type: \"metadata-url-base\", content: metadataUrl });\n                            // ERC-1155 allows a generic {id} in the URL\n                            if (scheme === \"erc1155\") {\n                                metadataUrl = metadataUrl.replace(\"{id}\", tokenId.substring(2));\n                                linkage.push({ type: \"metadata-url-expanded\", content: metadataUrl });\n                            }\n                            // Transform IPFS metadata links\n                            if (metadataUrl.match(/^ipfs:/i)) {\n                                metadataUrl = getIpfsLink(metadataUrl);\n                            }\n                            linkage.push({ type: \"metadata-url\", content: metadataUrl });\n                            // Get the token metadata\n                            const metadata = yield fetchJson(metadataUrl);\n                            if (!metadata) {\n                                return null;\n                            }\n                            linkage.push({ type: \"metadata\", content: JSON.stringify(metadata) });\n                            // Pull the image URL out\n                            let imageUrl = metadata.image;\n                            if (typeof (imageUrl) !== \"string\") {\n                                return null;\n                            }\n                            if (imageUrl.match(/^(https:\\/\\/|data:)/i)) {\n                                // Allow\n                            }\n                            else {\n                                // Transform IPFS link to gateway\n                                const ipfs = imageUrl.match(matcherIpfs);\n                                if (ipfs == null) {\n                                    return null;\n                                }\n                                linkage.push({ type: \"url-ipfs\", content: imageUrl });\n                                imageUrl = getIpfsLink(imageUrl);\n                            }\n                            linkage.push({ type: \"url\", content: imageUrl });\n                            return { linkage, url: imageUrl };\n                        }\n                    }\n                }\n            }\n            catch (error) { }\n            return null;\n        });\n    }\n    getContentHash() {\n        return __awaiter(this, void 0, void 0, function* () {\n            // keccak256(\"contenthash()\")\n            const hexBytes = yield this._fetchBytes(\"0xbc1c58d1\");\n            // No contenthash\n            if (hexBytes == null || hexBytes === \"0x\") {\n                return null;\n            }\n            // IPFS (CID: 1, Type: DAG-PB)\n            const ipfs = hexBytes.match(/^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);\n            if (ipfs) {\n                const length = parseInt(ipfs[3], 16);\n                if (ipfs[4].length === length * 2) {\n                    return \"ipfs:/\\/\" + Base58.encode(\"0x\" + ipfs[1]);\n                }\n            }\n            // IPNS (CID: 1, Type: libp2p-key)\n            const ipns = hexBytes.match(/^0xe5010172(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);\n            if (ipns) {\n                const length = parseInt(ipns[3], 16);\n                if (ipns[4].length === length * 2) {\n                    return \"ipns:/\\/\" + Base58.encode(\"0x\" + ipns[1]);\n                }\n            }\n            // Swarm (CID: 1, Type: swarm-manifest; hash/length hard-coded to keccak256/32)\n            const swarm = hexBytes.match(/^0xe40101fa011b20([0-9a-f]*)$/);\n            if (swarm) {\n                if (swarm[1].length === (32 * 2)) {\n                    return \"bzz:/\\/\" + swarm[1];\n                }\n            }\n            return logger.throwError(`invalid or unsupported content hash data`, Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"getContentHash()\",\n                data: hexBytes\n            });\n        });\n    }\n    getText(key) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // The key encoded as parameter to fetchBytes\n            let keyBytes = toUtf8Bytes(key);\n            // The nodehash consumes the first slot, so the string pointer targets\n            // offset 64, with the length at offset 64 and data starting at offset 96\n            keyBytes = concat([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);\n            // Pad to word-size (32 bytes)\n            if ((keyBytes.length % 32) !== 0) {\n                keyBytes = concat([keyBytes, hexZeroPad(\"0x\", 32 - (key.length % 32))]);\n            }\n            const hexBytes = yield this._fetchBytes(\"0x59d1d43c\", hexlify(keyBytes));\n            if (hexBytes == null || hexBytes === \"0x\") {\n                return null;\n            }\n            return toUtf8String(hexBytes);\n        });\n    }\n}\nlet defaultFormatter = null;\nlet nextPollId = 1;\nexport class BaseProvider extends Provider {\n    /**\n     *  ready\n     *\n     *  A Promise<Network> that resolves only once the provider is ready.\n     *\n     *  Sub-classes that call the super with a network without a chainId\n     *  MUST set this. Standard named networks have a known chainId.\n     *\n     */\n    constructor(network) {\n        logger.checkNew(new.target, Provider);\n        super();\n        // Events being listened to\n        this._events = [];\n        this._emitted = { block: -2 };\n        this.disableCcipRead = false;\n        this.formatter = new.target.getFormatter();\n        // If network is any, this Provider allows the underlying\n        // network to change dynamically, and we auto-detect the\n        // current network\n        defineReadOnly(this, \"anyNetwork\", (network === \"any\"));\n        if (this.anyNetwork) {\n            network = this.detectNetwork();\n        }\n        if (network instanceof Promise) {\n            this._networkPromise = network;\n            // Squash any \"unhandled promise\" errors; that do not need to be handled\n            network.catch((error) => { });\n            // Trigger initial network setting (async)\n            this._ready().catch((error) => { });\n        }\n        else {\n            const knownNetwork = getStatic(new.target, \"getNetwork\")(network);\n            if (knownNetwork) {\n                defineReadOnly(this, \"_network\", knownNetwork);\n                this.emit(\"network\", knownNetwork, null);\n            }\n            else {\n                logger.throwArgumentError(\"invalid network\", \"network\", network);\n            }\n        }\n        this._maxInternalBlockNumber = -1024;\n        this._lastBlockNumber = -2;\n        this._maxFilterBlockRange = 10;\n        this._pollingInterval = 4000;\n        this._fastQueryDate = 0;\n    }\n    _ready() {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (this._network == null) {\n                let network = null;\n                if (this._networkPromise) {\n                    try {\n                        network = yield this._networkPromise;\n                    }\n                    catch (error) { }\n                }\n                // Try the Provider's network detection (this MUST throw if it cannot)\n                if (network == null) {\n                    network = yield this.detectNetwork();\n                }\n                // This should never happen; every Provider sub-class should have\n                // suggested a network by here (or have thrown).\n                if (!network) {\n                    logger.throwError(\"no network detected\", Logger.errors.UNKNOWN_ERROR, {});\n                }\n                // Possible this call stacked so do not call defineReadOnly again\n                if (this._network == null) {\n                    if (this.anyNetwork) {\n                        this._network = network;\n                    }\n                    else {\n                        defineReadOnly(this, \"_network\", network);\n                    }\n                    this.emit(\"network\", network, null);\n                }\n            }\n            return this._network;\n        });\n    }\n    // This will always return the most recently established network.\n    // For \"any\", this can change (a \"network\" event is emitted before\n    // any change is reflected); otherwise this cannot change\n    get ready() {\n        return poll(() => {\n            return this._ready().then((network) => {\n                return network;\n            }, (error) => {\n                // If the network isn't running yet, we will wait\n                if (error.code === Logger.errors.NETWORK_ERROR && error.event === \"noNetwork\") {\n                    return undefined;\n                }\n                throw error;\n            });\n        });\n    }\n    // @TODO: Remove this and just create a singleton formatter\n    static getFormatter() {\n        if (defaultFormatter == null) {\n            defaultFormatter = new Formatter();\n        }\n        return defaultFormatter;\n    }\n    // @TODO: Remove this and just use getNetwork\n    static getNetwork(network) {\n        return getNetwork((network == null) ? \"homestead\" : network);\n    }\n    ccipReadFetch(tx, calldata, urls) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (this.disableCcipRead || urls.length === 0) {\n                return null;\n            }\n            const sender = tx.to.toLowerCase();\n            const data = calldata.toLowerCase();\n            const errorMessages = [];\n            for (let i = 0; i < urls.length; i++) {\n                const url = urls[i];\n                // URL expansion\n                const href = url.replace(\"{sender}\", sender).replace(\"{data}\", data);\n                // If no {data} is present, use POST; otherwise GET\n                const json = (url.indexOf(\"{data}\") >= 0) ? null : JSON.stringify({ data, sender });\n                const result = yield fetchJson({ url: href, errorPassThrough: true }, json, (value, response) => {\n                    value.status = response.statusCode;\n                    return value;\n                });\n                if (result.data) {\n                    return result.data;\n                }\n                const errorMessage = (result.message || \"unknown error\");\n                // 4xx indicates the result is not present; stop\n                if (result.status >= 400 && result.status < 500) {\n                    return logger.throwError(`response not found during CCIP fetch: ${errorMessage}`, Logger.errors.SERVER_ERROR, { url, errorMessage });\n                }\n                // 5xx indicates server issue; try the next url\n                errorMessages.push(errorMessage);\n            }\n            return logger.throwError(`error encountered during CCIP fetch: ${errorMessages.map((m) => JSON.stringify(m)).join(\", \")}`, Logger.errors.SERVER_ERROR, {\n                urls, errorMessages\n            });\n        });\n    }\n    // Fetches the blockNumber, but will reuse any result that is less\n    // than maxAge old or has been requested since the last request\n    _getInternalBlockNumber(maxAge) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this._ready();\n            // Allowing stale data up to maxAge old\n            if (maxAge > 0) {\n                // While there are pending internal block requests...\n                while (this._internalBlockNumber) {\n                    // ...\"remember\" which fetch we started with\n                    const internalBlockNumber = this._internalBlockNumber;\n                    try {\n                        // Check the result is not too stale\n                        const result = yield internalBlockNumber;\n                        if ((getTime() - result.respTime) <= maxAge) {\n                            return result.blockNumber;\n                        }\n                        // Too old; fetch a new value\n                        break;\n                    }\n                    catch (error) {\n                        // The fetch rejected; if we are the first to get the\n                        // rejection, drop through so we replace it with a new\n                        // fetch; all others blocked will then get that fetch\n                        // which won't match the one they \"remembered\" and loop\n                        if (this._internalBlockNumber === internalBlockNumber) {\n                            break;\n                        }\n                    }\n                }\n            }\n            const reqTime = getTime();\n            const checkInternalBlockNumber = resolveProperties({\n                blockNumber: this.perform(\"getBlockNumber\", {}),\n                networkError: this.getNetwork().then((network) => (null), (error) => (error))\n            }).then(({ blockNumber, networkError }) => {\n                if (networkError) {\n                    // Unremember this bad internal block number\n                    if (this._internalBlockNumber === checkInternalBlockNumber) {\n                        this._internalBlockNumber = null;\n                    }\n                    throw networkError;\n                }\n                const respTime = getTime();\n                blockNumber = BigNumber.from(blockNumber).toNumber();\n                if (blockNumber < this._maxInternalBlockNumber) {\n                    blockNumber = this._maxInternalBlockNumber;\n                }\n                this._maxInternalBlockNumber = blockNumber;\n                this._setFastBlockNumber(blockNumber); // @TODO: Still need this?\n                return { blockNumber, reqTime, respTime };\n            });\n            this._internalBlockNumber = checkInternalBlockNumber;\n            // Swallow unhandled exceptions; if needed they are handled else where\n            checkInternalBlockNumber.catch((error) => {\n                // Don't null the dead (rejected) fetch, if it has already been updated\n                if (this._internalBlockNumber === checkInternalBlockNumber) {\n                    this._internalBlockNumber = null;\n                }\n            });\n            return (yield checkInternalBlockNumber).blockNumber;\n        });\n    }\n    poll() {\n        return __awaiter(this, void 0, void 0, function* () {\n            const pollId = nextPollId++;\n            // Track all running promises, so we can trigger a post-poll once they are complete\n            const runners = [];\n            let blockNumber = null;\n            try {\n                blockNumber = yield this._getInternalBlockNumber(100 + this.pollingInterval / 2);\n            }\n            catch (error) {\n                this.emit(\"error\", error);\n                return;\n            }\n            this._setFastBlockNumber(blockNumber);\n            // Emit a poll event after we have the latest (fast) block number\n            this.emit(\"poll\", pollId, blockNumber);\n            // If the block has not changed, meh.\n            if (blockNumber === this._lastBlockNumber) {\n                this.emit(\"didPoll\", pollId);\n                return;\n            }\n            // First polling cycle, trigger a \"block\" events\n            if (this._emitted.block === -2) {\n                this._emitted.block = blockNumber - 1;\n            }\n            if (Math.abs((this._emitted.block) - blockNumber) > 1000) {\n                logger.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);\n                this.emit(\"error\", logger.makeError(\"network block skew detected\", Logger.errors.NETWORK_ERROR, {\n                    blockNumber: blockNumber,\n                    event: \"blockSkew\",\n                    previousBlockNumber: this._emitted.block\n                }));\n                this.emit(\"block\", blockNumber);\n            }\n            else {\n                // Notify all listener for each block that has passed\n                for (let i = this._emitted.block + 1; i <= blockNumber; i++) {\n                    this.emit(\"block\", i);\n                }\n            }\n            // The emitted block was updated, check for obsolete events\n            if (this._emitted.block !== blockNumber) {\n                this._emitted.block = blockNumber;\n                Object.keys(this._emitted).forEach((key) => {\n                    // The block event does not expire\n                    if (key === \"block\") {\n                        return;\n                    }\n                    // The block we were at when we emitted this event\n                    const eventBlockNumber = this._emitted[key];\n                    // We cannot garbage collect pending transactions or blocks here\n                    // They should be garbage collected by the Provider when setting\n                    // \"pending\" events\n                    if (eventBlockNumber === \"pending\") {\n                        return;\n                    }\n                    // Evict any transaction hashes or block hashes over 12 blocks\n                    // old, since they should not return null anyways\n                    if (blockNumber - eventBlockNumber > 12) {\n                        delete this._emitted[key];\n                    }\n                });\n            }\n            // First polling cycle\n            if (this._lastBlockNumber === -2) {\n                this._lastBlockNumber = blockNumber - 1;\n            }\n            // Find all transaction hashes we are waiting on\n            this._events.forEach((event) => {\n                switch (event.type) {\n                    case \"tx\": {\n                        const hash = event.hash;\n                        let runner = this.getTransactionReceipt(hash).then((receipt) => {\n                            if (!receipt || receipt.blockNumber == null) {\n                                return null;\n                            }\n                            this._emitted[\"t:\" + hash] = receipt.blockNumber;\n                            this.emit(hash, receipt);\n                            return null;\n                        }).catch((error) => { this.emit(\"error\", error); });\n                        runners.push(runner);\n                        break;\n                    }\n                    case \"filter\": {\n                        // We only allow a single getLogs to be in-flight at a time\n                        if (!event._inflight) {\n                            event._inflight = true;\n                            // Filter from the last known event; due to load-balancing\n                            // and some nodes returning updated block numbers before\n                            // indexing events, a logs result with 0 entries cannot be\n                            // trusted and we must retry a range which includes it again\n                            const filter = event.filter;\n                            filter.fromBlock = event._lastBlockNumber + 1;\n                            filter.toBlock = blockNumber;\n                            // Prevent fitler ranges from growing too wild\n                            if (filter.toBlock - this._maxFilterBlockRange > filter.fromBlock) {\n                                filter.fromBlock = filter.toBlock - this._maxFilterBlockRange;\n                            }\n                            const runner = this.getLogs(filter).then((logs) => {\n                                // Allow the next getLogs\n                                event._inflight = false;\n                                if (logs.length === 0) {\n                                    return;\n                                }\n                                logs.forEach((log) => {\n                                    // Only when we get an event for a given block number\n                                    // can we trust the events are indexed\n                                    if (log.blockNumber > event._lastBlockNumber) {\n                                        event._lastBlockNumber = log.blockNumber;\n                                    }\n                                    // Make sure we stall requests to fetch blocks and txs\n                                    this._emitted[\"b:\" + log.blockHash] = log.blockNumber;\n                                    this._emitted[\"t:\" + log.transactionHash] = log.blockNumber;\n                                    this.emit(filter, log);\n                                });\n                            }).catch((error) => {\n                                this.emit(\"error\", error);\n                                // Allow another getLogs (the range was not updated)\n                                event._inflight = false;\n                            });\n                            runners.push(runner);\n                        }\n                        break;\n                    }\n                }\n            });\n            this._lastBlockNumber = blockNumber;\n            // Once all events for this loop have been processed, emit \"didPoll\"\n            Promise.all(runners).then(() => {\n                this.emit(\"didPoll\", pollId);\n            }).catch((error) => { this.emit(\"error\", error); });\n            return;\n        });\n    }\n    // Deprecated; do not use this\n    resetEventsBlock(blockNumber) {\n        this._lastBlockNumber = blockNumber - 1;\n        if (this.polling) {\n            this.poll();\n        }\n    }\n    get network() {\n        return this._network;\n    }\n    // This method should query the network if the underlying network\n    // can change, such as when connected to a JSON-RPC backend\n    detectNetwork() {\n        return __awaiter(this, void 0, void 0, function* () {\n            return logger.throwError(\"provider does not support network detection\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"provider.detectNetwork\"\n            });\n        });\n    }\n    getNetwork() {\n        return __awaiter(this, void 0, void 0, function* () {\n            const network = yield this._ready();\n            // Make sure we are still connected to the same network; this is\n            // only an external call for backends which can have the underlying\n            // network change spontaneously\n            const currentNetwork = yield this.detectNetwork();\n            if (network.chainId !== currentNetwork.chainId) {\n                // We are allowing network changes, things can get complex fast;\n                // make sure you know what you are doing if you use \"any\"\n                if (this.anyNetwork) {\n                    this._network = currentNetwork;\n                    // Reset all internal block number guards and caches\n                    this._lastBlockNumber = -2;\n                    this._fastBlockNumber = null;\n                    this._fastBlockNumberPromise = null;\n                    this._fastQueryDate = 0;\n                    this._emitted.block = -2;\n                    this._maxInternalBlockNumber = -1024;\n                    this._internalBlockNumber = null;\n                    // The \"network\" event MUST happen before this method resolves\n                    // so any events have a chance to unregister, so we stall an\n                    // additional event loop before returning from /this/ call\n                    this.emit(\"network\", currentNetwork, network);\n                    yield stall(0);\n                    return this._network;\n                }\n                const error = logger.makeError(\"underlying network changed\", Logger.errors.NETWORK_ERROR, {\n                    event: \"changed\",\n                    network: network,\n                    detectedNetwork: currentNetwork\n                });\n                this.emit(\"error\", error);\n                throw error;\n            }\n            return network;\n        });\n    }\n    get blockNumber() {\n        this._getInternalBlockNumber(100 + this.pollingInterval / 2).then((blockNumber) => {\n            this._setFastBlockNumber(blockNumber);\n        }, (error) => { });\n        return (this._fastBlockNumber != null) ? this._fastBlockNumber : -1;\n    }\n    get polling() {\n        return (this._poller != null);\n    }\n    set polling(value) {\n        if (value && !this._poller) {\n            this._poller = setInterval(() => { this.poll(); }, this.pollingInterval);\n            if (!this._bootstrapPoll) {\n                this._bootstrapPoll = setTimeout(() => {\n                    this.poll();\n                    // We block additional polls until the polling interval\n                    // is done, to prevent overwhelming the poll function\n                    this._bootstrapPoll = setTimeout(() => {\n                        // If polling was disabled, something may require a poke\n                        // since starting the bootstrap poll and it was disabled\n                        if (!this._poller) {\n                            this.poll();\n                        }\n                        // Clear out the bootstrap so we can do another\n                        this._bootstrapPoll = null;\n                    }, this.pollingInterval);\n                }, 0);\n            }\n        }\n        else if (!value && this._poller) {\n            clearInterval(this._poller);\n            this._poller = null;\n        }\n    }\n    get pollingInterval() {\n        return this._pollingInterval;\n    }\n    set pollingInterval(value) {\n        if (typeof (value) !== \"number\" || value <= 0 || parseInt(String(value)) != value) {\n            throw new Error(\"invalid polling interval\");\n        }\n        this._pollingInterval = value;\n        if (this._poller) {\n            clearInterval(this._poller);\n            this._poller = setInterval(() => { this.poll(); }, this._pollingInterval);\n        }\n    }\n    _getFastBlockNumber() {\n        const now = getTime();\n        // Stale block number, request a newer value\n        if ((now - this._fastQueryDate) > 2 * this._pollingInterval) {\n            this._fastQueryDate = now;\n            this._fastBlockNumberPromise = this.getBlockNumber().then((blockNumber) => {\n                if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {\n                    this._fastBlockNumber = blockNumber;\n                }\n                return this._fastBlockNumber;\n            });\n        }\n        return this._fastBlockNumberPromise;\n    }\n    _setFastBlockNumber(blockNumber) {\n        // Older block, maybe a stale request\n        if (this._fastBlockNumber != null && blockNumber < this._fastBlockNumber) {\n            return;\n        }\n        // Update the time we updated the blocknumber\n        this._fastQueryDate = getTime();\n        // Newer block number, use  it\n        if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {\n            this._fastBlockNumber = blockNumber;\n            this._fastBlockNumberPromise = Promise.resolve(blockNumber);\n        }\n    }\n    waitForTransaction(transactionHash, confirmations, timeout) {\n        return __awaiter(this, void 0, void 0, function* () {\n            return this._waitForTransaction(transactionHash, (confirmations == null) ? 1 : confirmations, timeout || 0, null);\n        });\n    }\n    _waitForTransaction(transactionHash, confirmations, timeout, replaceable) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const receipt = yield this.getTransactionReceipt(transactionHash);\n            // Receipt is already good\n            if ((receipt ? receipt.confirmations : 0) >= confirmations) {\n                return receipt;\n            }\n            // Poll until the receipt is good...\n            return new Promise((resolve, reject) => {\n                const cancelFuncs = [];\n                let done = false;\n                const alreadyDone = function () {\n                    if (done) {\n                        return true;\n                    }\n                    done = true;\n                    cancelFuncs.forEach((func) => { func(); });\n                    return false;\n                };\n                const minedHandler = (receipt) => {\n                    if (receipt.confirmations < confirmations) {\n                        return;\n                    }\n                    if (alreadyDone()) {\n                        return;\n                    }\n                    resolve(receipt);\n                };\n                this.on(transactionHash, minedHandler);\n                cancelFuncs.push(() => { this.removeListener(transactionHash, minedHandler); });\n                if (replaceable) {\n                    let lastBlockNumber = replaceable.startBlock;\n                    let scannedBlock = null;\n                    const replaceHandler = (blockNumber) => __awaiter(this, void 0, void 0, function* () {\n                        if (done) {\n                            return;\n                        }\n                        // Wait 1 second; this is only used in the case of a fault, so\n                        // we will trade off a little bit of latency for more consistent\n                        // results and fewer JSON-RPC calls\n                        yield stall(1000);\n                        this.getTransactionCount(replaceable.from).then((nonce) => __awaiter(this, void 0, void 0, function* () {\n                            if (done) {\n                                return;\n                            }\n                            if (nonce <= replaceable.nonce) {\n                                lastBlockNumber = blockNumber;\n                            }\n                            else {\n                                // First check if the transaction was mined\n                                {\n                                    const mined = yield this.getTransaction(transactionHash);\n                                    if (mined && mined.blockNumber != null) {\n                                        return;\n                                    }\n                                }\n                                // First time scanning. We start a little earlier for some\n                                // wiggle room here to handle the eventually consistent nature\n                                // of blockchain (e.g. the getTransactionCount was for a\n                                // different block)\n                                if (scannedBlock == null) {\n                                    scannedBlock = lastBlockNumber - 3;\n                                    if (scannedBlock < replaceable.startBlock) {\n                                        scannedBlock = replaceable.startBlock;\n                                    }\n                                }\n                                while (scannedBlock <= blockNumber) {\n                                    if (done) {\n                                        return;\n                                    }\n                                    const block = yield this.getBlockWithTransactions(scannedBlock);\n                                    for (let ti = 0; ti < block.transactions.length; ti++) {\n                                        const tx = block.transactions[ti];\n                                        // Successfully mined!\n                                        if (tx.hash === transactionHash) {\n                                            return;\n                                        }\n                                        // Matches our transaction from and nonce; its a replacement\n                                        if (tx.from === replaceable.from && tx.nonce === replaceable.nonce) {\n                                            if (done) {\n                                                return;\n                                            }\n                                            // Get the receipt of the replacement\n                                            const receipt = yield this.waitForTransaction(tx.hash, confirmations);\n                                            // Already resolved or rejected (prolly a timeout)\n                                            if (alreadyDone()) {\n                                                return;\n                                            }\n                                            // The reason we were replaced\n                                            let reason = \"replaced\";\n                                            if (tx.data === replaceable.data && tx.to === replaceable.to && tx.value.eq(replaceable.value)) {\n                                                reason = \"repriced\";\n                                            }\n                                            else if (tx.data === \"0x\" && tx.from === tx.to && tx.value.isZero()) {\n                                                reason = \"cancelled\";\n                                            }\n                                            // Explain why we were replaced\n                                            reject(logger.makeError(\"transaction was replaced\", Logger.errors.TRANSACTION_REPLACED, {\n                                                cancelled: (reason === \"replaced\" || reason === \"cancelled\"),\n                                                reason,\n                                                replacement: this._wrapTransaction(tx),\n                                                hash: transactionHash,\n                                                receipt\n                                            }));\n                                            return;\n                                        }\n                                    }\n                                    scannedBlock++;\n                                }\n                            }\n                            if (done) {\n                                return;\n                            }\n                            this.once(\"block\", replaceHandler);\n                        }), (error) => {\n                            if (done) {\n                                return;\n                            }\n                            this.once(\"block\", replaceHandler);\n                        });\n                    });\n                    if (done) {\n                        return;\n                    }\n                    this.once(\"block\", replaceHandler);\n                    cancelFuncs.push(() => {\n                        this.removeListener(\"block\", replaceHandler);\n                    });\n                }\n                if (typeof (timeout) === \"number\" && timeout > 0) {\n                    const timer = setTimeout(() => {\n                        if (alreadyDone()) {\n                            return;\n                        }\n                        reject(logger.makeError(\"timeout exceeded\", Logger.errors.TIMEOUT, { timeout: timeout }));\n                    }, timeout);\n                    if (timer.unref) {\n                        timer.unref();\n                    }\n                    cancelFuncs.push(() => { clearTimeout(timer); });\n                }\n            });\n        });\n    }\n    getBlockNumber() {\n        return __awaiter(this, void 0, void 0, function* () {\n            return this._getInternalBlockNumber(0);\n        });\n    }\n    getGasPrice() {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const result = yield this.perform(\"getGasPrice\", {});\n            try {\n                return BigNumber.from(result);\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"getGasPrice\",\n                    result, error\n                });\n            }\n        });\n    }\n    getBalance(addressOrName, blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const params = yield resolveProperties({\n                address: this._getAddress(addressOrName),\n                blockTag: this._getBlockTag(blockTag)\n            });\n            const result = yield this.perform(\"getBalance\", params);\n            try {\n                return BigNumber.from(result);\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"getBalance\",\n                    params, result, error\n                });\n            }\n        });\n    }\n    getTransactionCount(addressOrName, blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const params = yield resolveProperties({\n                address: this._getAddress(addressOrName),\n                blockTag: this._getBlockTag(blockTag)\n            });\n            const result = yield this.perform(\"getTransactionCount\", params);\n            try {\n                return BigNumber.from(result).toNumber();\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"getTransactionCount\",\n                    params, result, error\n                });\n            }\n        });\n    }\n    getCode(addressOrName, blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const params = yield resolveProperties({\n                address: this._getAddress(addressOrName),\n                blockTag: this._getBlockTag(blockTag)\n            });\n            const result = yield this.perform(\"getCode\", params);\n            try {\n                return hexlify(result);\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"getCode\",\n                    params, result, error\n                });\n            }\n        });\n    }\n    getStorageAt(addressOrName, position, blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const params = yield resolveProperties({\n                address: this._getAddress(addressOrName),\n                blockTag: this._getBlockTag(blockTag),\n                position: Promise.resolve(position).then((p) => hexValue(p))\n            });\n            const result = yield this.perform(\"getStorageAt\", params);\n            try {\n                return hexlify(result);\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"getStorageAt\",\n                    params, result, error\n                });\n            }\n        });\n    }\n    // This should be called by any subclass wrapping a TransactionResponse\n    _wrapTransaction(tx, hash, startBlock) {\n        if (hash != null && hexDataLength(hash) !== 32) {\n            throw new Error(\"invalid response - sendTransaction\");\n        }\n        const result = tx;\n        // Check the hash we expect is the same as the hash the server reported\n        if (hash != null && tx.hash !== hash) {\n            logger.throwError(\"Transaction hash mismatch from Provider.sendTransaction.\", Logger.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });\n        }\n        result.wait = (confirms, timeout) => __awaiter(this, void 0, void 0, function* () {\n            if (confirms == null) {\n                confirms = 1;\n            }\n            if (timeout == null) {\n                timeout = 0;\n            }\n            // Get the details to detect replacement\n            let replacement = undefined;\n            if (confirms !== 0 && startBlock != null) {\n                replacement = {\n                    data: tx.data,\n                    from: tx.from,\n                    nonce: tx.nonce,\n                    to: tx.to,\n                    value: tx.value,\n                    startBlock\n                };\n            }\n            const receipt = yield this._waitForTransaction(tx.hash, confirms, timeout, replacement);\n            if (receipt == null && confirms === 0) {\n                return null;\n            }\n            // No longer pending, allow the polling loop to garbage collect this\n            this._emitted[\"t:\" + tx.hash] = receipt.blockNumber;\n            if (receipt.status === 0) {\n                logger.throwError(\"transaction failed\", Logger.errors.CALL_EXCEPTION, {\n                    transactionHash: tx.hash,\n                    transaction: tx,\n                    receipt: receipt\n                });\n            }\n            return receipt;\n        });\n        return result;\n    }\n    sendTransaction(signedTransaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const hexTx = yield Promise.resolve(signedTransaction).then(t => hexlify(t));\n            const tx = this.formatter.transaction(signedTransaction);\n            if (tx.confirmations == null) {\n                tx.confirmations = 0;\n            }\n            const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);\n            try {\n                const hash = yield this.perform(\"sendTransaction\", { signedTransaction: hexTx });\n                return this._wrapTransaction(tx, hash, blockNumber);\n            }\n            catch (error) {\n                error.transaction = tx;\n                error.transactionHash = tx.hash;\n                throw error;\n            }\n        });\n    }\n    _getTransactionRequest(transaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const values = yield transaction;\n            const tx = {};\n            [\"from\", \"to\"].forEach((key) => {\n                if (values[key] == null) {\n                    return;\n                }\n                tx[key] = Promise.resolve(values[key]).then((v) => (v ? this._getAddress(v) : null));\n            });\n            [\"gasLimit\", \"gasPrice\", \"maxFeePerGas\", \"maxPriorityFeePerGas\", \"value\"].forEach((key) => {\n                if (values[key] == null) {\n                    return;\n                }\n                tx[key] = Promise.resolve(values[key]).then((v) => (v ? BigNumber.from(v) : null));\n            });\n            [\"type\"].forEach((key) => {\n                if (values[key] == null) {\n                    return;\n                }\n                tx[key] = Promise.resolve(values[key]).then((v) => ((v != null) ? v : null));\n            });\n            if (values.accessList) {\n                tx.accessList = this.formatter.accessList(values.accessList);\n            }\n            [\"data\"].forEach((key) => {\n                if (values[key] == null) {\n                    return;\n                }\n                tx[key] = Promise.resolve(values[key]).then((v) => (v ? hexlify(v) : null));\n            });\n            return this.formatter.transactionRequest(yield resolveProperties(tx));\n        });\n    }\n    _getFilter(filter) {\n        return __awaiter(this, void 0, void 0, function* () {\n            filter = yield filter;\n            const result = {};\n            if (filter.address != null) {\n                result.address = this._getAddress(filter.address);\n            }\n            [\"blockHash\", \"topics\"].forEach((key) => {\n                if (filter[key] == null) {\n                    return;\n                }\n                result[key] = filter[key];\n            });\n            [\"fromBlock\", \"toBlock\"].forEach((key) => {\n                if (filter[key] == null) {\n                    return;\n                }\n                result[key] = this._getBlockTag(filter[key]);\n            });\n            return this.formatter.filter(yield resolveProperties(result));\n        });\n    }\n    _call(transaction, blockTag, attempt) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (attempt >= MAX_CCIP_REDIRECTS) {\n                logger.throwError(\"CCIP read exceeded maximum redirections\", Logger.errors.SERVER_ERROR, {\n                    redirects: attempt, transaction\n                });\n            }\n            const txSender = transaction.to;\n            const result = yield this.perform(\"call\", { transaction, blockTag });\n            // CCIP Read request via OffchainLookup(address,string[],bytes,bytes4,bytes)\n            if (attempt >= 0 && blockTag === \"latest\" && txSender != null && result.substring(0, 10) === \"0x556f1830\" && (hexDataLength(result) % 32 === 4)) {\n                try {\n                    const data = hexDataSlice(result, 4);\n                    // Check the sender of the OffchainLookup matches the transaction\n                    const sender = hexDataSlice(data, 0, 32);\n                    if (!BigNumber.from(sender).eq(txSender)) {\n                        logger.throwError(\"CCIP Read sender did not match\", Logger.errors.CALL_EXCEPTION, {\n                            name: \"OffchainLookup\",\n                            signature: \"OffchainLookup(address,string[],bytes,bytes4,bytes)\",\n                            transaction, data: result\n                        });\n                    }\n                    // Read the URLs from the response\n                    const urls = [];\n                    const urlsOffset = BigNumber.from(hexDataSlice(data, 32, 64)).toNumber();\n                    const urlsLength = BigNumber.from(hexDataSlice(data, urlsOffset, urlsOffset + 32)).toNumber();\n                    const urlsData = hexDataSlice(data, urlsOffset + 32);\n                    for (let u = 0; u < urlsLength; u++) {\n                        const url = _parseString(urlsData, u * 32);\n                        if (url == null) {\n                            logger.throwError(\"CCIP Read contained corrupt URL string\", Logger.errors.CALL_EXCEPTION, {\n                                name: \"OffchainLookup\",\n                                signature: \"OffchainLookup(address,string[],bytes,bytes4,bytes)\",\n                                transaction, data: result\n                            });\n                        }\n                        urls.push(url);\n                    }\n                    // Get the CCIP calldata to forward\n                    const calldata = _parseBytes(data, 64);\n                    // Get the callbackSelector (bytes4)\n                    if (!BigNumber.from(hexDataSlice(data, 100, 128)).isZero()) {\n                        logger.throwError(\"CCIP Read callback selector included junk\", Logger.errors.CALL_EXCEPTION, {\n                            name: \"OffchainLookup\",\n                            signature: \"OffchainLookup(address,string[],bytes,bytes4,bytes)\",\n                            transaction, data: result\n                        });\n                    }\n                    const callbackSelector = hexDataSlice(data, 96, 100);\n                    // Get the extra data to send back to the contract as context\n                    const extraData = _parseBytes(data, 128);\n                    const ccipResult = yield this.ccipReadFetch(transaction, calldata, urls);\n                    if (ccipResult == null) {\n                        logger.throwError(\"CCIP Read disabled or provided no URLs\", Logger.errors.CALL_EXCEPTION, {\n                            name: \"OffchainLookup\",\n                            signature: \"OffchainLookup(address,string[],bytes,bytes4,bytes)\",\n                            transaction, data: result\n                        });\n                    }\n                    const tx = {\n                        to: txSender,\n                        data: hexConcat([callbackSelector, encodeBytes([ccipResult, extraData])])\n                    };\n                    return this._call(tx, blockTag, attempt + 1);\n                }\n                catch (error) {\n                    if (error.code === Logger.errors.SERVER_ERROR) {\n                        throw error;\n                    }\n                }\n            }\n            try {\n                return hexlify(result);\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"call\",\n                    params: { transaction, blockTag }, result, error\n                });\n            }\n        });\n    }\n    call(transaction, blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const resolved = yield resolveProperties({\n                transaction: this._getTransactionRequest(transaction),\n                blockTag: this._getBlockTag(blockTag),\n                ccipReadEnabled: Promise.resolve(transaction.ccipReadEnabled)\n            });\n            return this._call(resolved.transaction, resolved.blockTag, resolved.ccipReadEnabled ? 0 : -1);\n        });\n    }\n    estimateGas(transaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const params = yield resolveProperties({\n                transaction: this._getTransactionRequest(transaction)\n            });\n            const result = yield this.perform(\"estimateGas\", params);\n            try {\n                return BigNumber.from(result);\n            }\n            catch (error) {\n                return logger.throwError(\"bad result from backend\", Logger.errors.SERVER_ERROR, {\n                    method: \"estimateGas\",\n                    params, result, error\n                });\n            }\n        });\n    }\n    _getAddress(addressOrName) {\n        return __awaiter(this, void 0, void 0, function* () {\n            addressOrName = yield addressOrName;\n            if (typeof (addressOrName) !== \"string\") {\n                logger.throwArgumentError(\"invalid address or ENS name\", \"name\", addressOrName);\n            }\n            const address = yield this.resolveName(addressOrName);\n            if (address == null) {\n                logger.throwError(\"ENS name not configured\", Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: `resolveName(${JSON.stringify(addressOrName)})`\n                });\n            }\n            return address;\n        });\n    }\n    _getBlock(blockHashOrBlockTag, includeTransactions) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            blockHashOrBlockTag = yield blockHashOrBlockTag;\n            // If blockTag is a number (not \"latest\", etc), this is the block number\n            let blockNumber = -128;\n            const params = {\n                includeTransactions: !!includeTransactions\n            };\n            if (isHexString(blockHashOrBlockTag, 32)) {\n                params.blockHash = blockHashOrBlockTag;\n            }\n            else {\n                try {\n                    params.blockTag = yield this._getBlockTag(blockHashOrBlockTag);\n                    if (isHexString(params.blockTag)) {\n                        blockNumber = parseInt(params.blockTag.substring(2), 16);\n                    }\n                }\n                catch (error) {\n                    logger.throwArgumentError(\"invalid block hash or block tag\", \"blockHashOrBlockTag\", blockHashOrBlockTag);\n                }\n            }\n            return poll(() => __awaiter(this, void 0, void 0, function* () {\n                const block = yield this.perform(\"getBlock\", params);\n                // Block was not found\n                if (block == null) {\n                    // For blockhashes, if we didn't say it existed, that blockhash may\n                    // not exist. If we did see it though, perhaps from a log, we know\n                    // it exists, and this node is just not caught up yet.\n                    if (params.blockHash != null) {\n                        if (this._emitted[\"b:\" + params.blockHash] == null) {\n                            return null;\n                        }\n                    }\n                    // For block tags, if we are asking for a future block, we return null\n                    if (params.blockTag != null) {\n                        if (blockNumber > this._emitted.block) {\n                            return null;\n                        }\n                    }\n                    // Retry on the next block\n                    return undefined;\n                }\n                // Add transactions\n                if (includeTransactions) {\n                    let blockNumber = null;\n                    for (let i = 0; i < block.transactions.length; i++) {\n                        const tx = block.transactions[i];\n                        if (tx.blockNumber == null) {\n                            tx.confirmations = 0;\n                        }\n                        else if (tx.confirmations == null) {\n                            if (blockNumber == null) {\n                                blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);\n                            }\n                            // Add the confirmations using the fast block number (pessimistic)\n                            let confirmations = (blockNumber - tx.blockNumber) + 1;\n                            if (confirmations <= 0) {\n                                confirmations = 1;\n                            }\n                            tx.confirmations = confirmations;\n                        }\n                    }\n                    const blockWithTxs = this.formatter.blockWithTransactions(block);\n                    blockWithTxs.transactions = blockWithTxs.transactions.map((tx) => this._wrapTransaction(tx));\n                    return blockWithTxs;\n                }\n                return this.formatter.block(block);\n            }), { oncePoll: this });\n        });\n    }\n    getBlock(blockHashOrBlockTag) {\n        return (this._getBlock(blockHashOrBlockTag, false));\n    }\n    getBlockWithTransactions(blockHashOrBlockTag) {\n        return (this._getBlock(blockHashOrBlockTag, true));\n    }\n    getTransaction(transactionHash) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            transactionHash = yield transactionHash;\n            const params = { transactionHash: this.formatter.hash(transactionHash, true) };\n            return poll(() => __awaiter(this, void 0, void 0, function* () {\n                const result = yield this.perform(\"getTransaction\", params);\n                if (result == null) {\n                    if (this._emitted[\"t:\" + transactionHash] == null) {\n                        return null;\n                    }\n                    return undefined;\n                }\n                const tx = this.formatter.transactionResponse(result);\n                if (tx.blockNumber == null) {\n                    tx.confirmations = 0;\n                }\n                else if (tx.confirmations == null) {\n                    const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);\n                    // Add the confirmations using the fast block number (pessimistic)\n                    let confirmations = (blockNumber - tx.blockNumber) + 1;\n                    if (confirmations <= 0) {\n                        confirmations = 1;\n                    }\n                    tx.confirmations = confirmations;\n                }\n                return this._wrapTransaction(tx);\n            }), { oncePoll: this });\n        });\n    }\n    getTransactionReceipt(transactionHash) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            transactionHash = yield transactionHash;\n            const params = { transactionHash: this.formatter.hash(transactionHash, true) };\n            return poll(() => __awaiter(this, void 0, void 0, function* () {\n                const result = yield this.perform(\"getTransactionReceipt\", params);\n                if (result == null) {\n                    if (this._emitted[\"t:\" + transactionHash] == null) {\n                        return null;\n                    }\n                    return undefined;\n                }\n                // \"geth-etc\" returns receipts before they are ready\n                if (result.blockHash == null) {\n                    return undefined;\n                }\n                const receipt = this.formatter.receipt(result);\n                if (receipt.blockNumber == null) {\n                    receipt.confirmations = 0;\n                }\n                else if (receipt.confirmations == null) {\n                    const blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);\n                    // Add the confirmations using the fast block number (pessimistic)\n                    let confirmations = (blockNumber - receipt.blockNumber) + 1;\n                    if (confirmations <= 0) {\n                        confirmations = 1;\n                    }\n                    receipt.confirmations = confirmations;\n                }\n                return receipt;\n            }), { oncePoll: this });\n        });\n    }\n    getLogs(filter) {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            const params = yield resolveProperties({ filter: this._getFilter(filter) });\n            const logs = yield this.perform(\"getLogs\", params);\n            logs.forEach((log) => {\n                if (log.removed == null) {\n                    log.removed = false;\n                }\n            });\n            return Formatter.arrayOf(this.formatter.filterLog.bind(this.formatter))(logs);\n        });\n    }\n    getEtherPrice() {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield this.getNetwork();\n            return this.perform(\"getEtherPrice\", {});\n        });\n    }\n    _getBlockTag(blockTag) {\n        return __awaiter(this, void 0, void 0, function* () {\n            blockTag = yield blockTag;\n            if (typeof (blockTag) === \"number\" && blockTag < 0) {\n                if (blockTag % 1) {\n                    logger.throwArgumentError(\"invalid BlockTag\", \"blockTag\", blockTag);\n                }\n                let blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);\n                blockNumber += blockTag;\n                if (blockNumber < 0) {\n                    blockNumber = 0;\n                }\n                return this.formatter.blockTag(blockNumber);\n            }\n            return this.formatter.blockTag(blockTag);\n        });\n    }\n    getResolver(name) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let currentName = name;\n            while (true) {\n                if (currentName === \"\" || currentName === \".\") {\n                    return null;\n                }\n                // Optimization since the eth node cannot change and does\n                // not have a wildcar resolver\n                if (name !== \"eth\" && currentName === \"eth\") {\n                    return null;\n                }\n                // Check the current node for a resolver\n                const addr = yield this._getResolver(currentName, \"getResolver\");\n                // Found a resolver!\n                if (addr != null) {\n                    const resolver = new Resolver(this, addr, name);\n                    // Legacy resolver found, using EIP-2544 so it isn't safe to use\n                    if (currentName !== name && !(yield resolver.supportsWildcard())) {\n                        return null;\n                    }\n                    return resolver;\n                }\n                // Get the parent node\n                currentName = currentName.split(\".\").slice(1).join(\".\");\n            }\n        });\n    }\n    _getResolver(name, operation) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (operation == null) {\n                operation = \"ENS\";\n            }\n            const network = yield this.getNetwork();\n            // No ENS...\n            if (!network.ensAddress) {\n                logger.throwError(\"network does not support ENS\", Logger.errors.UNSUPPORTED_OPERATION, { operation, network: network.name });\n            }\n            try {\n                // keccak256(\"resolver(bytes32)\")\n                const addrData = yield this.call({\n                    to: network.ensAddress,\n                    data: (\"0x0178b8bf\" + namehash(name).substring(2))\n                });\n                return this.formatter.callAddress(addrData);\n            }\n            catch (error) {\n                // ENS registry cannot throw errors on resolver(bytes32)\n            }\n            return null;\n        });\n    }\n    resolveName(name) {\n        return __awaiter(this, void 0, void 0, function* () {\n            name = yield name;\n            // If it is already an address, nothing to resolve\n            try {\n                return Promise.resolve(this.formatter.address(name));\n            }\n            catch (error) {\n                // If is is a hexstring, the address is bad (See #694)\n                if (isHexString(name)) {\n                    throw error;\n                }\n            }\n            if (typeof (name) !== \"string\") {\n                logger.throwArgumentError(\"invalid ENS name\", \"name\", name);\n            }\n            // Get the addr from the resovler\n            const resolver = yield this.getResolver(name);\n            if (!resolver) {\n                return null;\n            }\n            return yield resolver.getAddress();\n        });\n    }\n    lookupAddress(address) {\n        return __awaiter(this, void 0, void 0, function* () {\n            address = yield address;\n            address = this.formatter.address(address);\n            const node = address.substring(2).toLowerCase() + \".addr.reverse\";\n            const resolverAddr = yield this._getResolver(node, \"lookupAddress\");\n            if (resolverAddr == null) {\n                return null;\n            }\n            // keccak(\"name(bytes32)\")\n            const name = _parseString(yield this.call({\n                to: resolverAddr,\n                data: (\"0x691f3431\" + namehash(node).substring(2))\n            }), 0);\n            const addr = yield this.resolveName(name);\n            if (addr != address) {\n                return null;\n            }\n            return name;\n        });\n    }\n    getAvatar(nameOrAddress) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let resolver = null;\n            if (isHexString(nameOrAddress)) {\n                // Address; reverse lookup\n                const address = this.formatter.address(nameOrAddress);\n                const node = address.substring(2).toLowerCase() + \".addr.reverse\";\n                const resolverAddress = yield this._getResolver(node, \"getAvatar\");\n                if (!resolverAddress) {\n                    return null;\n                }\n                // Try resolving the avatar against the addr.reverse resolver\n                resolver = new Resolver(this, resolverAddress, node);\n                try {\n                    const avatar = yield resolver.getAvatar();\n                    if (avatar) {\n                        return avatar.url;\n                    }\n                }\n                catch (error) {\n                    if (error.code !== Logger.errors.CALL_EXCEPTION) {\n                        throw error;\n                    }\n                }\n                // Try getting the name and performing forward lookup; allowing wildcards\n                try {\n                    // keccak(\"name(bytes32)\")\n                    const name = _parseString(yield this.call({\n                        to: resolverAddress,\n                        data: (\"0x691f3431\" + namehash(node).substring(2))\n                    }), 0);\n                    resolver = yield this.getResolver(name);\n                }\n                catch (error) {\n                    if (error.code !== Logger.errors.CALL_EXCEPTION) {\n                        throw error;\n                    }\n                    return null;\n                }\n            }\n            else {\n                // ENS name; forward lookup with wildcard\n                resolver = yield this.getResolver(nameOrAddress);\n                if (!resolver) {\n                    return null;\n                }\n            }\n            const avatar = yield resolver.getAvatar();\n            if (avatar == null) {\n                return null;\n            }\n            return avatar.url;\n        });\n    }\n    perform(method, params) {\n        return logger.throwError(method + \" not implemented\", Logger.errors.NOT_IMPLEMENTED, { operation: method });\n    }\n    _startEvent(event) {\n        this.polling = (this._events.filter((e) => e.pollable()).length > 0);\n    }\n    _stopEvent(event) {\n        this.polling = (this._events.filter((e) => e.pollable()).length > 0);\n    }\n    _addEventListener(eventName, listener, once) {\n        const event = new Event(getEventTag(eventName), listener, once);\n        this._events.push(event);\n        this._startEvent(event);\n        return this;\n    }\n    on(eventName, listener) {\n        return this._addEventListener(eventName, listener, false);\n    }\n    once(eventName, listener) {\n        return this._addEventListener(eventName, listener, true);\n    }\n    emit(eventName, ...args) {\n        let result = false;\n        let stopped = [];\n        let eventTag = getEventTag(eventName);\n        this._events = this._events.filter((event) => {\n            if (event.tag !== eventTag) {\n                return true;\n            }\n            setTimeout(() => {\n                event.listener.apply(this, args);\n            }, 0);\n            result = true;\n            if (event.once) {\n                stopped.push(event);\n                return false;\n            }\n            return true;\n        });\n        stopped.forEach((event) => { this._stopEvent(event); });\n        return result;\n    }\n    listenerCount(eventName) {\n        if (!eventName) {\n            return this._events.length;\n        }\n        let eventTag = getEventTag(eventName);\n        return this._events.filter((event) => {\n            return (event.tag === eventTag);\n        }).length;\n    }\n    listeners(eventName) {\n        if (eventName == null) {\n            return this._events.map((event) => event.listener);\n        }\n        let eventTag = getEventTag(eventName);\n        return this._events\n            .filter((event) => (event.tag === eventTag))\n            .map((event) => event.listener);\n    }\n    off(eventName, listener) {\n        if (listener == null) {\n            return this.removeAllListeners(eventName);\n        }\n        const stopped = [];\n        let found = false;\n        let eventTag = getEventTag(eventName);\n        this._events = this._events.filter((event) => {\n            if (event.tag !== eventTag || event.listener != listener) {\n                return true;\n            }\n            if (found) {\n                return true;\n            }\n            found = true;\n            stopped.push(event);\n            return false;\n        });\n        stopped.forEach((event) => { this._stopEvent(event); });\n        return this;\n    }\n    removeAllListeners(eventName) {\n        let stopped = [];\n        if (eventName == null) {\n            stopped = this._events;\n            this._events = [];\n        }\n        else {\n            const eventTag = getEventTag(eventName);\n            this._events = this._events.filter((event) => {\n                if (event.tag !== eventTag) {\n                    return true;\n                }\n                stopped.push(event);\n                return false;\n            });\n        }\n        stopped.forEach((event) => { this._stopEvent(event); });\n        return this;\n    }\n}\n//# sourceMappingURL=base-provider.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { Signer } from \"@ethersproject/abstract-signer\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { hexlify, hexValue, isHexString } from \"@ethersproject/bytes\";\nimport { _TypedDataEncoder } from \"@ethersproject/hash\";\nimport { checkProperties, deepCopy, defineReadOnly, getStatic, resolveProperties, shallowCopy } from \"@ethersproject/properties\";\nimport { toUtf8Bytes } from \"@ethersproject/strings\";\nimport { accessListify } from \"@ethersproject/transactions\";\nimport { fetchJson, poll } from \"@ethersproject/web\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { BaseProvider } from \"./base-provider\";\nconst errorGas = [\"call\", \"estimateGas\"];\nfunction spelunk(value) {\n    if (value == null) {\n        return null;\n    }\n    // These *are* the droids we're looking for.\n    if (typeof (value.message) === \"string\" && value.message.match(\"reverted\") && isHexString(value.data)) {\n        return { message: value.message, data: value.data };\n    }\n    // Spelunk further...\n    if (typeof (value) === \"object\") {\n        for (const key in value) {\n            const result = spelunk(value[key]);\n            if (result) {\n                return result;\n            }\n        }\n        return null;\n    }\n    // Might be a JSON string we can further descend...\n    if (typeof (value) === \"string\") {\n        try {\n            return spelunk(JSON.parse(value));\n        }\n        catch (error) { }\n    }\n    return null;\n}\nfunction checkError(method, error, params) {\n    // Undo the \"convenience\" some nodes are attempting to prevent backwards\n    // incompatibility; maybe for v6 consider forwarding reverts as errors\n    if (method === \"call\") {\n        const result = spelunk(error);\n        if (result) {\n            return result.data;\n        }\n        logger.throwError(\"missing revert data in call exception; Transaction reverted without a reason string\", Logger.errors.CALL_EXCEPTION, {\n            error, data: \"0x\"\n        });\n    }\n    // @TODO: Should we spelunk for message too?\n    let message = error.message;\n    if (error.code === Logger.errors.SERVER_ERROR && error.error && typeof (error.error.message) === \"string\") {\n        message = error.error.message;\n    }\n    else if (typeof (error.body) === \"string\") {\n        message = error.body;\n    }\n    else if (typeof (error.responseText) === \"string\") {\n        message = error.responseText;\n    }\n    message = (message || \"\").toLowerCase();\n    const transaction = params.transaction || params.signedTransaction;\n    // \"insufficient funds for gas * price + value + cost(data)\"\n    if (message.match(/insufficient funds|base fee exceeds gas limit/)) {\n        logger.throwError(\"insufficient funds for intrinsic transaction cost\", Logger.errors.INSUFFICIENT_FUNDS, {\n            error, method, transaction\n        });\n    }\n    // \"nonce too low\"\n    if (message.match(/nonce (is )?too low/)) {\n        logger.throwError(\"nonce has already been used\", Logger.errors.NONCE_EXPIRED, {\n            error, method, transaction\n        });\n    }\n    // \"replacement transaction underpriced\"\n    if (message.match(/replacement transaction underpriced/)) {\n        logger.throwError(\"replacement fee too low\", Logger.errors.REPLACEMENT_UNDERPRICED, {\n            error, method, transaction\n        });\n    }\n    // \"replacement transaction underpriced\"\n    if (message.match(/only replay-protected/)) {\n        logger.throwError(\"legacy pre-eip-155 transactions not supported\", Logger.errors.UNSUPPORTED_OPERATION, {\n            error, method, transaction\n        });\n    }\n    if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted/)) {\n        logger.throwError(\"cannot estimate gas; transaction may fail or may require manual gas limit\", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {\n            error, method, transaction\n        });\n    }\n    throw error;\n}\nfunction timer(timeout) {\n    return new Promise(function (resolve) {\n        setTimeout(resolve, timeout);\n    });\n}\nfunction getResult(payload) {\n    if (payload.error) {\n        // @TODO: not any\n        const error = new Error(payload.error.message);\n        error.code = payload.error.code;\n        error.data = payload.error.data;\n        throw error;\n    }\n    return payload.result;\n}\nfunction getLowerCase(value) {\n    if (value) {\n        return value.toLowerCase();\n    }\n    return value;\n}\nconst _constructorGuard = {};\nexport class JsonRpcSigner extends Signer {\n    constructor(constructorGuard, provider, addressOrIndex) {\n        logger.checkNew(new.target, JsonRpcSigner);\n        super();\n        if (constructorGuard !== _constructorGuard) {\n            throw new Error(\"do not call the JsonRpcSigner constructor directly; use provider.getSigner\");\n        }\n        defineReadOnly(this, \"provider\", provider);\n        if (addressOrIndex == null) {\n            addressOrIndex = 0;\n        }\n        if (typeof (addressOrIndex) === \"string\") {\n            defineReadOnly(this, \"_address\", this.provider.formatter.address(addressOrIndex));\n            defineReadOnly(this, \"_index\", null);\n        }\n        else if (typeof (addressOrIndex) === \"number\") {\n            defineReadOnly(this, \"_index\", addressOrIndex);\n            defineReadOnly(this, \"_address\", null);\n        }\n        else {\n            logger.throwArgumentError(\"invalid address or index\", \"addressOrIndex\", addressOrIndex);\n        }\n    }\n    connect(provider) {\n        return logger.throwError(\"cannot alter JSON-RPC Signer connection\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"connect\"\n        });\n    }\n    connectUnchecked() {\n        return new UncheckedJsonRpcSigner(_constructorGuard, this.provider, this._address || this._index);\n    }\n    getAddress() {\n        if (this._address) {\n            return Promise.resolve(this._address);\n        }\n        return this.provider.send(\"eth_accounts\", []).then((accounts) => {\n            if (accounts.length <= this._index) {\n                logger.throwError(\"unknown account #\" + this._index, Logger.errors.UNSUPPORTED_OPERATION, {\n                    operation: \"getAddress\"\n                });\n            }\n            return this.provider.formatter.address(accounts[this._index]);\n        });\n    }\n    sendUncheckedTransaction(transaction) {\n        transaction = shallowCopy(transaction);\n        const fromAddress = this.getAddress().then((address) => {\n            if (address) {\n                address = address.toLowerCase();\n            }\n            return address;\n        });\n        // The JSON-RPC for eth_sendTransaction uses 90000 gas; if the user\n        // wishes to use this, it is easy to specify explicitly, otherwise\n        // we look it up for them.\n        if (transaction.gasLimit == null) {\n            const estimate = shallowCopy(transaction);\n            estimate.from = fromAddress;\n            transaction.gasLimit = this.provider.estimateGas(estimate);\n        }\n        if (transaction.to != null) {\n            transaction.to = Promise.resolve(transaction.to).then((to) => __awaiter(this, void 0, void 0, function* () {\n                if (to == null) {\n                    return null;\n                }\n                const address = yield this.provider.resolveName(to);\n                if (address == null) {\n                    logger.throwArgumentError(\"provided ENS name resolves to null\", \"tx.to\", to);\n                }\n                return address;\n            }));\n        }\n        return resolveProperties({\n            tx: resolveProperties(transaction),\n            sender: fromAddress\n        }).then(({ tx, sender }) => {\n            if (tx.from != null) {\n                if (tx.from.toLowerCase() !== sender) {\n                    logger.throwArgumentError(\"from address mismatch\", \"transaction\", transaction);\n                }\n            }\n            else {\n                tx.from = sender;\n            }\n            const hexTx = this.provider.constructor.hexlifyTransaction(tx, { from: true });\n            return this.provider.send(\"eth_sendTransaction\", [hexTx]).then((hash) => {\n                return hash;\n            }, (error) => {\n                return checkError(\"sendTransaction\", error, hexTx);\n            });\n        });\n    }\n    signTransaction(transaction) {\n        return logger.throwError(\"signing transactions is unsupported\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"signTransaction\"\n        });\n    }\n    sendTransaction(transaction) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // This cannot be mined any earlier than any recent block\n            const blockNumber = yield this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval);\n            // Send the transaction\n            const hash = yield this.sendUncheckedTransaction(transaction);\n            try {\n                // Unfortunately, JSON-RPC only provides and opaque transaction hash\n                // for a response, and we need the actual transaction, so we poll\n                // for it; it should show up very quickly\n                return yield poll(() => __awaiter(this, void 0, void 0, function* () {\n                    const tx = yield this.provider.getTransaction(hash);\n                    if (tx === null) {\n                        return undefined;\n                    }\n                    return this.provider._wrapTransaction(tx, hash, blockNumber);\n                }), { oncePoll: this.provider });\n            }\n            catch (error) {\n                error.transactionHash = hash;\n                throw error;\n            }\n        });\n    }\n    signMessage(message) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const data = ((typeof (message) === \"string\") ? toUtf8Bytes(message) : message);\n            const address = yield this.getAddress();\n            return yield this.provider.send(\"personal_sign\", [hexlify(data), address.toLowerCase()]);\n        });\n    }\n    _legacySignMessage(message) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const data = ((typeof (message) === \"string\") ? toUtf8Bytes(message) : message);\n            const address = yield this.getAddress();\n            // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign\n            return yield this.provider.send(\"eth_sign\", [address.toLowerCase(), hexlify(data)]);\n        });\n    }\n    _signTypedData(domain, types, value) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Populate any ENS names (in-place)\n            const populated = yield _TypedDataEncoder.resolveNames(domain, types, value, (name) => {\n                return this.provider.resolveName(name);\n            });\n            const address = yield this.getAddress();\n            return yield this.provider.send(\"eth_signTypedData_v4\", [\n                address.toLowerCase(),\n                JSON.stringify(_TypedDataEncoder.getPayload(populated.domain, types, populated.value))\n            ]);\n        });\n    }\n    unlock(password) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const provider = this.provider;\n            const address = yield this.getAddress();\n            return provider.send(\"personal_unlockAccount\", [address.toLowerCase(), password, null]);\n        });\n    }\n}\nclass UncheckedJsonRpcSigner extends JsonRpcSigner {\n    sendTransaction(transaction) {\n        return this.sendUncheckedTransaction(transaction).then((hash) => {\n            return {\n                hash: hash,\n                nonce: null,\n                gasLimit: null,\n                gasPrice: null,\n                data: null,\n                value: null,\n                chainId: null,\n                confirmations: 0,\n                from: null,\n                wait: (confirmations) => { return this.provider.waitForTransaction(hash, confirmations); }\n            };\n        });\n    }\n}\nconst allowedTransactionKeys = {\n    chainId: true, data: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true,\n    type: true, accessList: true,\n    maxFeePerGas: true, maxPriorityFeePerGas: true\n};\nexport class JsonRpcProvider extends BaseProvider {\n    constructor(url, network) {\n        logger.checkNew(new.target, JsonRpcProvider);\n        let networkOrReady = network;\n        // The network is unknown, query the JSON-RPC for it\n        if (networkOrReady == null) {\n            networkOrReady = new Promise((resolve, reject) => {\n                setTimeout(() => {\n                    this.detectNetwork().then((network) => {\n                        resolve(network);\n                    }, (error) => {\n                        reject(error);\n                    });\n                }, 0);\n            });\n        }\n        super(networkOrReady);\n        // Default URL\n        if (!url) {\n            url = getStatic(this.constructor, \"defaultUrl\")();\n        }\n        if (typeof (url) === \"string\") {\n            defineReadOnly(this, \"connection\", Object.freeze({\n                url: url\n            }));\n        }\n        else {\n            defineReadOnly(this, \"connection\", Object.freeze(shallowCopy(url)));\n        }\n        this._nextId = 42;\n    }\n    get _cache() {\n        if (this._eventLoopCache == null) {\n            this._eventLoopCache = {};\n        }\n        return this._eventLoopCache;\n    }\n    static defaultUrl() {\n        return \"http:/\\/localhost:8545\";\n    }\n    detectNetwork() {\n        if (!this._cache[\"detectNetwork\"]) {\n            this._cache[\"detectNetwork\"] = this._uncachedDetectNetwork();\n            // Clear this cache at the beginning of the next event loop\n            setTimeout(() => {\n                this._cache[\"detectNetwork\"] = null;\n            }, 0);\n        }\n        return this._cache[\"detectNetwork\"];\n    }\n    _uncachedDetectNetwork() {\n        return __awaiter(this, void 0, void 0, function* () {\n            yield timer(0);\n            let chainId = null;\n            try {\n                chainId = yield this.send(\"eth_chainId\", []);\n            }\n            catch (error) {\n                try {\n                    chainId = yield this.send(\"net_version\", []);\n                }\n                catch (error) { }\n            }\n            if (chainId != null) {\n                const getNetwork = getStatic(this.constructor, \"getNetwork\");\n                try {\n                    return getNetwork(BigNumber.from(chainId).toNumber());\n                }\n                catch (error) {\n                    return logger.throwError(\"could not detect network\", Logger.errors.NETWORK_ERROR, {\n                        chainId: chainId,\n                        event: \"invalidNetwork\",\n                        serverError: error\n                    });\n                }\n            }\n            return logger.throwError(\"could not detect network\", Logger.errors.NETWORK_ERROR, {\n                event: \"noNetwork\"\n            });\n        });\n    }\n    getSigner(addressOrIndex) {\n        return new JsonRpcSigner(_constructorGuard, this, addressOrIndex);\n    }\n    getUncheckedSigner(addressOrIndex) {\n        return this.getSigner(addressOrIndex).connectUnchecked();\n    }\n    listAccounts() {\n        return this.send(\"eth_accounts\", []).then((accounts) => {\n            return accounts.map((a) => this.formatter.address(a));\n        });\n    }\n    send(method, params) {\n        const request = {\n            method: method,\n            params: params,\n            id: (this._nextId++),\n            jsonrpc: \"2.0\"\n        };\n        this.emit(\"debug\", {\n            action: \"request\",\n            request: deepCopy(request),\n            provider: this\n        });\n        // We can expand this in the future to any call, but for now these\n        // are the biggest wins and do not require any serializing parameters.\n        const cache = ([\"eth_chainId\", \"eth_blockNumber\"].indexOf(method) >= 0);\n        if (cache && this._cache[method]) {\n            return this._cache[method];\n        }\n        const result = fetchJson(this.connection, JSON.stringify(request), getResult).then((result) => {\n            this.emit(\"debug\", {\n                action: \"response\",\n                request: request,\n                response: result,\n                provider: this\n            });\n            return result;\n        }, (error) => {\n            this.emit(\"debug\", {\n                action: \"response\",\n                error: error,\n                request: request,\n                provider: this\n            });\n            throw error;\n        });\n        // Cache the fetch, but clear it on the next event loop\n        if (cache) {\n            this._cache[method] = result;\n            setTimeout(() => {\n                this._cache[method] = null;\n            }, 0);\n        }\n        return result;\n    }\n    prepareRequest(method, params) {\n        switch (method) {\n            case \"getBlockNumber\":\n                return [\"eth_blockNumber\", []];\n            case \"getGasPrice\":\n                return [\"eth_gasPrice\", []];\n            case \"getBalance\":\n                return [\"eth_getBalance\", [getLowerCase(params.address), params.blockTag]];\n            case \"getTransactionCount\":\n                return [\"eth_getTransactionCount\", [getLowerCase(params.address), params.blockTag]];\n            case \"getCode\":\n                return [\"eth_getCode\", [getLowerCase(params.address), params.blockTag]];\n            case \"getStorageAt\":\n                return [\"eth_getStorageAt\", [getLowerCase(params.address), params.position, params.blockTag]];\n            case \"sendTransaction\":\n                return [\"eth_sendRawTransaction\", [params.signedTransaction]];\n            case \"getBlock\":\n                if (params.blockTag) {\n                    return [\"eth_getBlockByNumber\", [params.blockTag, !!params.includeTransactions]];\n                }\n                else if (params.blockHash) {\n                    return [\"eth_getBlockByHash\", [params.blockHash, !!params.includeTransactions]];\n                }\n                return null;\n            case \"getTransaction\":\n                return [\"eth_getTransactionByHash\", [params.transactionHash]];\n            case \"getTransactionReceipt\":\n                return [\"eth_getTransactionReceipt\", [params.transactionHash]];\n            case \"call\": {\n                const hexlifyTransaction = getStatic(this.constructor, \"hexlifyTransaction\");\n                return [\"eth_call\", [hexlifyTransaction(params.transaction, { from: true }), params.blockTag]];\n            }\n            case \"estimateGas\": {\n                const hexlifyTransaction = getStatic(this.constructor, \"hexlifyTransaction\");\n                return [\"eth_estimateGas\", [hexlifyTransaction(params.transaction, { from: true })]];\n            }\n            case \"getLogs\":\n                if (params.filter && params.filter.address != null) {\n                    params.filter.address = getLowerCase(params.filter.address);\n                }\n                return [\"eth_getLogs\", [params.filter]];\n            default:\n                break;\n        }\n        return null;\n    }\n    perform(method, params) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Legacy networks do not like the type field being passed along (which\n            // is fair), so we delete type if it is 0 and a non-EIP-1559 network\n            if (method === \"call\" || method === \"estimateGas\") {\n                const tx = params.transaction;\n                if (tx && tx.type != null && BigNumber.from(tx.type).isZero()) {\n                    // If there are no EIP-1559 properties, it might be non-EIP-a559\n                    if (tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null) {\n                        const feeData = yield this.getFeeData();\n                        if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) {\n                            // Network doesn't know about EIP-1559 (and hence type)\n                            params = shallowCopy(params);\n                            params.transaction = shallowCopy(tx);\n                            delete params.transaction.type;\n                        }\n                    }\n                }\n            }\n            const args = this.prepareRequest(method, params);\n            if (args == null) {\n                logger.throwError(method + \" not implemented\", Logger.errors.NOT_IMPLEMENTED, { operation: method });\n            }\n            try {\n                return yield this.send(args[0], args[1]);\n            }\n            catch (error) {\n                return checkError(method, error, params);\n            }\n        });\n    }\n    _startEvent(event) {\n        if (event.tag === \"pending\") {\n            this._startPending();\n        }\n        super._startEvent(event);\n    }\n    _startPending() {\n        if (this._pendingFilter != null) {\n            return;\n        }\n        const self = this;\n        const pendingFilter = this.send(\"eth_newPendingTransactionFilter\", []);\n        this._pendingFilter = pendingFilter;\n        pendingFilter.then(function (filterId) {\n            function poll() {\n                self.send(\"eth_getFilterChanges\", [filterId]).then(function (hashes) {\n                    if (self._pendingFilter != pendingFilter) {\n                        return null;\n                    }\n                    let seq = Promise.resolve();\n                    hashes.forEach(function (hash) {\n                        // @TODO: This should be garbage collected at some point... How? When?\n                        self._emitted[\"t:\" + hash.toLowerCase()] = \"pending\";\n                        seq = seq.then(function () {\n                            return self.getTransaction(hash).then(function (tx) {\n                                self.emit(\"pending\", tx);\n                                return null;\n                            });\n                        });\n                    });\n                    return seq.then(function () {\n                        return timer(1000);\n                    });\n                }).then(function () {\n                    if (self._pendingFilter != pendingFilter) {\n                        self.send(\"eth_uninstallFilter\", [filterId]);\n                        return;\n                    }\n                    setTimeout(function () { poll(); }, 0);\n                    return null;\n                }).catch((error) => { });\n            }\n            poll();\n            return filterId;\n        }).catch((error) => { });\n    }\n    _stopEvent(event) {\n        if (event.tag === \"pending\" && this.listenerCount(\"pending\") === 0) {\n            this._pendingFilter = null;\n        }\n        super._stopEvent(event);\n    }\n    // Convert an ethers.js transaction into a JSON-RPC transaction\n    //  - gasLimit => gas\n    //  - All values hexlified\n    //  - All numeric values zero-striped\n    //  - All addresses are lowercased\n    // NOTE: This allows a TransactionRequest, but all values should be resolved\n    //       before this is called\n    // @TODO: This will likely be removed in future versions and prepareRequest\n    //        will be the preferred method for this.\n    static hexlifyTransaction(transaction, allowExtra) {\n        // Check only allowed properties are given\n        const allowed = shallowCopy(allowedTransactionKeys);\n        if (allowExtra) {\n            for (const key in allowExtra) {\n                if (allowExtra[key]) {\n                    allowed[key] = true;\n                }\n            }\n        }\n        checkProperties(transaction, allowed);\n        const result = {};\n        // JSON-RPC now requires numeric values to be \"quantity\" values\n        [\"chainId\", \"gasLimit\", \"gasPrice\", \"type\", \"maxFeePerGas\", \"maxPriorityFeePerGas\", \"nonce\", \"value\"].forEach(function (key) {\n            if (transaction[key] == null) {\n                return;\n            }\n            const value = hexValue(transaction[key]);\n            if (key === \"gasLimit\") {\n                key = \"gas\";\n            }\n            result[key] = value;\n        });\n        [\"from\", \"to\", \"data\"].forEach(function (key) {\n            if (transaction[key] == null) {\n                return;\n            }\n            result[key] = hexlify(transaction[key]);\n        });\n        if (transaction.accessList) {\n            result[\"accessList\"] = accessListify(transaction.accessList);\n        }\n        return result;\n    }\n}\n//# sourceMappingURL=json-rpc-provider.js.map","\"use strict\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nlet WS = null;\ntry {\n    WS = WebSocket;\n    if (WS == null) {\n        throw new Error(\"inject please\");\n    }\n}\ncatch (error) {\n    const logger = new Logger(version);\n    WS = function () {\n        logger.throwError(\"WebSockets not supported in this environment\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"new WebSocket()\"\n        });\n    };\n}\n//export default WS;\n//module.exports = WS;\nexport { WS as WebSocket };\n//# sourceMappingURL=ws.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { JsonRpcProvider } from \"./json-rpc-provider\";\nimport { WebSocket } from \"./ws\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n/**\n *  Notes:\n *\n *  This provider differs a bit from the polling providers. One main\n *  difference is how it handles consistency. The polling providers\n *  will stall responses to ensure a consistent state, while this\n *  WebSocket provider assumes the connected backend will manage this.\n *\n *  For example, if a polling provider emits an event which indicates\n *  the event occurred in blockhash XXX, a call to fetch that block by\n *  its hash XXX, if not present will retry until it is present. This\n *  can occur when querying a pool of nodes that are mildly out of sync\n *  with each other.\n */\nlet NextId = 1;\n// For more info about the Real-time Event API see:\n//   https://geth.ethereum.org/docs/rpc/pubsub\nexport class WebSocketProvider extends JsonRpcProvider {\n    constructor(url, network) {\n        // This will be added in the future; please open an issue to expedite\n        if (network === \"any\") {\n            logger.throwError(\"WebSocketProvider does not support 'any' network yet\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"network:any\"\n            });\n        }\n        if (typeof (url) === \"string\") {\n            super(url, network);\n        }\n        else {\n            super(\"_websocket\", network);\n        }\n        this._pollingInterval = -1;\n        this._wsReady = false;\n        if (typeof (url) === \"string\") {\n            defineReadOnly(this, \"_websocket\", new WebSocket(this.connection.url));\n        }\n        else {\n            defineReadOnly(this, \"_websocket\", url);\n        }\n        defineReadOnly(this, \"_requests\", {});\n        defineReadOnly(this, \"_subs\", {});\n        defineReadOnly(this, \"_subIds\", {});\n        defineReadOnly(this, \"_detectNetwork\", super.detectNetwork());\n        // Stall sending requests until the socket is open...\n        this.websocket.onopen = () => {\n            this._wsReady = true;\n            Object.keys(this._requests).forEach((id) => {\n                this.websocket.send(this._requests[id].payload);\n            });\n        };\n        this.websocket.onmessage = (messageEvent) => {\n            const data = messageEvent.data;\n            const result = JSON.parse(data);\n            if (result.id != null) {\n                const id = String(result.id);\n                const request = this._requests[id];\n                delete this._requests[id];\n                if (result.result !== undefined) {\n                    request.callback(null, result.result);\n                    this.emit(\"debug\", {\n                        action: \"response\",\n                        request: JSON.parse(request.payload),\n                        response: result.result,\n                        provider: this\n                    });\n                }\n                else {\n                    let error = null;\n                    if (result.error) {\n                        error = new Error(result.error.message || \"unknown error\");\n                        defineReadOnly(error, \"code\", result.error.code || null);\n                        defineReadOnly(error, \"response\", data);\n                    }\n                    else {\n                        error = new Error(\"unknown error\");\n                    }\n                    request.callback(error, undefined);\n                    this.emit(\"debug\", {\n                        action: \"response\",\n                        error: error,\n                        request: JSON.parse(request.payload),\n                        provider: this\n                    });\n                }\n            }\n            else if (result.method === \"eth_subscription\") {\n                // Subscription...\n                const sub = this._subs[result.params.subscription];\n                if (sub) {\n                    //this.emit.apply(this,                  );\n                    sub.processFunc(result.params.result);\n                }\n            }\n            else {\n                console.warn(\"this should not happen\");\n            }\n        };\n        // This Provider does not actually poll, but we want to trigger\n        // poll events for things that depend on them (like stalling for\n        // block and transaction lookups)\n        const fauxPoll = setInterval(() => {\n            this.emit(\"poll\");\n        }, 1000);\n        if (fauxPoll.unref) {\n            fauxPoll.unref();\n        }\n    }\n    // Cannot narrow the type of _websocket, as that is not backwards compatible\n    // so we add a getter and let the WebSocket be a public API.\n    get websocket() { return this._websocket; }\n    detectNetwork() {\n        return this._detectNetwork;\n    }\n    get pollingInterval() {\n        return 0;\n    }\n    resetEventsBlock(blockNumber) {\n        logger.throwError(\"cannot reset events block on WebSocketProvider\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"resetEventBlock\"\n        });\n    }\n    set pollingInterval(value) {\n        logger.throwError(\"cannot set polling interval on WebSocketProvider\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"setPollingInterval\"\n        });\n    }\n    poll() {\n        return __awaiter(this, void 0, void 0, function* () {\n            return null;\n        });\n    }\n    set polling(value) {\n        if (!value) {\n            return;\n        }\n        logger.throwError(\"cannot set polling on WebSocketProvider\", Logger.errors.UNSUPPORTED_OPERATION, {\n            operation: \"setPolling\"\n        });\n    }\n    send(method, params) {\n        const rid = NextId++;\n        return new Promise((resolve, reject) => {\n            function callback(error, result) {\n                if (error) {\n                    return reject(error);\n                }\n                return resolve(result);\n            }\n            const payload = JSON.stringify({\n                method: method,\n                params: params,\n                id: rid,\n                jsonrpc: \"2.0\"\n            });\n            this.emit(\"debug\", {\n                action: \"request\",\n                request: JSON.parse(payload),\n                provider: this\n            });\n            this._requests[String(rid)] = { callback, payload };\n            if (this._wsReady) {\n                this.websocket.send(payload);\n            }\n        });\n    }\n    static defaultUrl() {\n        return \"ws:/\\/localhost:8546\";\n    }\n    _subscribe(tag, param, processFunc) {\n        return __awaiter(this, void 0, void 0, function* () {\n            let subIdPromise = this._subIds[tag];\n            if (subIdPromise == null) {\n                subIdPromise = Promise.all(param).then((param) => {\n                    return this.send(\"eth_subscribe\", param);\n                });\n                this._subIds[tag] = subIdPromise;\n            }\n            const subId = yield subIdPromise;\n            this._subs[subId] = { tag, processFunc };\n        });\n    }\n    _startEvent(event) {\n        switch (event.type) {\n            case \"block\":\n                this._subscribe(\"block\", [\"newHeads\"], (result) => {\n                    const blockNumber = BigNumber.from(result.number).toNumber();\n                    this._emitted.block = blockNumber;\n                    this.emit(\"block\", blockNumber);\n                });\n                break;\n            case \"pending\":\n                this._subscribe(\"pending\", [\"newPendingTransactions\"], (result) => {\n                    this.emit(\"pending\", result);\n                });\n                break;\n            case \"filter\":\n                this._subscribe(event.tag, [\"logs\", this._getFilter(event.filter)], (result) => {\n                    if (result.removed == null) {\n                        result.removed = false;\n                    }\n                    this.emit(event.filter, this.formatter.filterLog(result));\n                });\n                break;\n            case \"tx\": {\n                const emitReceipt = (event) => {\n                    const hash = event.hash;\n                    this.getTransactionReceipt(hash).then((receipt) => {\n                        if (!receipt) {\n                            return;\n                        }\n                        this.emit(hash, receipt);\n                    });\n                };\n                // In case it is already mined\n                emitReceipt(event);\n                // To keep things simple, we start up a single newHeads subscription\n                // to keep an eye out for transactions we are watching for.\n                // Starting a subscription for an event (i.e. \"tx\") that is already\n                // running is (basically) a nop.\n                this._subscribe(\"tx\", [\"newHeads\"], (result) => {\n                    this._events.filter((e) => (e.type === \"tx\")).forEach(emitReceipt);\n                });\n                break;\n            }\n            // Nothing is needed\n            case \"debug\":\n            case \"poll\":\n            case \"willPoll\":\n            case \"didPoll\":\n            case \"error\":\n                break;\n            default:\n                console.log(\"unhandled:\", event);\n                break;\n        }\n    }\n    _stopEvent(event) {\n        let tag = event.tag;\n        if (event.type === \"tx\") {\n            // There are remaining transaction event listeners\n            if (this._events.filter((e) => (e.type === \"tx\")).length) {\n                return;\n            }\n            tag = \"tx\";\n        }\n        else if (this.listenerCount(event.event)) {\n            // There are remaining event listeners\n            return;\n        }\n        const subId = this._subIds[tag];\n        if (!subId) {\n            return;\n        }\n        delete this._subIds[tag];\n        subId.then((subId) => {\n            if (!this._subs[subId]) {\n                return;\n            }\n            delete this._subs[subId];\n            this.send(\"eth_unsubscribe\", [subId]);\n        });\n    }\n    destroy() {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Wait until we have connected before trying to disconnect\n            if (this.websocket.readyState === WebSocket.CONNECTING) {\n                yield (new Promise((resolve) => {\n                    this.websocket.onopen = function () {\n                        resolve(true);\n                    };\n                    this.websocket.onerror = function () {\n                        resolve(false);\n                    };\n                }));\n            }\n            // Hangup\n            // See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes\n            this.websocket.close(1000);\n        });\n    }\n}\n//# sourceMappingURL=websocket-provider.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { defineReadOnly, getStatic } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { JsonRpcProvider } from \"./json-rpc-provider\";\n// A StaticJsonRpcProvider is useful when you *know* for certain that\n// the backend will never change, as it never calls eth_chainId to\n// verify its backend. However, if the backend does change, the effects\n// are undefined and may include:\n// - inconsistent results\n// - locking up the UI\n// - block skew warnings\n// - wrong results\n// If the network is not explicit (i.e. auto-detection is expected), the\n// node MUST be running and available to respond to requests BEFORE this\n// is instantiated.\nexport class StaticJsonRpcProvider extends JsonRpcProvider {\n    detectNetwork() {\n        const _super = Object.create(null, {\n            detectNetwork: { get: () => super.detectNetwork }\n        });\n        return __awaiter(this, void 0, void 0, function* () {\n            let network = this.network;\n            if (network == null) {\n                network = yield _super.detectNetwork.call(this);\n                if (!network) {\n                    logger.throwError(\"no network detected\", Logger.errors.UNKNOWN_ERROR, {});\n                }\n                // If still not set, set it\n                if (this._network == null) {\n                    // A static network does not support \"any\"\n                    defineReadOnly(this, \"_network\", network);\n                    this.emit(\"network\", network, null);\n                }\n            }\n            return network;\n        });\n    }\n}\nexport class UrlJsonRpcProvider extends StaticJsonRpcProvider {\n    constructor(network, apiKey) {\n        logger.checkAbstract(new.target, UrlJsonRpcProvider);\n        // Normalize the Network and API Key\n        network = getStatic(new.target, \"getNetwork\")(network);\n        apiKey = getStatic(new.target, \"getApiKey\")(apiKey);\n        const connection = getStatic(new.target, \"getUrl\")(network, apiKey);\n        super(connection, network);\n        if (typeof (apiKey) === \"string\") {\n            defineReadOnly(this, \"apiKey\", apiKey);\n        }\n        else if (apiKey != null) {\n            Object.keys(apiKey).forEach((key) => {\n                defineReadOnly(this, key, apiKey[key]);\n            });\n        }\n    }\n    _startPending() {\n        logger.warn(\"WARNING: API provider does not support pending filters\");\n    }\n    isCommunityResource() {\n        return false;\n    }\n    getSigner(address) {\n        return logger.throwError(\"API provider does not support signing\", Logger.errors.UNSUPPORTED_OPERATION, { operation: \"getSigner\" });\n    }\n    listAccounts() {\n        return Promise.resolve([]);\n    }\n    // Return a defaultApiKey if null, otherwise validate the API key\n    static getApiKey(apiKey) {\n        return apiKey;\n    }\n    // Returns the url or connection for the given network and API key. The\n    // API key will have been sanitized by the getApiKey first, so any validation\n    // or transformations can be done there.\n    static getUrl(network, apiKey) {\n        return logger.throwError(\"not implemented; sub-classes must override getUrl\", Logger.errors.NOT_IMPLEMENTED, {\n            operation: \"getUrl\"\n        });\n    }\n}\n//# sourceMappingURL=url-json-rpc-provider.js.map","\"use strict\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { showThrottleMessage } from \"./formatter\";\nimport { WebSocketProvider } from \"./websocket-provider\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\n// This key was provided to ethers.js by Alchemy to be used by the\n// default provider, but it is recommended that for your own\n// production environments, that you acquire your own API key at:\n//   https://dashboard.alchemyapi.io\nconst defaultApiKey = \"_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC\";\nexport class AlchemyWebSocketProvider extends WebSocketProvider {\n    constructor(network, apiKey) {\n        const provider = new AlchemyProvider(network, apiKey);\n        const url = provider.connection.url.replace(/^http/i, \"ws\")\n            .replace(\".alchemyapi.\", \".ws.alchemyapi.\");\n        super(url, provider.network);\n        defineReadOnly(this, \"apiKey\", provider.apiKey);\n    }\n    isCommunityResource() {\n        return (this.apiKey === defaultApiKey);\n    }\n}\nexport class AlchemyProvider extends UrlJsonRpcProvider {\n    static getWebSocketProvider(network, apiKey) {\n        return new AlchemyWebSocketProvider(network, apiKey);\n    }\n    static getApiKey(apiKey) {\n        if (apiKey == null) {\n            return defaultApiKey;\n        }\n        if (apiKey && typeof (apiKey) !== \"string\") {\n            logger.throwArgumentError(\"invalid apiKey\", \"apiKey\", apiKey);\n        }\n        return apiKey;\n    }\n    static getUrl(network, apiKey) {\n        let host = null;\n        switch (network.name) {\n            case \"homestead\":\n                host = \"eth-mainnet.alchemyapi.io/v2/\";\n                break;\n            case \"ropsten\":\n                host = \"eth-ropsten.alchemyapi.io/v2/\";\n                break;\n            case \"rinkeby\":\n                host = \"eth-rinkeby.alchemyapi.io/v2/\";\n                break;\n            case \"goerli\":\n                host = \"eth-goerli.alchemyapi.io/v2/\";\n                break;\n            case \"kovan\":\n                host = \"eth-kovan.alchemyapi.io/v2/\";\n                break;\n            case \"matic\":\n                host = \"polygon-mainnet.g.alchemy.com/v2/\";\n                break;\n            case \"maticmum\":\n                host = \"polygon-mumbai.g.alchemy.com/v2/\";\n                break;\n            case \"arbitrum\":\n                host = \"arb-mainnet.g.alchemy.com/v2/\";\n                break;\n            case \"arbitrum-rinkeby\":\n                host = \"arb-rinkeby.g.alchemy.com/v2/\";\n                break;\n            case \"optimism\":\n                host = \"opt-mainnet.g.alchemy.com/v2/\";\n                break;\n            case \"optimism-kovan\":\n                host = \"opt-kovan.g.alchemy.com/v2/\";\n                break;\n            default:\n                logger.throwArgumentError(\"unsupported network\", \"network\", arguments[0]);\n        }\n        return {\n            allowGzip: true,\n            url: (\"https:/\" + \"/\" + host + apiKey),\n            throttleCallback: (attempt, url) => {\n                if (apiKey === defaultApiKey) {\n                    showThrottleMessage();\n                }\n                return Promise.resolve(true);\n            }\n        };\n    }\n    isCommunityResource() {\n        return (this.apiKey === defaultApiKey);\n    }\n}\n//# sourceMappingURL=alchemy-provider.js.map","import { showThrottleMessage } from \"./formatter\";\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nconst defaultApiKey = \"9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972\";\nfunction getHost(name) {\n    switch (name) {\n        case \"homestead\":\n            return \"rpc.ankr.com/eth/\";\n        case \"matic\":\n            return \"rpc.ankr.com/polygon/\";\n        case \"arbitrum\":\n            return \"rpc.ankr.com/arbitrum/\";\n    }\n    return logger.throwArgumentError(\"unsupported network\", \"name\", name);\n}\nexport class AnkrProvider extends UrlJsonRpcProvider {\n    isCommunityResource() {\n        return (this.apiKey === defaultApiKey);\n    }\n    static getApiKey(apiKey) {\n        if (apiKey == null) {\n            return defaultApiKey;\n        }\n        return apiKey;\n    }\n    static getUrl(network, apiKey) {\n        if (apiKey == null) {\n            apiKey = defaultApiKey;\n        }\n        const connection = {\n            allowGzip: true,\n            url: (\"https:/\\/\" + getHost(network.name) + apiKey),\n            throttleCallback: (attempt, url) => {\n                if (apiKey.apiKey === defaultApiKey) {\n                    showThrottleMessage();\n                }\n                return Promise.resolve(true);\n            }\n        };\n        if (apiKey.projectSecret != null) {\n            connection.user = \"\";\n            connection.password = apiKey.projectSecret;\n        }\n        return connection;\n    }\n}\n//# sourceMappingURL=ankr-provider.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport class CloudflareProvider extends UrlJsonRpcProvider {\n    static getApiKey(apiKey) {\n        if (apiKey != null) {\n            logger.throwArgumentError(\"apiKey not supported for cloudflare\", \"apiKey\", apiKey);\n        }\n        return null;\n    }\n    static getUrl(network, apiKey) {\n        let host = null;\n        switch (network.name) {\n            case \"homestead\":\n                host = \"https://cloudflare-eth.com/\";\n                break;\n            default:\n                logger.throwArgumentError(\"unsupported network\", \"network\", arguments[0]);\n        }\n        return host;\n    }\n    perform(method, params) {\n        const _super = Object.create(null, {\n            perform: { get: () => super.perform }\n        });\n        return __awaiter(this, void 0, void 0, function* () {\n            // The Cloudflare provider does not support eth_blockNumber,\n            // so we get the latest block and pull it from that\n            if (method === \"getBlockNumber\") {\n                const block = yield _super.perform.call(this, \"getBlock\", { blockTag: \"latest\" });\n                return block.number;\n            }\n            return _super.perform.call(this, method, params);\n        });\n    }\n}\n//# sourceMappingURL=cloudflare-provider.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { hexlify, hexValue, isHexString } from \"@ethersproject/bytes\";\nimport { deepCopy, defineReadOnly } from \"@ethersproject/properties\";\nimport { accessListify } from \"@ethersproject/transactions\";\nimport { fetchJson } from \"@ethersproject/web\";\nimport { showThrottleMessage } from \"./formatter\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { BaseProvider } from \"./base-provider\";\n// The transaction has already been sanitized by the calls in Provider\nfunction getTransactionPostData(transaction) {\n    const result = {};\n    for (let key in transaction) {\n        if (transaction[key] == null) {\n            continue;\n        }\n        let value = transaction[key];\n        if (key === \"type\" && value === 0) {\n            continue;\n        }\n        // Quantity-types require no leading zero, unless 0\n        if ({ type: true, gasLimit: true, gasPrice: true, maxFeePerGs: true, maxPriorityFeePerGas: true, nonce: true, value: true }[key]) {\n            value = hexValue(hexlify(value));\n        }\n        else if (key === \"accessList\") {\n            value = \"[\" + accessListify(value).map((set) => {\n                return `{address:\"${set.address}\",storageKeys:[\"${set.storageKeys.join('\",\"')}\"]}`;\n            }).join(\",\") + \"]\";\n        }\n        else {\n            value = hexlify(value);\n        }\n        result[key] = value;\n    }\n    return result;\n}\nfunction getResult(result) {\n    // getLogs, getHistory have weird success responses\n    if (result.status == 0 && (result.message === \"No records found\" || result.message === \"No transactions found\")) {\n        return result.result;\n    }\n    if (result.status != 1 || result.message != \"OK\") {\n        const error = new Error(\"invalid response\");\n        error.result = JSON.stringify(result);\n        if ((result.result || \"\").toLowerCase().indexOf(\"rate limit\") >= 0) {\n            error.throttleRetry = true;\n        }\n        throw error;\n    }\n    return result.result;\n}\nfunction getJsonResult(result) {\n    // This response indicates we are being throttled\n    if (result && result.status == 0 && result.message == \"NOTOK\" && (result.result || \"\").toLowerCase().indexOf(\"rate limit\") >= 0) {\n        const error = new Error(\"throttled response\");\n        error.result = JSON.stringify(result);\n        error.throttleRetry = true;\n        throw error;\n    }\n    if (result.jsonrpc != \"2.0\") {\n        // @TODO: not any\n        const error = new Error(\"invalid response\");\n        error.result = JSON.stringify(result);\n        throw error;\n    }\n    if (result.error) {\n        // @TODO: not any\n        const error = new Error(result.error.message || \"unknown error\");\n        if (result.error.code) {\n            error.code = result.error.code;\n        }\n        if (result.error.data) {\n            error.data = result.error.data;\n        }\n        throw error;\n    }\n    return result.result;\n}\n// The blockTag was normalized as a string by the Provider pre-perform operations\nfunction checkLogTag(blockTag) {\n    if (blockTag === \"pending\") {\n        throw new Error(\"pending not supported\");\n    }\n    if (blockTag === \"latest\") {\n        return blockTag;\n    }\n    return parseInt(blockTag.substring(2), 16);\n}\nconst defaultApiKey = \"9D13ZE7XSBTJ94N9BNJ2MA33VMAY2YPIRB\";\nfunction checkError(method, error, transaction) {\n    // Undo the \"convenience\" some nodes are attempting to prevent backwards\n    // incompatibility; maybe for v6 consider forwarding reverts as errors\n    if (method === \"call\" && error.code === Logger.errors.SERVER_ERROR) {\n        const e = error.error;\n        // Etherscan keeps changing their string\n        if (e && (e.message.match(/reverted/i) || e.message.match(/VM execution error/i))) {\n            // Etherscan prefixes the data like \"Reverted 0x1234\"\n            let data = e.data;\n            if (data) {\n                data = \"0x\" + data.replace(/^.*0x/i, \"\");\n            }\n            if (isHexString(data)) {\n                return data;\n            }\n            logger.throwError(\"missing revert data in call exception\", Logger.errors.CALL_EXCEPTION, {\n                error, data: \"0x\"\n            });\n        }\n    }\n    // Get the message from any nested error structure\n    let message = error.message;\n    if (error.code === Logger.errors.SERVER_ERROR) {\n        if (error.error && typeof (error.error.message) === \"string\") {\n            message = error.error.message;\n        }\n        else if (typeof (error.body) === \"string\") {\n            message = error.body;\n        }\n        else if (typeof (error.responseText) === \"string\") {\n            message = error.responseText;\n        }\n    }\n    message = (message || \"\").toLowerCase();\n    // \"Insufficient funds. The account you tried to send transaction from does not have enough funds. Required 21464000000000 and got: 0\"\n    if (message.match(/insufficient funds/)) {\n        logger.throwError(\"insufficient funds for intrinsic transaction cost\", Logger.errors.INSUFFICIENT_FUNDS, {\n            error, method, transaction\n        });\n    }\n    // \"Transaction with the same hash was already imported.\"\n    if (message.match(/same hash was already imported|transaction nonce is too low|nonce too low/)) {\n        logger.throwError(\"nonce has already been used\", Logger.errors.NONCE_EXPIRED, {\n            error, method, transaction\n        });\n    }\n    // \"Transaction gas price is too low. There is another transaction with same nonce in the queue. Try increasing the gas price or incrementing the nonce.\"\n    if (message.match(/another transaction with same nonce/)) {\n        logger.throwError(\"replacement fee too low\", Logger.errors.REPLACEMENT_UNDERPRICED, {\n            error, method, transaction\n        });\n    }\n    if (message.match(/execution failed due to an exception|execution reverted/)) {\n        logger.throwError(\"cannot estimate gas; transaction may fail or may require manual gas limit\", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {\n            error, method, transaction\n        });\n    }\n    throw error;\n}\nexport class EtherscanProvider extends BaseProvider {\n    constructor(network, apiKey) {\n        logger.checkNew(new.target, EtherscanProvider);\n        super(network);\n        defineReadOnly(this, \"baseUrl\", this.getBaseUrl());\n        defineReadOnly(this, \"apiKey\", apiKey || defaultApiKey);\n    }\n    getBaseUrl() {\n        switch (this.network ? this.network.name : \"invalid\") {\n            case \"homestead\":\n                return \"https:/\\/api.etherscan.io\";\n            case \"ropsten\":\n                return \"https:/\\/api-ropsten.etherscan.io\";\n            case \"rinkeby\":\n                return \"https:/\\/api-rinkeby.etherscan.io\";\n            case \"kovan\":\n                return \"https:/\\/api-kovan.etherscan.io\";\n            case \"goerli\":\n                return \"https:/\\/api-goerli.etherscan.io\";\n            default:\n        }\n        return logger.throwArgumentError(\"unsupported network\", \"network\", name);\n    }\n    getUrl(module, params) {\n        const query = Object.keys(params).reduce((accum, key) => {\n            const value = params[key];\n            if (value != null) {\n                accum += `&${key}=${value}`;\n            }\n            return accum;\n        }, \"\");\n        const apiKey = ((this.apiKey) ? `&apikey=${this.apiKey}` : \"\");\n        return `${this.baseUrl}/api?module=${module}${query}${apiKey}`;\n    }\n    getPostUrl() {\n        return `${this.baseUrl}/api`;\n    }\n    getPostData(module, params) {\n        params.module = module;\n        params.apikey = this.apiKey;\n        return params;\n    }\n    fetch(module, params, post) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const url = (post ? this.getPostUrl() : this.getUrl(module, params));\n            const payload = (post ? this.getPostData(module, params) : null);\n            const procFunc = (module === \"proxy\") ? getJsonResult : getResult;\n            this.emit(\"debug\", {\n                action: \"request\",\n                request: url,\n                provider: this\n            });\n            const connection = {\n                url: url,\n                throttleSlotInterval: 1000,\n                throttleCallback: (attempt, url) => {\n                    if (this.isCommunityResource()) {\n                        showThrottleMessage();\n                    }\n                    return Promise.resolve(true);\n                }\n            };\n            let payloadStr = null;\n            if (payload) {\n                connection.headers = { \"content-type\": \"application/x-www-form-urlencoded; charset=UTF-8\" };\n                payloadStr = Object.keys(payload).map((key) => {\n                    return `${key}=${payload[key]}`;\n                }).join(\"&\");\n            }\n            const result = yield fetchJson(connection, payloadStr, procFunc || getJsonResult);\n            this.emit(\"debug\", {\n                action: \"response\",\n                request: url,\n                response: deepCopy(result),\n                provider: this\n            });\n            return result;\n        });\n    }\n    detectNetwork() {\n        return __awaiter(this, void 0, void 0, function* () {\n            return this.network;\n        });\n    }\n    perform(method, params) {\n        const _super = Object.create(null, {\n            perform: { get: () => super.perform }\n        });\n        return __awaiter(this, void 0, void 0, function* () {\n            switch (method) {\n                case \"getBlockNumber\":\n                    return this.fetch(\"proxy\", { action: \"eth_blockNumber\" });\n                case \"getGasPrice\":\n                    return this.fetch(\"proxy\", { action: \"eth_gasPrice\" });\n                case \"getBalance\":\n                    // Returns base-10 result\n                    return this.fetch(\"account\", {\n                        action: \"balance\",\n                        address: params.address,\n                        tag: params.blockTag\n                    });\n                case \"getTransactionCount\":\n                    return this.fetch(\"proxy\", {\n                        action: \"eth_getTransactionCount\",\n                        address: params.address,\n                        tag: params.blockTag\n                    });\n                case \"getCode\":\n                    return this.fetch(\"proxy\", {\n                        action: \"eth_getCode\",\n                        address: params.address,\n                        tag: params.blockTag\n                    });\n                case \"getStorageAt\":\n                    return this.fetch(\"proxy\", {\n                        action: \"eth_getStorageAt\",\n                        address: params.address,\n                        position: params.position,\n                        tag: params.blockTag\n                    });\n                case \"sendTransaction\":\n                    return this.fetch(\"proxy\", {\n                        action: \"eth_sendRawTransaction\",\n                        hex: params.signedTransaction\n                    }, true).catch((error) => {\n                        return checkError(\"sendTransaction\", error, params.signedTransaction);\n                    });\n                case \"getBlock\":\n                    if (params.blockTag) {\n                        return this.fetch(\"proxy\", {\n                            action: \"eth_getBlockByNumber\",\n                            tag: params.blockTag,\n                            boolean: (params.includeTransactions ? \"true\" : \"false\")\n                        });\n                    }\n                    throw new Error(\"getBlock by blockHash not implemented\");\n                case \"getTransaction\":\n                    return this.fetch(\"proxy\", {\n                        action: \"eth_getTransactionByHash\",\n                        txhash: params.transactionHash\n                    });\n                case \"getTransactionReceipt\":\n                    return this.fetch(\"proxy\", {\n                        action: \"eth_getTransactionReceipt\",\n                        txhash: params.transactionHash\n                    });\n                case \"call\": {\n                    if (params.blockTag !== \"latest\") {\n                        throw new Error(\"EtherscanProvider does not support blockTag for call\");\n                    }\n                    const postData = getTransactionPostData(params.transaction);\n                    postData.module = \"proxy\";\n                    postData.action = \"eth_call\";\n                    try {\n                        return yield this.fetch(\"proxy\", postData, true);\n                    }\n                    catch (error) {\n                        return checkError(\"call\", error, params.transaction);\n                    }\n                }\n                case \"estimateGas\": {\n                    const postData = getTransactionPostData(params.transaction);\n                    postData.module = \"proxy\";\n                    postData.action = \"eth_estimateGas\";\n                    try {\n                        return yield this.fetch(\"proxy\", postData, true);\n                    }\n                    catch (error) {\n                        return checkError(\"estimateGas\", error, params.transaction);\n                    }\n                }\n                case \"getLogs\": {\n                    const args = { action: \"getLogs\" };\n                    if (params.filter.fromBlock) {\n                        args.fromBlock = checkLogTag(params.filter.fromBlock);\n                    }\n                    if (params.filter.toBlock) {\n                        args.toBlock = checkLogTag(params.filter.toBlock);\n                    }\n                    if (params.filter.address) {\n                        args.address = params.filter.address;\n                    }\n                    // @TODO: We can handle slightly more complicated logs using the logs API\n                    if (params.filter.topics && params.filter.topics.length > 0) {\n                        if (params.filter.topics.length > 1) {\n                            logger.throwError(\"unsupported topic count\", Logger.errors.UNSUPPORTED_OPERATION, { topics: params.filter.topics });\n                        }\n                        if (params.filter.topics.length === 1) {\n                            const topic0 = params.filter.topics[0];\n                            if (typeof (topic0) !== \"string\" || topic0.length !== 66) {\n                                logger.throwError(\"unsupported topic format\", Logger.errors.UNSUPPORTED_OPERATION, { topic0: topic0 });\n                            }\n                            args.topic0 = topic0;\n                        }\n                    }\n                    const logs = yield this.fetch(\"logs\", args);\n                    // Cache txHash => blockHash\n                    let blocks = {};\n                    // Add any missing blockHash to the logs\n                    for (let i = 0; i < logs.length; i++) {\n                        const log = logs[i];\n                        if (log.blockHash != null) {\n                            continue;\n                        }\n                        if (blocks[log.blockNumber] == null) {\n                            const block = yield this.getBlock(log.blockNumber);\n                            if (block) {\n                                blocks[log.blockNumber] = block.hash;\n                            }\n                        }\n                        log.blockHash = blocks[log.blockNumber];\n                    }\n                    return logs;\n                }\n                case \"getEtherPrice\":\n                    if (this.network.name !== \"homestead\") {\n                        return 0.0;\n                    }\n                    return parseFloat((yield this.fetch(\"stats\", { action: \"ethprice\" })).ethusd);\n                default:\n                    break;\n            }\n            return _super.perform.call(this, method, params);\n        });\n    }\n    // Note: The `page` page parameter only allows pagination within the\n    //       10,000 window available without a page and offset parameter\n    //       Error: Result window is too large, PageNo x Offset size must\n    //              be less than or equal to 10000\n    getHistory(addressOrName, startBlock, endBlock) {\n        return __awaiter(this, void 0, void 0, function* () {\n            const params = {\n                action: \"txlist\",\n                address: (yield this.resolveName(addressOrName)),\n                startblock: ((startBlock == null) ? 0 : startBlock),\n                endblock: ((endBlock == null) ? 99999999 : endBlock),\n                sort: \"asc\"\n            };\n            const result = yield this.fetch(\"account\", params);\n            return result.map((tx) => {\n                [\"contractAddress\", \"to\"].forEach(function (key) {\n                    if (tx[key] == \"\") {\n                        delete tx[key];\n                    }\n                });\n                if (tx.creates == null && tx.contractAddress != null) {\n                    tx.creates = tx.contractAddress;\n                }\n                const item = this.formatter.transactionResponse(tx);\n                if (tx.timeStamp) {\n                    item.timestamp = parseInt(tx.timeStamp);\n                }\n                return item;\n            });\n        });\n    }\n    isCommunityResource() {\n        return (this.apiKey === defaultApiKey);\n    }\n}\n//# sourceMappingURL=etherscan-provider.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { Provider } from \"@ethersproject/abstract-provider\";\nimport { BigNumber } from \"@ethersproject/bignumber\";\nimport { isHexString } from \"@ethersproject/bytes\";\nimport { deepCopy, defineReadOnly, shallowCopy } from \"@ethersproject/properties\";\nimport { shuffled } from \"@ethersproject/random\";\nimport { poll } from \"@ethersproject/web\";\nimport { BaseProvider } from \"./base-provider\";\nimport { isCommunityResource } from \"./formatter\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nfunction now() { return (new Date()).getTime(); }\n// Returns to network as long as all agree, or null if any is null.\n// Throws an error if any two networks do not match.\nfunction checkNetworks(networks) {\n    let result = null;\n    for (let i = 0; i < networks.length; i++) {\n        const network = networks[i];\n        // Null! We do not know our network; bail.\n        if (network == null) {\n            return null;\n        }\n        if (result) {\n            // Make sure the network matches the previous networks\n            if (!(result.name === network.name && result.chainId === network.chainId &&\n                ((result.ensAddress === network.ensAddress) || (result.ensAddress == null && network.ensAddress == null)))) {\n                logger.throwArgumentError(\"provider mismatch\", \"networks\", networks);\n            }\n        }\n        else {\n            result = network;\n        }\n    }\n    return result;\n}\nfunction median(values, maxDelta) {\n    values = values.slice().sort();\n    const middle = Math.floor(values.length / 2);\n    // Odd length; take the middle\n    if (values.length % 2) {\n        return values[middle];\n    }\n    // Even length; take the average of the two middle\n    const a = values[middle - 1], b = values[middle];\n    if (maxDelta != null && Math.abs(a - b) > maxDelta) {\n        return null;\n    }\n    return (a + b) / 2;\n}\nfunction serialize(value) {\n    if (value === null) {\n        return \"null\";\n    }\n    else if (typeof (value) === \"number\" || typeof (value) === \"boolean\") {\n        return JSON.stringify(value);\n    }\n    else if (typeof (value) === \"string\") {\n        return value;\n    }\n    else if (BigNumber.isBigNumber(value)) {\n        return value.toString();\n    }\n    else if (Array.isArray(value)) {\n        return JSON.stringify(value.map((i) => serialize(i)));\n    }\n    else if (typeof (value) === \"object\") {\n        const keys = Object.keys(value);\n        keys.sort();\n        return \"{\" + keys.map((key) => {\n            let v = value[key];\n            if (typeof (v) === \"function\") {\n                v = \"[function]\";\n            }\n            else {\n                v = serialize(v);\n            }\n            return JSON.stringify(key) + \":\" + v;\n        }).join(\",\") + \"}\";\n    }\n    throw new Error(\"unknown value type: \" + typeof (value));\n}\n// Next request ID to use for emitting debug info\nlet nextRid = 1;\n;\nfunction stall(duration) {\n    let cancel = null;\n    let timer = null;\n    let promise = (new Promise((resolve) => {\n        cancel = function () {\n            if (timer) {\n                clearTimeout(timer);\n                timer = null;\n            }\n            resolve();\n        };\n        timer = setTimeout(cancel, duration);\n    }));\n    const wait = (func) => {\n        promise = promise.then(func);\n        return promise;\n    };\n    function getPromise() {\n        return promise;\n    }\n    return { cancel, getPromise, wait };\n}\nconst ForwardErrors = [\n    Logger.errors.CALL_EXCEPTION,\n    Logger.errors.INSUFFICIENT_FUNDS,\n    Logger.errors.NONCE_EXPIRED,\n    Logger.errors.REPLACEMENT_UNDERPRICED,\n    Logger.errors.UNPREDICTABLE_GAS_LIMIT\n];\nconst ForwardProperties = [\n    \"address\",\n    \"args\",\n    \"errorArgs\",\n    \"errorSignature\",\n    \"method\",\n    \"transaction\",\n];\n;\nfunction exposeDebugConfig(config, now) {\n    const result = {\n        weight: config.weight\n    };\n    Object.defineProperty(result, \"provider\", { get: () => config.provider });\n    if (config.start) {\n        result.start = config.start;\n    }\n    if (now) {\n        result.duration = (now - config.start);\n    }\n    if (config.done) {\n        if (config.error) {\n            result.error = config.error;\n        }\n        else {\n            result.result = config.result || null;\n        }\n    }\n    return result;\n}\nfunction normalizedTally(normalize, quorum) {\n    return function (configs) {\n        // Count the votes for each result\n        const tally = {};\n        configs.forEach((c) => {\n            const value = normalize(c.result);\n            if (!tally[value]) {\n                tally[value] = { count: 0, result: c.result };\n            }\n            tally[value].count++;\n        });\n        // Check for a quorum on any given result\n        const keys = Object.keys(tally);\n        for (let i = 0; i < keys.length; i++) {\n            const check = tally[keys[i]];\n            if (check.count >= quorum) {\n                return check.result;\n            }\n        }\n        // No quroum\n        return undefined;\n    };\n}\nfunction getProcessFunc(provider, method, params) {\n    let normalize = serialize;\n    switch (method) {\n        case \"getBlockNumber\":\n            // Return the median value, unless there is (median + 1) is also\n            // present, in which case that is probably true and the median\n            // is going to be stale soon. In the event of a malicious node,\n            // the lie will be true soon enough.\n            return function (configs) {\n                const values = configs.map((c) => c.result);\n                // Get the median block number\n                let blockNumber = median(configs.map((c) => c.result), 2);\n                if (blockNumber == null) {\n                    return undefined;\n                }\n                blockNumber = Math.ceil(blockNumber);\n                // If the next block height is present, its prolly safe to use\n                if (values.indexOf(blockNumber + 1) >= 0) {\n                    blockNumber++;\n                }\n                // Don't ever roll back the blockNumber\n                if (blockNumber >= provider._highestBlockNumber) {\n                    provider._highestBlockNumber = blockNumber;\n                }\n                return provider._highestBlockNumber;\n            };\n        case \"getGasPrice\":\n            // Return the middle (round index up) value, similar to median\n            // but do not average even entries and choose the higher.\n            // Malicious actors must compromise 50% of the nodes to lie.\n            return function (configs) {\n                const values = configs.map((c) => c.result);\n                values.sort();\n                return values[Math.floor(values.length / 2)];\n            };\n        case \"getEtherPrice\":\n            // Returns the median price. Malicious actors must compromise at\n            // least 50% of the nodes to lie (in a meaningful way).\n            return function (configs) {\n                return median(configs.map((c) => c.result));\n            };\n        // No additional normalizing required; serialize is enough\n        case \"getBalance\":\n        case \"getTransactionCount\":\n        case \"getCode\":\n        case \"getStorageAt\":\n        case \"call\":\n        case \"estimateGas\":\n        case \"getLogs\":\n            break;\n        // We drop the confirmations from transactions as it is approximate\n        case \"getTransaction\":\n        case \"getTransactionReceipt\":\n            normalize = function (tx) {\n                if (tx == null) {\n                    return null;\n                }\n                tx = shallowCopy(tx);\n                tx.confirmations = -1;\n                return serialize(tx);\n            };\n            break;\n        // We drop the confirmations from transactions as it is approximate\n        case \"getBlock\":\n            // We drop the confirmations from transactions as it is approximate\n            if (params.includeTransactions) {\n                normalize = function (block) {\n                    if (block == null) {\n                        return null;\n                    }\n                    block = shallowCopy(block);\n                    block.transactions = block.transactions.map((tx) => {\n                        tx = shallowCopy(tx);\n                        tx.confirmations = -1;\n                        return tx;\n                    });\n                    return serialize(block);\n                };\n            }\n            else {\n                normalize = function (block) {\n                    if (block == null) {\n                        return null;\n                    }\n                    return serialize(block);\n                };\n            }\n            break;\n        default:\n            throw new Error(\"unknown method: \" + method);\n    }\n    // Return the result if and only if the expected quorum is\n    // satisfied and agreed upon for the final result.\n    return normalizedTally(normalize, provider.quorum);\n}\n// If we are doing a blockTag query, we need to make sure the backend is\n// caught up to the FallbackProvider, before sending a request to it.\nfunction waitForSync(config, blockNumber) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const provider = (config.provider);\n        if ((provider.blockNumber != null && provider.blockNumber >= blockNumber) || blockNumber === -1) {\n            return provider;\n        }\n        return poll(() => {\n            return new Promise((resolve, reject) => {\n                setTimeout(function () {\n                    // We are synced\n                    if (provider.blockNumber >= blockNumber) {\n                        return resolve(provider);\n                    }\n                    // We're done; just quit\n                    if (config.cancelled) {\n                        return resolve(null);\n                    }\n                    // Try again, next block\n                    return resolve(undefined);\n                }, 0);\n            });\n        }, { oncePoll: provider });\n    });\n}\nfunction getRunner(config, currentBlockNumber, method, params) {\n    return __awaiter(this, void 0, void 0, function* () {\n        let provider = config.provider;\n        switch (method) {\n            case \"getBlockNumber\":\n            case \"getGasPrice\":\n                return provider[method]();\n            case \"getEtherPrice\":\n                if (provider.getEtherPrice) {\n                    return provider.getEtherPrice();\n                }\n                break;\n            case \"getBalance\":\n            case \"getTransactionCount\":\n            case \"getCode\":\n                if (params.blockTag && isHexString(params.blockTag)) {\n                    provider = yield waitForSync(config, currentBlockNumber);\n                }\n                return provider[method](params.address, params.blockTag || \"latest\");\n            case \"getStorageAt\":\n                if (params.blockTag && isHexString(params.blockTag)) {\n                    provider = yield waitForSync(config, currentBlockNumber);\n                }\n                return provider.getStorageAt(params.address, params.position, params.blockTag || \"latest\");\n            case \"getBlock\":\n                if (params.blockTag && isHexString(params.blockTag)) {\n                    provider = yield waitForSync(config, currentBlockNumber);\n                }\n                return provider[(params.includeTransactions ? \"getBlockWithTransactions\" : \"getBlock\")](params.blockTag || params.blockHash);\n            case \"call\":\n            case \"estimateGas\":\n                if (params.blockTag && isHexString(params.blockTag)) {\n                    provider = yield waitForSync(config, currentBlockNumber);\n                }\n                return provider[method](params.transaction);\n            case \"getTransaction\":\n            case \"getTransactionReceipt\":\n                return provider[method](params.transactionHash);\n            case \"getLogs\": {\n                let filter = params.filter;\n                if ((filter.fromBlock && isHexString(filter.fromBlock)) || (filter.toBlock && isHexString(filter.toBlock))) {\n                    provider = yield waitForSync(config, currentBlockNumber);\n                }\n                return provider.getLogs(filter);\n            }\n        }\n        return logger.throwError(\"unknown method error\", Logger.errors.UNKNOWN_ERROR, {\n            method: method,\n            params: params\n        });\n    });\n}\nexport class FallbackProvider extends BaseProvider {\n    constructor(providers, quorum) {\n        logger.checkNew(new.target, FallbackProvider);\n        if (providers.length === 0) {\n            logger.throwArgumentError(\"missing providers\", \"providers\", providers);\n        }\n        const providerConfigs = providers.map((configOrProvider, index) => {\n            if (Provider.isProvider(configOrProvider)) {\n                const stallTimeout = isCommunityResource(configOrProvider) ? 2000 : 750;\n                const priority = 1;\n                return Object.freeze({ provider: configOrProvider, weight: 1, stallTimeout, priority });\n            }\n            const config = shallowCopy(configOrProvider);\n            if (config.priority == null) {\n                config.priority = 1;\n            }\n            if (config.stallTimeout == null) {\n                config.stallTimeout = isCommunityResource(configOrProvider) ? 2000 : 750;\n            }\n            if (config.weight == null) {\n                config.weight = 1;\n            }\n            const weight = config.weight;\n            if (weight % 1 || weight > 512 || weight < 1) {\n                logger.throwArgumentError(\"invalid weight; must be integer in [1, 512]\", `providers[${index}].weight`, weight);\n            }\n            return Object.freeze(config);\n        });\n        const total = providerConfigs.reduce((accum, c) => (accum + c.weight), 0);\n        if (quorum == null) {\n            quorum = total / 2;\n        }\n        else if (quorum > total) {\n            logger.throwArgumentError(\"quorum will always fail; larger than total weight\", \"quorum\", quorum);\n        }\n        // Are all providers' networks are known\n        let networkOrReady = checkNetworks(providerConfigs.map((c) => (c.provider).network));\n        // Not all networks are known; we must stall\n        if (networkOrReady == null) {\n            networkOrReady = new Promise((resolve, reject) => {\n                setTimeout(() => {\n                    this.detectNetwork().then(resolve, reject);\n                }, 0);\n            });\n        }\n        super(networkOrReady);\n        // Preserve a copy, so we do not get mutated\n        defineReadOnly(this, \"providerConfigs\", Object.freeze(providerConfigs));\n        defineReadOnly(this, \"quorum\", quorum);\n        this._highestBlockNumber = -1;\n    }\n    detectNetwork() {\n        return __awaiter(this, void 0, void 0, function* () {\n            const networks = yield Promise.all(this.providerConfigs.map((c) => c.provider.getNetwork()));\n            return checkNetworks(networks);\n        });\n    }\n    perform(method, params) {\n        return __awaiter(this, void 0, void 0, function* () {\n            // Sending transactions is special; always broadcast it to all backends\n            if (method === \"sendTransaction\") {\n                const results = yield Promise.all(this.providerConfigs.map((c) => {\n                    return c.provider.sendTransaction(params.signedTransaction).then((result) => {\n                        return result.hash;\n                    }, (error) => {\n                        return error;\n                    });\n                }));\n                // Any success is good enough (other errors are likely \"already seen\" errors\n                for (let i = 0; i < results.length; i++) {\n                    const result = results[i];\n                    if (typeof (result) === \"string\") {\n                        return result;\n                    }\n                }\n                // They were all an error; pick the first error\n                throw results[0];\n            }\n            // We need to make sure we are in sync with our backends, so we need\n            // to know this before we can make a lot of calls\n            if (this._highestBlockNumber === -1 && method !== \"getBlockNumber\") {\n                yield this.getBlockNumber();\n            }\n            const processFunc = getProcessFunc(this, method, params);\n            // Shuffle the providers and then sort them by their priority; we\n            // shallowCopy them since we will store the result in them too\n            const configs = shuffled(this.providerConfigs.map(shallowCopy));\n            configs.sort((a, b) => (a.priority - b.priority));\n            const currentBlockNumber = this._highestBlockNumber;\n            let i = 0;\n            let first = true;\n            while (true) {\n                const t0 = now();\n                // Compute the inflight weight (exclude anything past)\n                let inflightWeight = configs.filter((c) => (c.runner && ((t0 - c.start) < c.stallTimeout)))\n                    .reduce((accum, c) => (accum + c.weight), 0);\n                // Start running enough to meet quorum\n                while (inflightWeight < this.quorum && i < configs.length) {\n                    const config = configs[i++];\n                    const rid = nextRid++;\n                    config.start = now();\n                    config.staller = stall(config.stallTimeout);\n                    config.staller.wait(() => { config.staller = null; });\n                    config.runner = getRunner(config, currentBlockNumber, method, params).then((result) => {\n                        config.done = true;\n                        config.result = result;\n                        if (this.listenerCount(\"debug\")) {\n                            this.emit(\"debug\", {\n                                action: \"request\",\n                                rid: rid,\n                                backend: exposeDebugConfig(config, now()),\n                                request: { method: method, params: deepCopy(params) },\n                                provider: this\n                            });\n                        }\n                    }, (error) => {\n                        config.done = true;\n                        config.error = error;\n                        if (this.listenerCount(\"debug\")) {\n                            this.emit(\"debug\", {\n                                action: \"request\",\n                                rid: rid,\n                                backend: exposeDebugConfig(config, now()),\n                                request: { method: method, params: deepCopy(params) },\n                                provider: this\n                            });\n                        }\n                    });\n                    if (this.listenerCount(\"debug\")) {\n                        this.emit(\"debug\", {\n                            action: \"request\",\n                            rid: rid,\n                            backend: exposeDebugConfig(config, null),\n                            request: { method: method, params: deepCopy(params) },\n                            provider: this\n                        });\n                    }\n                    inflightWeight += config.weight;\n                }\n                // Wait for anything meaningful to finish or stall out\n                const waiting = [];\n                configs.forEach((c) => {\n                    if (c.done || !c.runner) {\n                        return;\n                    }\n                    waiting.push(c.runner);\n                    if (c.staller) {\n                        waiting.push(c.staller.getPromise());\n                    }\n                });\n                if (waiting.length) {\n                    yield Promise.race(waiting);\n                }\n                // Check the quorum and process the results; the process function\n                // may additionally decide the quorum is not met\n                const results = configs.filter((c) => (c.done && c.error == null));\n                if (results.length >= this.quorum) {\n                    const result = processFunc(results);\n                    if (result !== undefined) {\n                        // Shut down any stallers\n                        configs.forEach(c => {\n                            if (c.staller) {\n                                c.staller.cancel();\n                            }\n                            c.cancelled = true;\n                        });\n                        return result;\n                    }\n                    if (!first) {\n                        yield stall(100).getPromise();\n                    }\n                    first = false;\n                }\n                // No result, check for errors that should be forwarded\n                const errors = configs.reduce((accum, c) => {\n                    if (!c.done || c.error == null) {\n                        return accum;\n                    }\n                    const code = (c.error).code;\n                    if (ForwardErrors.indexOf(code) >= 0) {\n                        if (!accum[code]) {\n                            accum[code] = { error: c.error, weight: 0 };\n                        }\n                        accum[code].weight += c.weight;\n                    }\n                    return accum;\n                }, ({}));\n                Object.keys(errors).forEach((errorCode) => {\n                    const tally = errors[errorCode];\n                    if (tally.weight < this.quorum) {\n                        return;\n                    }\n                    // Shut down any stallers\n                    configs.forEach(c => {\n                        if (c.staller) {\n                            c.staller.cancel();\n                        }\n                        c.cancelled = true;\n                    });\n                    const e = (tally.error);\n                    const props = {};\n                    ForwardProperties.forEach((name) => {\n                        if (e[name] == null) {\n                            return;\n                        }\n                        props[name] = e[name];\n                    });\n                    logger.throwError(e.reason || e.message, errorCode, props);\n                });\n                // All configs have run to completion; we will never get more data\n                if (configs.filter((c) => !c.done).length === 0) {\n                    break;\n                }\n            }\n            // Shut down any stallers; shouldn't be any\n            configs.forEach(c => {\n                if (c.staller) {\n                    c.staller.cancel();\n                }\n                c.cancelled = true;\n            });\n            return logger.throwError(\"failed to meet quorum\", Logger.errors.SERVER_ERROR, {\n                method: method,\n                params: params,\n                //results: configs.map((c) => c.result),\n                //errors: configs.map((c) => c.error),\n                results: configs.map((c) => exposeDebugConfig(c)),\n                provider: this\n            });\n        });\n    }\n}\n//# sourceMappingURL=fallback-provider.js.map","\"use strict\";\nconst IpcProvider = null;\nexport { IpcProvider };\n//# sourceMappingURL=ipc-provider.js.map","\"use strict\";\nimport { defineReadOnly } from \"@ethersproject/properties\";\nimport { WebSocketProvider } from \"./websocket-provider\";\nimport { showThrottleMessage } from \"./formatter\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\nconst defaultProjectId = \"84842078b09946638c03157f83405213\";\nexport class InfuraWebSocketProvider extends WebSocketProvider {\n    constructor(network, apiKey) {\n        const provider = new InfuraProvider(network, apiKey);\n        const connection = provider.connection;\n        if (connection.password) {\n            logger.throwError(\"INFURA WebSocket project secrets unsupported\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"InfuraProvider.getWebSocketProvider()\"\n            });\n        }\n        const url = connection.url.replace(/^http/i, \"ws\").replace(\"/v3/\", \"/ws/v3/\");\n        super(url, network);\n        defineReadOnly(this, \"apiKey\", provider.projectId);\n        defineReadOnly(this, \"projectId\", provider.projectId);\n        defineReadOnly(this, \"projectSecret\", provider.projectSecret);\n    }\n    isCommunityResource() {\n        return (this.projectId === defaultProjectId);\n    }\n}\nexport class InfuraProvider extends UrlJsonRpcProvider {\n    static getWebSocketProvider(network, apiKey) {\n        return new InfuraWebSocketProvider(network, apiKey);\n    }\n    static getApiKey(apiKey) {\n        const apiKeyObj = {\n            apiKey: defaultProjectId,\n            projectId: defaultProjectId,\n            projectSecret: null\n        };\n        if (apiKey == null) {\n            return apiKeyObj;\n        }\n        if (typeof (apiKey) === \"string\") {\n            apiKeyObj.projectId = apiKey;\n        }\n        else if (apiKey.projectSecret != null) {\n            logger.assertArgument((typeof (apiKey.projectId) === \"string\"), \"projectSecret requires a projectId\", \"projectId\", apiKey.projectId);\n            logger.assertArgument((typeof (apiKey.projectSecret) === \"string\"), \"invalid projectSecret\", \"projectSecret\", \"[REDACTED]\");\n            apiKeyObj.projectId = apiKey.projectId;\n            apiKeyObj.projectSecret = apiKey.projectSecret;\n        }\n        else if (apiKey.projectId) {\n            apiKeyObj.projectId = apiKey.projectId;\n        }\n        apiKeyObj.apiKey = apiKeyObj.projectId;\n        return apiKeyObj;\n    }\n    static getUrl(network, apiKey) {\n        let host = null;\n        switch (network ? network.name : \"unknown\") {\n            case \"homestead\":\n                host = \"mainnet.infura.io\";\n                break;\n            case \"ropsten\":\n                host = \"ropsten.infura.io\";\n                break;\n            case \"rinkeby\":\n                host = \"rinkeby.infura.io\";\n                break;\n            case \"kovan\":\n                host = \"kovan.infura.io\";\n                break;\n            case \"goerli\":\n                host = \"goerli.infura.io\";\n                break;\n            case \"matic\":\n                host = \"polygon-mainnet.infura.io\";\n                break;\n            case \"maticmum\":\n                host = \"polygon-mumbai.infura.io\";\n                break;\n            case \"optimism\":\n                host = \"optimism-mainnet.infura.io\";\n                break;\n            case \"optimism-kovan\":\n                host = \"optimism-kovan.infura.io\";\n                break;\n            case \"arbitrum\":\n                host = \"arbitrum-mainnet.infura.io\";\n                break;\n            case \"arbitrum-rinkeby\":\n                host = \"arbitrum-rinkeby.infura.io\";\n                break;\n            default:\n                logger.throwError(\"unsupported network\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"network\",\n                    value: network\n                });\n        }\n        const connection = {\n            allowGzip: true,\n            url: (\"https:/\" + \"/\" + host + \"/v3/\" + apiKey.projectId),\n            throttleCallback: (attempt, url) => {\n                if (apiKey.projectId === defaultProjectId) {\n                    showThrottleMessage();\n                }\n                return Promise.resolve(true);\n            }\n        };\n        if (apiKey.projectSecret != null) {\n            connection.user = \"\";\n            connection.password = apiKey.projectSecret;\n        }\n        return connection;\n    }\n    isCommunityResource() {\n        return (this.projectId === defaultProjectId);\n    }\n}\n//# sourceMappingURL=infura-provider.js.map","import { deepCopy } from \"@ethersproject/properties\";\nimport { fetchJson } from \"@ethersproject/web\";\nimport { JsonRpcProvider } from \"./json-rpc-provider\";\n// Experimental\nexport class JsonRpcBatchProvider extends JsonRpcProvider {\n    send(method, params) {\n        const request = {\n            method: method,\n            params: params,\n            id: (this._nextId++),\n            jsonrpc: \"2.0\"\n        };\n        if (this._pendingBatch == null) {\n            this._pendingBatch = [];\n        }\n        const inflightRequest = { request, resolve: null, reject: null };\n        const promise = new Promise((resolve, reject) => {\n            inflightRequest.resolve = resolve;\n            inflightRequest.reject = reject;\n        });\n        this._pendingBatch.push(inflightRequest);\n        if (!this._pendingBatchAggregator) {\n            // Schedule batch for next event loop + short duration\n            this._pendingBatchAggregator = setTimeout(() => {\n                // Get teh current batch and clear it, so new requests\n                // go into the next batch\n                const batch = this._pendingBatch;\n                this._pendingBatch = null;\n                this._pendingBatchAggregator = null;\n                // Get the request as an array of requests\n                const request = batch.map((inflight) => inflight.request);\n                this.emit(\"debug\", {\n                    action: \"requestBatch\",\n                    request: deepCopy(request),\n                    provider: this\n                });\n                return fetchJson(this.connection, JSON.stringify(request)).then((result) => {\n                    this.emit(\"debug\", {\n                        action: \"response\",\n                        request: request,\n                        response: result,\n                        provider: this\n                    });\n                    // For each result, feed it to the correct Promise, depending\n                    // on whether it was a success or error\n                    batch.forEach((inflightRequest, index) => {\n                        const payload = result[index];\n                        if (payload.error) {\n                            const error = new Error(payload.error.message);\n                            error.code = payload.error.code;\n                            error.data = payload.error.data;\n                            inflightRequest.reject(error);\n                        }\n                        else {\n                            inflightRequest.resolve(payload.result);\n                        }\n                    });\n                }, (error) => {\n                    this.emit(\"debug\", {\n                        action: \"response\",\n                        error: error,\n                        request: request,\n                        provider: this\n                    });\n                    batch.forEach((inflightRequest) => {\n                        inflightRequest.reject(error);\n                    });\n                });\n            }, 10);\n        }\n        return promise;\n    }\n}\n//# sourceMappingURL=json-rpc-batch-provider.js.map","/* istanbul ignore file */\n\"use strict\";\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n// Special API key provided by Nodesmith for ethers.js\nconst defaultApiKey = \"ETHERS_JS_SHARED\";\nexport class NodesmithProvider extends UrlJsonRpcProvider {\n    static getApiKey(apiKey) {\n        if (apiKey && typeof (apiKey) !== \"string\") {\n            logger.throwArgumentError(\"invalid apiKey\", \"apiKey\", apiKey);\n        }\n        return apiKey || defaultApiKey;\n    }\n    static getUrl(network, apiKey) {\n        logger.warn(\"NodeSmith will be discontinued on 2019-12-20; please migrate to another platform.\");\n        let host = null;\n        switch (network.name) {\n            case \"homestead\":\n                host = \"https://ethereum.api.nodesmith.io/v1/mainnet/jsonrpc\";\n                break;\n            case \"ropsten\":\n                host = \"https://ethereum.api.nodesmith.io/v1/ropsten/jsonrpc\";\n                break;\n            case \"rinkeby\":\n                host = \"https://ethereum.api.nodesmith.io/v1/rinkeby/jsonrpc\";\n                break;\n            case \"goerli\":\n                host = \"https://ethereum.api.nodesmith.io/v1/goerli/jsonrpc\";\n                break;\n            case \"kovan\":\n                host = \"https://ethereum.api.nodesmith.io/v1/kovan/jsonrpc\";\n                break;\n            default:\n                logger.throwArgumentError(\"unsupported network\", \"network\", arguments[0]);\n        }\n        return (host + \"?apiKey=\" + apiKey);\n    }\n}\n//# sourceMappingURL=nodesmith-provider.js.map","\"use strict\";\nimport { getStatic } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\n// These are load-balancer-based application IDs\nconst defaultApplicationIds = {\n    homestead: \"6004bcd10040261633ade990\",\n    ropsten: \"6004bd4d0040261633ade991\",\n    rinkeby: \"6004bda20040261633ade994\",\n    goerli: \"6004bd860040261633ade992\",\n};\nexport class PocketProvider extends UrlJsonRpcProvider {\n    constructor(network, apiKey) {\n        // We need a bit of creativity in the constructor because\n        // Pocket uses different default API keys based on the network\n        if (apiKey == null) {\n            const n = getStatic(new.target, \"getNetwork\")(network);\n            if (n) {\n                const applicationId = defaultApplicationIds[n.name];\n                if (applicationId) {\n                    apiKey = {\n                        applicationId: applicationId,\n                        loadBalancer: true\n                    };\n                }\n            }\n            // If there was any issue above, we don't know this network\n            if (apiKey == null) {\n                logger.throwError(\"unsupported network\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"network\",\n                    value: network\n                });\n            }\n        }\n        super(network, apiKey);\n    }\n    static getApiKey(apiKey) {\n        // Most API Providers allow null to get the default configuration, but\n        // Pocket requires the network to decide the default provider, so we\n        // rely on hijacking the constructor to add a sensible default for us\n        if (apiKey == null) {\n            logger.throwArgumentError(\"PocketProvider.getApiKey does not support null apiKey\", \"apiKey\", apiKey);\n        }\n        const apiKeyObj = {\n            applicationId: null,\n            loadBalancer: false,\n            applicationSecretKey: null\n        };\n        // Parse applicationId and applicationSecretKey\n        if (typeof (apiKey) === \"string\") {\n            apiKeyObj.applicationId = apiKey;\n        }\n        else if (apiKey.applicationSecretKey != null) {\n            logger.assertArgument((typeof (apiKey.applicationId) === \"string\"), \"applicationSecretKey requires an applicationId\", \"applicationId\", apiKey.applicationId);\n            logger.assertArgument((typeof (apiKey.applicationSecretKey) === \"string\"), \"invalid applicationSecretKey\", \"applicationSecretKey\", \"[REDACTED]\");\n            apiKeyObj.applicationId = apiKey.applicationId;\n            apiKeyObj.applicationSecretKey = apiKey.applicationSecretKey;\n            apiKeyObj.loadBalancer = !!apiKey.loadBalancer;\n        }\n        else if (apiKey.applicationId) {\n            logger.assertArgument((typeof (apiKey.applicationId) === \"string\"), \"apiKey.applicationId must be a string\", \"apiKey.applicationId\", apiKey.applicationId);\n            apiKeyObj.applicationId = apiKey.applicationId;\n            apiKeyObj.loadBalancer = !!apiKey.loadBalancer;\n        }\n        else {\n            logger.throwArgumentError(\"unsupported PocketProvider apiKey\", \"apiKey\", apiKey);\n        }\n        return apiKeyObj;\n    }\n    static getUrl(network, apiKey) {\n        let host = null;\n        switch (network ? network.name : \"unknown\") {\n            case \"homestead\":\n                host = \"eth-mainnet.gateway.pokt.network\";\n                break;\n            case \"ropsten\":\n                host = \"eth-ropsten.gateway.pokt.network\";\n                break;\n            case \"rinkeby\":\n                host = \"eth-rinkeby.gateway.pokt.network\";\n                break;\n            case \"goerli\":\n                host = \"eth-goerli.gateway.pokt.network\";\n                break;\n            default:\n                logger.throwError(\"unsupported network\", Logger.errors.INVALID_ARGUMENT, {\n                    argument: \"network\",\n                    value: network\n                });\n        }\n        let url = null;\n        if (apiKey.loadBalancer) {\n            url = `https:/\\/${host}/v1/lb/${apiKey.applicationId}`;\n        }\n        else {\n            url = `https:/\\/${host}/v1/${apiKey.applicationId}`;\n        }\n        const connection = { url };\n        // Initialize empty headers\n        connection.headers = {};\n        // Apply application secret key\n        if (apiKey.applicationSecretKey != null) {\n            connection.user = \"\";\n            connection.password = apiKey.applicationSecretKey;\n        }\n        return connection;\n    }\n    isCommunityResource() {\n        return (this.applicationId === defaultApplicationIds[this.network.name]);\n    }\n}\n//# sourceMappingURL=pocket-provider.js.map","\"use strict\";\nimport { deepCopy, defineReadOnly } from \"@ethersproject/properties\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { JsonRpcProvider } from \"./json-rpc-provider\";\nlet _nextId = 1;\nfunction buildWeb3LegacyFetcher(provider, sendFunc) {\n    const fetcher = \"Web3LegacyFetcher\";\n    return function (method, params) {\n        const request = {\n            method: method,\n            params: params,\n            id: (_nextId++),\n            jsonrpc: \"2.0\"\n        };\n        return new Promise((resolve, reject) => {\n            this.emit(\"debug\", {\n                action: \"request\",\n                fetcher,\n                request: deepCopy(request),\n                provider: this\n            });\n            sendFunc(request, (error, response) => {\n                if (error) {\n                    this.emit(\"debug\", {\n                        action: \"response\",\n                        fetcher,\n                        error,\n                        request,\n                        provider: this\n                    });\n                    return reject(error);\n                }\n                this.emit(\"debug\", {\n                    action: \"response\",\n                    fetcher,\n                    request,\n                    response,\n                    provider: this\n                });\n                if (response.error) {\n                    const error = new Error(response.error.message);\n                    error.code = response.error.code;\n                    error.data = response.error.data;\n                    return reject(error);\n                }\n                resolve(response.result);\n            });\n        });\n    };\n}\nfunction buildEip1193Fetcher(provider) {\n    return function (method, params) {\n        if (params == null) {\n            params = [];\n        }\n        const request = { method, params };\n        this.emit(\"debug\", {\n            action: \"request\",\n            fetcher: \"Eip1193Fetcher\",\n            request: deepCopy(request),\n            provider: this\n        });\n        return provider.request(request).then((response) => {\n            this.emit(\"debug\", {\n                action: \"response\",\n                fetcher: \"Eip1193Fetcher\",\n                request,\n                response,\n                provider: this\n            });\n            return response;\n        }, (error) => {\n            this.emit(\"debug\", {\n                action: \"response\",\n                fetcher: \"Eip1193Fetcher\",\n                request,\n                error,\n                provider: this\n            });\n            throw error;\n        });\n    };\n}\nexport class Web3Provider extends JsonRpcProvider {\n    constructor(provider, network) {\n        logger.checkNew(new.target, Web3Provider);\n        if (provider == null) {\n            logger.throwArgumentError(\"missing provider\", \"provider\", provider);\n        }\n        let path = null;\n        let jsonRpcFetchFunc = null;\n        let subprovider = null;\n        if (typeof (provider) === \"function\") {\n            path = \"unknown:\";\n            jsonRpcFetchFunc = provider;\n        }\n        else {\n            path = provider.host || provider.path || \"\";\n            if (!path && provider.isMetaMask) {\n                path = \"metamask\";\n            }\n            subprovider = provider;\n            if (provider.request) {\n                if (path === \"\") {\n                    path = \"eip-1193:\";\n                }\n                jsonRpcFetchFunc = buildEip1193Fetcher(provider);\n            }\n            else if (provider.sendAsync) {\n                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.sendAsync.bind(provider));\n            }\n            else if (provider.send) {\n                jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.send.bind(provider));\n            }\n            else {\n                logger.throwArgumentError(\"unsupported provider\", \"provider\", provider);\n            }\n            if (!path) {\n                path = \"unknown:\";\n            }\n        }\n        super(path, network);\n        defineReadOnly(this, \"jsonRpcFetchFunc\", jsonRpcFetchFunc);\n        defineReadOnly(this, \"provider\", subprovider);\n    }\n    send(method, params) {\n        return this.jsonRpcFetchFunc(method, params);\n    }\n}\n//# sourceMappingURL=web3-provider.js.map","\"use strict\";\nimport { Provider } from \"@ethersproject/abstract-provider\";\nimport { getNetwork } from \"@ethersproject/networks\";\nimport { BaseProvider, Resolver } from \"./base-provider\";\nimport { AlchemyProvider, AlchemyWebSocketProvider } from \"./alchemy-provider\";\nimport { AnkrProvider } from \"./ankr-provider\";\nimport { CloudflareProvider } from \"./cloudflare-provider\";\nimport { EtherscanProvider } from \"./etherscan-provider\";\nimport { FallbackProvider } from \"./fallback-provider\";\nimport { IpcProvider } from \"./ipc-provider\";\nimport { InfuraProvider, InfuraWebSocketProvider } from \"./infura-provider\";\nimport { JsonRpcProvider, JsonRpcSigner } from \"./json-rpc-provider\";\nimport { JsonRpcBatchProvider } from \"./json-rpc-batch-provider\";\nimport { NodesmithProvider } from \"./nodesmith-provider\";\nimport { PocketProvider } from \"./pocket-provider\";\nimport { StaticJsonRpcProvider, UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\nimport { Web3Provider } from \"./web3-provider\";\nimport { WebSocketProvider } from \"./websocket-provider\";\nimport { Formatter, isCommunityResourcable, isCommunityResource, showThrottleMessage } from \"./formatter\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n////////////////////////\n// Helper Functions\nfunction getDefaultProvider(network, options) {\n    if (network == null) {\n        network = \"homestead\";\n    }\n    // If passed a URL, figure out the right type of provider based on the scheme\n    if (typeof (network) === \"string\") {\n        // @TODO: Add support for IpcProvider; maybe if it ends in \".ipc\"?\n        // Handle http and ws (and their secure variants)\n        const match = network.match(/^(ws|http)s?:/i);\n        if (match) {\n            switch (match[1]) {\n                case \"http\":\n                    return new JsonRpcProvider(network);\n                case \"ws\":\n                    return new WebSocketProvider(network);\n                default:\n                    logger.throwArgumentError(\"unsupported URL scheme\", \"network\", network);\n            }\n        }\n    }\n    const n = getNetwork(network);\n    if (!n || !n._defaultProvider) {\n        logger.throwError(\"unsupported getDefaultProvider network\", Logger.errors.NETWORK_ERROR, {\n            operation: \"getDefaultProvider\",\n            network: network\n        });\n    }\n    return n._defaultProvider({\n        FallbackProvider,\n        AlchemyProvider,\n        AnkrProvider,\n        CloudflareProvider,\n        EtherscanProvider,\n        InfuraProvider,\n        JsonRpcProvider,\n        NodesmithProvider,\n        PocketProvider,\n        Web3Provider,\n        IpcProvider,\n    }, options);\n}\n////////////////////////\n// Exports\nexport { \n// Abstract Providers (or Abstract-ish)\nProvider, BaseProvider, Resolver, UrlJsonRpcProvider, \n///////////////////////\n// Concrete Providers\nFallbackProvider, AlchemyProvider, AlchemyWebSocketProvider, AnkrProvider, CloudflareProvider, EtherscanProvider, InfuraProvider, InfuraWebSocketProvider, JsonRpcProvider, JsonRpcBatchProvider, NodesmithProvider, PocketProvider, StaticJsonRpcProvider, Web3Provider, WebSocketProvider, IpcProvider, \n///////////////////////\n// Signer\nJsonRpcSigner, \n///////////////////////\n// Functions\ngetDefaultProvider, getNetwork, isCommunityResource, isCommunityResourcable, showThrottleMessage, \n///////////////////////\n// Objects\nFormatter };\n//# sourceMappingURL=index.js.map","\"use strict\";\nimport { arrayify, hexlify } from \"@ethersproject/bytes\";\nimport { computeHmac } from \"@ethersproject/sha2\";\nexport function pbkdf2(password, salt, iterations, keylen, hashAlgorithm) {\n    password = arrayify(password);\n    salt = arrayify(salt);\n    let hLen;\n    let l = 1;\n    const DK = new Uint8Array(keylen);\n    const block1 = new Uint8Array(salt.length + 4);\n    block1.set(salt);\n    //salt.copy(block1, 0, 0, salt.length)\n    let r;\n    let T;\n    for (let i = 1; i <= l; i++) {\n        //block1.writeUInt32BE(i, salt.length)\n        block1[salt.length] = (i >> 24) & 0xff;\n        block1[salt.length + 1] = (i >> 16) & 0xff;\n        block1[salt.length + 2] = (i >> 8) & 0xff;\n        block1[salt.length + 3] = i & 0xff;\n        //let U = createHmac(password).update(block1).digest();\n        let U = arrayify(computeHmac(hashAlgorithm, password, block1));\n        if (!hLen) {\n            hLen = U.length;\n            T = new Uint8Array(hLen);\n            l = Math.ceil(keylen / hLen);\n            r = keylen - (l - 1) * hLen;\n        }\n        //U.copy(T, 0, 0, hLen)\n        T.set(U);\n        for (let j = 1; j < iterations; j++) {\n            //U = createHmac(password).update(U).digest();\n            U = arrayify(computeHmac(hashAlgorithm, password, U));\n            for (let k = 0; k < hLen; k++)\n                T[k] ^= U[k];\n        }\n        const destPos = (i - 1) * hLen;\n        const len = (i === l ? r : hLen);\n        //T.copy(DK, destPos, 0, len)\n        DK.set(arrayify(T).slice(0, len), destPos);\n    }\n    return hexlify(DK);\n}\n//# sourceMappingURL=pbkdf2.js.map","\"use strict\";\nexport function shuffled(array) {\n    array = array.slice();\n    for (let i = array.length - 1; i > 0; i--) {\n        const j = Math.floor(Math.random() * (i + 1));\n        const tmp = array[i];\n        array[i] = array[j];\n        array[j] = tmp;\n    }\n    return array;\n}\n//# sourceMappingURL=shuffle.js.map","\"use strict\";\nimport { arrayify } from \"@ethersproject/bytes\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\n// Debugging line for testing browser lib in node\n//const window = { crypto: { getRandomValues: () => { } } };\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis\nfunction getGlobal() {\n    if (typeof self !== 'undefined') {\n        return self;\n    }\n    if (typeof window !== 'undefined') {\n        return window;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    throw new Error('unable to locate global object');\n}\n;\nconst anyGlobal = getGlobal();\nlet crypto = anyGlobal.crypto || anyGlobal.msCrypto;\nif (!crypto || !crypto.getRandomValues) {\n    logger.warn(\"WARNING: Missing strong random number source\");\n    crypto = {\n        getRandomValues: function (buffer) {\n            return logger.throwError(\"no secure random source avaialble\", Logger.errors.UNSUPPORTED_OPERATION, {\n                operation: \"crypto.getRandomValues\"\n            });\n        }\n    };\n}\nexport function randomBytes(length) {\n    if (length <= 0 || length > 1024 || (length % 1) || length != length) {\n        logger.throwArgumentError(\"invalid length\", \"length\", length);\n    }\n    const result = new Uint8Array(length);\n    crypto.getRandomValues(result);\n    return arrayify(result);\n}\n;\n//# sourceMappingURL=random.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nexport function defineReadOnly(object, name, value) {\n    Object.defineProperty(object, name, {\n        enumerable: true,\n        value: value,\n        writable: false,\n    });\n}\n// Crawl up the constructor chain to find a static method\nexport function getStatic(ctor, key) {\n    for (let i = 0; i < 32; i++) {\n        if (ctor[key]) {\n            return ctor[key];\n        }\n        if (!ctor.prototype || typeof (ctor.prototype) !== \"object\") {\n            break;\n        }\n        ctor = Object.getPrototypeOf(ctor.prototype).constructor;\n    }\n    return null;\n}\nexport function resolveProperties(object) {\n    return __awaiter(this, void 0, void 0, function* () {\n        const promises = Object.keys(object).map((key) => {\n            const value = object[key];\n            return Promise.resolve(value).then((v) => ({ key: key, value: v }));\n        });\n        const results = yield Promise.all(promises);\n        return results.reduce((accum, result) => {\n            accum[(result.key)] = result.value;\n            return accum;\n        }, {});\n    });\n}\nexport function checkProperties(object, properties) {\n    if (!object || typeof (object) !== \"object\") {\n        logger.throwArgumentError(\"invalid object\", \"object\", object);\n    }\n    Object.keys(object).forEach((key) => {\n        if (!properties[key]) {\n            logger.throwArgumentError(\"invalid object key - \" + key, \"transaction:\" + key, object);\n        }\n    });\n}\nexport function shallowCopy(object) {\n    const result = {};\n    for (const key in object) {\n        result[key] = object[key];\n    }\n    return result;\n}\nconst opaque = { bigint: true, boolean: true, \"function\": true, number: true, string: true };\nfunction _isFrozen(object) {\n    // Opaque objects are not mutable, so safe to copy by assignment\n    if (object === undefined || object === null || opaque[typeof (object)]) {\n        return true;\n    }\n    if (Array.isArray(object) || typeof (object) === \"object\") {\n        if (!Object.isFrozen(object)) {\n            return false;\n        }\n        const keys = Object.keys(object);\n        for (let i = 0; i < keys.length; i++) {\n            let value = null;\n            try {\n                value = object[keys[i]];\n            }\n            catch (error) {\n                // If accessing a value triggers an error, it is a getter\n                // designed to do so (e.g. Result) and is therefore \"frozen\"\n                continue;\n            }\n            if (!_isFrozen(value)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    return logger.throwArgumentError(`Cannot deepCopy ${typeof (object)}`, \"object\", object);\n}\n// Returns a new copy of object, such that no properties may be replaced.\n// New properties may be added only to objects.\nfunction _deepCopy(object) {\n    if (_isFrozen(object)) {\n        return object;\n    }\n    // Arrays are mutable, so we need to create a copy\n    if (Array.isArray(object)) {\n        return Object.freeze(object.map((item) => deepCopy(item)));\n    }\n    if (typeof (object) === \"object\") {\n        const result = {};\n        for (const key in object) {\n            const value = object[key];\n            if (value === undefined) {\n                continue;\n            }\n            defineReadOnly(result, key, deepCopy(value));\n        }\n        return result;\n    }\n    return logger.throwArgumentError(`Cannot deepCopy ${typeof (object)}`, \"object\", object);\n}\nexport function deepCopy(object) {\n    return _deepCopy(object);\n}\nexport class Description {\n    constructor(info) {\n        for (const key in info) {\n            this[key] = deepCopy(info[key]);\n        }\n    }\n}\n//# sourceMappingURL=index.js.map","export const version = \"properties/5.6.0\";\n//# sourceMappingURL=_version.js.map","export const version = \"rlp/5.6.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\n//See: https://github.com/ethereum/wiki/wiki/RLP\nimport { arrayify, hexlify, isBytesLike } from \"@ethersproject/bytes\";\nimport { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nfunction arrayifyInteger(value) {\n    const result = [];\n    while (value) {\n        result.unshift(value & 0xff);\n        value >>= 8;\n    }\n    return result;\n}\nfunction unarrayifyInteger(data, offset, length) {\n    let result = 0;\n    for (let i = 0; i < length; i++) {\n        result = (result * 256) + data[offset + i];\n    }\n    return result;\n}\nfunction _encode(object) {\n    if (Array.isArray(object)) {\n        let payload = [];\n        object.forEach(function (child) {\n            payload = payload.concat(_encode(child));\n        });\n        if (payload.length <= 55) {\n            payload.unshift(0xc0 + payload.length);\n            return payload;\n        }\n        const length = arrayifyInteger(payload.length);\n        length.unshift(0xf7 + length.length);\n        return length.concat(payload);\n    }\n    if (!isBytesLike(object)) {\n        logger.throwArgumentError(\"RLP object must be BytesLike\", \"object\", object);\n    }\n    const data = Array.prototype.slice.call(arrayify(object));\n    if (data.length === 1 && data[0] <= 0x7f) {\n        return data;\n    }\n    else if (data.length <= 55) {\n        data.unshift(0x80 + data.length);\n        return data;\n    }\n    const length = arrayifyInteger(data.length);\n    length.unshift(0xb7 + length.length);\n    return length.concat(data);\n}\nexport function encode(object) {\n    return hexlify(_encode(object));\n}\nfunction _decodeChildren(data, offset, childOffset, length) {\n    const result = [];\n    while (childOffset < offset + 1 + length) {\n        const decoded = _decode(data, childOffset);\n        result.push(decoded.result);\n        childOffset += decoded.consumed;\n        if (childOffset > offset + 1 + length) {\n            logger.throwError(\"child data too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n    }\n    return { consumed: (1 + length), result: result };\n}\n// returns { consumed: number, result: Object }\nfunction _decode(data, offset) {\n    if (data.length === 0) {\n        logger.throwError(\"data too short\", Logger.errors.BUFFER_OVERRUN, {});\n    }\n    // Array with extra length prefix\n    if (data[offset] >= 0xf8) {\n        const lengthLength = data[offset] - 0xf7;\n        if (offset + 1 + lengthLength > data.length) {\n            logger.throwError(\"data short segment too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n        const length = unarrayifyInteger(data, offset + 1, lengthLength);\n        if (offset + 1 + lengthLength + length > data.length) {\n            logger.throwError(\"data long segment too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n        return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);\n    }\n    else if (data[offset] >= 0xc0) {\n        const length = data[offset] - 0xc0;\n        if (offset + 1 + length > data.length) {\n            logger.throwError(\"data array too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n        return _decodeChildren(data, offset, offset + 1, length);\n    }\n    else if (data[offset] >= 0xb8) {\n        const lengthLength = data[offset] - 0xb7;\n        if (offset + 1 + lengthLength > data.length) {\n            logger.throwError(\"data array too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n        const length = unarrayifyInteger(data, offset + 1, lengthLength);\n        if (offset + 1 + lengthLength + length > data.length) {\n            logger.throwError(\"data array too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n        const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));\n        return { consumed: (1 + lengthLength + length), result: result };\n    }\n    else if (data[offset] >= 0x80) {\n        const length = data[offset] - 0x80;\n        if (offset + 1 + length > data.length) {\n            logger.throwError(\"data too short\", Logger.errors.BUFFER_OVERRUN, {});\n        }\n        const result = hexlify(data.slice(offset + 1, offset + 1 + length));\n        return { consumed: (1 + length), result: result };\n    }\n    return { consumed: 1, result: hexlify(data[offset]) };\n}\nexport function decode(data) {\n    const bytes = arrayify(data);\n    const decoded = _decode(bytes, 0);\n    if (decoded.consumed !== bytes.length) {\n        logger.throwArgumentError(\"invalid rlp data\", \"data\", data);\n    }\n    return decoded.result;\n}\n//# sourceMappingURL=index.js.map","export const version = \"random/5.6.0\";\n//# sourceMappingURL=_version.js.map"],"sourceRoot":""}