{"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/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/providers/lib.esm/json-rpc-provider.js","webpack:///./node_modules/@ethersproject/pbkdf2/lib.esm/pbkdf2.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/ws.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/random/lib.esm/shuffle.js","webpack:///./node_modules/@ethersproject/random/lib.esm/random.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/websocket-provider.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/formatter.js","webpack:///./node_modules/@ethersproject/properties/lib.esm/index.js","webpack:///./node_modules/@ethersproject/properties/lib.esm/_version.js","webpack:///./node_modules/@ethersproject/providers/lib.esm/base-provider.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":["logger","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","sepolia","classic","classicMorden","classicTestnet","classicKotti","xdai","matic","maticmum","optimism","arbitrum","bnb","bnbt","getNetwork","standard","throwArgumentError","defaultProvider","value","isRenetworkable","detectNetwork","_super","Object","create","get","super","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","next","e","rejected","result","done","then","apply","__awaiter","this","call","throwError","errors","UNKNOWN_ERROR","_network","emit","constructor","apiKey","checkAbstract","keys","forEach","key","_startPending","warn","isCommunityResource","getSigner","address","UNSUPPORTED_OPERATION","operation","listAccounts","static","NOT_IMPLEMENTED","defaultApiKey","connection","replace","host","arguments","allowGzip","throttleCallback","attempt","getHost","projectSecret","user","password","perform","method","params","blockTag","number","getTransactionPostData","transaction","type","gasLimit","gasPrice","maxFeePerGs","maxPriorityFeePerGas","nonce","map","set","storageKeys","join","getResult","status","message","match","Error","JSON","stringify","toLowerCase","throttleRetry","getJsonResult","jsonrpc","code","data","checkLogTag","parseInt","substring","checkError","SERVER_ERROR","CALL_EXCEPTION","body","responseText","INSUFFICIENT_FUNDS","NONCE_EXPIRED","REPLACEMENT_UNDERPRICED","UNPREDICTABLE_GAS_LIMIT","getBaseUrl","getUrl","module","query","reduce","accum","baseUrl","getPostUrl","getPostData","apikey","fetch","post","payload","procFunc","action","request","throttleSlotInterval","payloadStr","headers","response","tag","position","hex","signedTransaction","catch","boolean","includeTransactions","txhash","transactionHash","postData","args","filter","fromBlock","toBlock","topics","topic0","logs","blocks","i","log","blockHash","blockNumber","block","getBlock","hash","parseFloat","ethusd","getHistory","addressOrName","startBlock","endBlock","resolveName","startblock","endblock","sort","tx","creates","contractAddress","item","formatter","transactionResponse","timeStamp","timestamp","now","Date","getTime","checkNetworks","median","values","maxDelta","slice","middle","Math","floor","a","b","abs","serialize","isBigNumber","toString","Array","isArray","v","nextRid","stall","duration","cancel","timer","promise","clearTimeout","setTimeout","getPromise","wait","ForwardErrors","ForwardProperties","exposeDebugConfig","config","weight","defineProperty","start","getProcessFunc","normalize","configs","c","ceil","_highestBlockNumber","confirmations","transactions","tally","count","check","normalizedTally","waitForSync","cancelled","undefined","oncePoll","getRunner","currentBlockNumber","getEtherPrice","getStorageAt","getLogs","providerConfigs","configOrProvider","index","isProvider","stallTimeout","priority","freeze","total","networkOrReady","all","results","sendTransaction","getBlockNumber","processFunc","shuffle","first","t0","inflightWeight","runner","rid","staller","listenerCount","backend","waiting","race","errorCode","props","reason","IpcProvider","defaultProjectId","projectId","apiKeyObj","assertArgument","INVALID_ARGUMENT","argument","send","id","_nextId","_pendingBatch","inflightRequest","_pendingBatchAggregator","batch","inflight","defaultApplicationId","applicationId","loadBalancer","applicationSecretKey","buildWeb3LegacyFetcher","sendFunc","fetcher","path","jsonRpcFetchFunc","subprovider","isMetaMask","buildEip1193Fetcher","sendAsync","bind","getDefaultProvider","n","NETWORK_ERROR","NodesmithProvider","Web3Provider","errorGas","spelunk","requireData","parse","timeout","getLowerCase","_constructorGuard","JsonRpcSigner","constructorGuard","addressOrIndex","connect","connectUnchecked","UncheckedJsonRpcSigner","_address","_index","getAddress","accounts","sendUncheckedTransaction","fromAddress","estimate","from","estimateGas","to","sender","hexTx","hexlifyTransaction","ACTION_REJECTED","signTransaction","_getInternalBlockNumber","pollingInterval","getTransaction","_wrapTransaction","signMessage","messageData","_legacySignMessage","_signTypedData","domain","types","populated","resolveNames","getPayload","unlock","waitForTransaction","allowedTransactionKeys","accessList","maxFeePerGas","_cache","_eventLoopCache","_uncachedDetectNetwork","toNumber","event","serverError","getUncheckedSigner","cache","prepareRequest","isZero","feeData","getFeeData","_startEvent","_pendingFilter","self","pendingFilter","filterId","poll","hashes","seq","_emitted","_stopEvent","allowExtra","allowed","pbkdf2","salt","iterations","keylen","hashAlgorithm","hLen","l","DK","Uint8Array","block1","r","T","U","j","k","destPos","len","WS","WebSocket","version","shuffled","array","random","tmp","anyGlobal","window","global","getGlobal","crypto","msCrypto","randomBytes","getRandomValues","buffer","NextId","WebSocketProvider","_pollingInterval","_wsReady","websocket","onopen","_requests","onmessage","messageEvent","String","callback","sub","_subs","subscription","console","fauxPoll","setInterval","unref","_websocket","_detectNetwork","resetEventsBlock","polling","_subscribe","param","subIdPromise","_subIds","subId","_getFilter","removed","filterLog","emitReceipt","getTransactionReceipt","receipt","_events","destroy","readyState","CONNECTING","onerror","close","Formatter","formats","getDefaultFormats","bigNumber","allowNull","transactionIndex","uint256","s","raw","transactionRequest","receiptLog","arrayOf","logIndex","root","gasUsed","logsBloom","cumulativeGasUsed","effectiveGasPrice","parentHash","difficulty","miner","extraData","baseFeePerGas","blockWithTransactions","allowFalsish","strict","callAddress","_block","format","author","_difficulty","gas","input","networkId","byzantium","object","checkKey","checkValue","nullValue","replaceValue","isCommunityResourcable","throttleMessage","showThrottleMessage","defineReadOnly","enumerable","writable","getStatic","ctor","prototype","getPrototypeOf","resolveProperties","promises","checkProperties","properties","shallowCopy","opaque","bigint","string","_isFrozen","isFrozen","_deepCopy","deepCopy","Description","info","checkTopic","topic","serializeTopics","pop","unique","sorted","getEventTag","eventName","isForkEvent","PollableEvents","Event","listener","once","_lastBlockNumber","_inflight","split","comps","deserializeTopics","pollable","coinInfos","symbol","p2pkh","p2sh","prefix","ilk","bytes32ify","toHexString","base58Encode","encode","matcherIpfs","RegExp","matchers","_parseString","_parseBytes","offset","getIpfsLink","link","numPad","padded","bytesPad","encodeBytes","datas","byteCount","Resolver","resolvedAddress","supportsWildcard","_supportsEip2544","eq","_fetch","selector","parameters","ccipReadEnabled","parseBytes","_fetchBytes","_getAddress","coinType","hexBytes","coinInfo","bytes","words","toWords","unshift","getAvatar","linkage","content","avatar","getText","scheme","owner","_resolvedAddress","addr","tokenId","tokenOwner","balance","metadataUrl","metadata","imageUrl","image","getContentHash","ipfs","ipns","swarm","skynet","urlSafe","keyBytes","defaultFormatter","nextPollId","BaseProvider","disableCcipRead","getFormatter","anyNetwork","_networkPromise","_ready","knownNetwork","_maxInternalBlockNumber","_maxFilterBlockRange","_fastQueryDate","ready","ccipReadFetch","calldata","urls","errorMessages","href","json","errorPassThrough","statusCode","errorMessage","m","maxAge","_internalBlockNumber","internalBlockNumber","respTime","reqTime","checkInternalBlockNumber","networkError","_setFastBlockNumber","pollId","runners","makeError","previousBlockNumber","eventBlockNumber","minFromBlock","currentNetwork","_fastBlockNumber","_fastBlockNumberPromise","detectedNetwork","_poller","_bootstrapPoll","clearInterval","_getFastBlockNumber","_waitForTransaction","replaceable","cancelFuncs","alreadyDone","minedHandler","on","removeListener","lastBlockNumber","scannedBlock","replaceHandler","getTransactionCount","mined","getBlockWithTransactions","ti","TRANSACTION_REPLACED","replacement","TIMEOUT","getGasPrice","getBalance","_getBlockTag","getCode","p","expectedHash","returnedHash","confirms","t","_getTransactionRequest","_call","redirects","txSender","signature","urlsOffset","urlsLength","urlsData","u","callbackSelector","ccipResult","resolved","_getBlock","blockHashOrBlockTag","blockWithTxs","getResolver","currentName","_getResolver","resolver","addrData","lookupAddress","node","resolverAddr","nameOrAddress","resolverAddress","_addEventListener","stopped","eventTag","listeners","off","removeAllListeners","found","arrayifyInteger","unarrayifyInteger","_encode","child","concat","_decodeChildren","childOffset","decoded","_decode","consumed","BUFFER_OVERRUN","lengthLength","decode"],"mappings":"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","file":"js/chunk-vendors~d6b3b356.b2d48e08.js","sourcesContent":["export const version = \"networks/5.7.1\";\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\", \"sepolia\"];\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                const skip = [\"ropsten\"];\n                const provider = new providers.AnkrProvider(network, options.ankr);\n                if (provider.network && skip.indexOf(provider.network.name) === -1) {\n                    providerList.push(provider);\n                }\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    sepolia: {\n        chainId: 11155111,\n        name: \"sepolia\",\n        _defaultProvider: ethDefaultProvider(\"sepolia\")\n    },\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: {\n        chainId: 137,\n        name: \"matic\",\n        _defaultProvider: ethDefaultProvider(\"matic\")\n    },\n    maticmum: { chainId: 80001, name: \"maticmum\" },\n    optimism: {\n        chainId: 10,\n        name: \"optimism\",\n        _defaultProvider: ethDefaultProvider(\"optimism\")\n    },\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    \"arbitrum-goerli\": { chainId: 421613, name: \"arbitrum-goerli\" },\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","\"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 \"goerli\":\n                host = \"eth-goerli.g.alchemy.com/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-goerli\":\n                host = \"arb-goerli.g.alchemy.com/v2/\";\n                break;\n            case \"optimism\":\n                host = \"opt-mainnet.g.alchemy.com/v2/\";\n                break;\n            case \"optimism-goerli\":\n                host = \"opt-goerli.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 \"ropsten\":\n            return \"rpc.ankr.com/eth_ropsten/\";\n        case \"rinkeby\":\n            return \"rpc.ankr.com/eth_rinkeby/\";\n        case \"goerli\":\n            return \"rpc.ankr.com/eth_goerli/\";\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 || typeof (result.message) !== \"string\" || !result.message.match(/^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}\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        super(network);\n        defineReadOnly(this, \"baseUrl\", this.getBaseUrl());\n        defineReadOnly(this, \"apiKey\", apiKey || null);\n    }\n    getBaseUrl() {\n        switch (this.network ? this.network.name : \"invalid\") {\n            case \"homestead\":\n                return \"https:/\\/api.etherscan.io\";\n            case \"goerli\":\n                return \"https:/\\/api-goerli.etherscan.io\";\n            case \"sepolia\":\n                return \"https:/\\/api-sepolia.etherscan.io\";\n            case \"matic\":\n                return \"https:/\\/api.polygonscan.com\";\n            case \"maticmum\":\n                return \"https:/\\/api-testnet.polygonscan.com\";\n            case \"arbitrum\":\n                return \"https:/\\/api.arbiscan.io\";\n            case \"arbitrum-goerli\":\n                return \"https:/\\/api-goerli.arbiscan.io\";\n            case \"optimism\":\n                return \"https:/\\/api-optimistic.etherscan.io\";\n            case \"optimism-goerli\":\n                return \"https:/\\/api-goerli-optimistic.etherscan.io\";\n            default:\n        }\n        return logger.throwArgumentError(\"unsupported network\", \"network\", this.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 == null);\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                if (method === \"call\" && params.blockTag) {\n                    return provider[method](params.transaction, params.blockTag);\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        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 \"goerli\":\n                host = \"goerli.infura.io\";\n                break;\n            case \"sepolia\":\n                host = \"sepolia.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-goerli\":\n                host = \"optimism-goerli.infura.io\";\n                break;\n            case \"arbitrum\":\n                host = \"arbitrum-mainnet.infura.io\";\n                break;\n            case \"arbitrum-goerli\":\n                host = \"arbitrum-goerli.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 { Logger } from \"@ethersproject/logger\";\nimport { version } from \"./_version\";\nconst logger = new Logger(version);\nimport { UrlJsonRpcProvider } from \"./url-json-rpc-provider\";\nconst defaultApplicationId = \"62e1ad51b37b8e00394bda3b\";\nexport class PocketProvider extends UrlJsonRpcProvider {\n    static getApiKey(apiKey) {\n        const apiKeyObj = {\n            applicationId: null,\n            loadBalancer: true,\n            applicationSecretKey: null\n        };\n        // Parse applicationId and applicationSecretKey\n        if (apiKey == null) {\n            apiKeyObj.applicationId = defaultApplicationId;\n        }\n        else if (typeof (apiKey) === \"string\") {\n            apiKeyObj.applicationId = apiKey;\n        }\n        else if (apiKey.applicationSecretKey != null) {\n            apiKeyObj.applicationId = apiKey.applicationId;\n            apiKeyObj.applicationSecretKey = apiKey.applicationSecretKey;\n        }\n        else if (apiKey.applicationId) {\n            apiKeyObj.applicationId = apiKey.applicationId;\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 \"goerli\":\n                host = \"eth-goerli.gateway.pokt.network\";\n                break;\n            case \"homestead\":\n                host = \"eth-mainnet.gateway.pokt.network\";\n                break;\n            case \"kovan\":\n                host = \"poa-kovan.gateway.pokt.network\";\n                break;\n            case \"matic\":\n                host = \"poly-mainnet.gateway.pokt.network\";\n                break;\n            case \"maticmum\":\n                host = \"polygon-mumbai-rpc.gateway.pokt.network\";\n                break;\n            case \"rinkeby\":\n                host = \"eth-rinkeby.gateway.pokt.network\";\n                break;\n            case \"ropsten\":\n                host = \"eth-ropsten.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        const url = `https:/\\/${host}/v1/lb/${apiKey.applicationId}`;\n        const connection = { headers: {}, url };\n        if (apiKey.applicationSecretKey != null) {\n            connection.user = \"\";\n            connection.password = apiKey.applicationSecretKey;\n        }\n        return connection;\n    }\n    isCommunityResource() {\n        return (this.applicationId === defaultApplicationId);\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        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].toLowerCase()) {\n                case \"http\":\n                case \"https\":\n                    return new JsonRpcProvider(network);\n                case \"ws\":\n                case \"wss\":\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\";\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, hexZeroPad, 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, requireData) {\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\")) {\n        const data = isHexString(value.data) ? value.data : null;\n        if (!requireData || data) {\n            return { message: value.message, data };\n        }\n    }\n    // Spelunk further...\n    if (typeof (value) === \"object\") {\n        for (const key in value) {\n            const result = spelunk(value[key], requireData);\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), requireData);\n        }\n        catch (error) { }\n    }\n    return null;\n}\nfunction checkError(method, error, params) {\n    const transaction = params.transaction || params.signedTransaction;\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, true);\n        if (result) {\n            return result.data;\n        }\n        // Nothing descriptive..\n        logger.throwError(\"missing revert data in call exception; Transaction reverted without a reason string\", Logger.errors.CALL_EXCEPTION, {\n            data: \"0x\", transaction, error\n        });\n    }\n    if (method === \"estimateGas\") {\n        // Try to find something, with a preference on SERVER_ERROR body\n        let result = spelunk(error.body, false);\n        if (result == null) {\n            result = spelunk(error, false);\n        }\n        // Found \"reverted\", this is a CALL_EXCEPTION\n        if (result) {\n            logger.throwError(\"cannot estimate gas; transaction may fail or may require manual gas limit\", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {\n                reason: result.message, method, transaction, error\n            });\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    // \"insufficient funds for gas * price + value + cost(data)\"\n    if (message.match(/insufficient funds|base fee exceeds gas limit|InsufficientFunds/i)) {\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/i)) {\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|transaction gas price.*too low/i)) {\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/i)) {\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|revert/)) {\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        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                if (typeof (error.message) === \"string\" && error.message.match(/user denied/i)) {\n                    logger.throwError(\"user rejected transaction\", Logger.errors.ACTION_REJECTED, {\n                        action: \"sendTransaction\",\n                        transaction: tx\n                    });\n                }\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            try {\n                return yield this.provider.send(\"personal_sign\", [hexlify(data), address.toLowerCase()]);\n            }\n            catch (error) {\n                if (typeof (error.message) === \"string\" && error.message.match(/user denied/i)) {\n                    logger.throwError(\"user rejected signing\", Logger.errors.ACTION_REJECTED, {\n                        action: \"signMessage\",\n                        from: address,\n                        messageData: message\n                    });\n                }\n                throw error;\n            }\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            try {\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            catch (error) {\n                if (typeof (error.message) === \"string\" && error.message.match(/user denied/i)) {\n                    logger.throwError(\"user rejected signing\", Logger.errors.ACTION_REJECTED, {\n                        action: \"_legacySignMessage\",\n                        from: address,\n                        messageData: message\n                    });\n                }\n                throw error;\n            }\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            try {\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            catch (error) {\n                if (typeof (error.message) === \"string\" && error.message.match(/user denied/i)) {\n                    logger.throwError(\"user rejected signing\", Logger.errors.ACTION_REJECTED, {\n                        action: \"_signTypedData\",\n                        from: address,\n                        messageData: { domain: populated.domain, types, value: populated.value }\n                    });\n                }\n                throw error;\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        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), hexZeroPad(params.position, 32), 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-1559\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(BigNumber.from(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 { 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\";\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","export const version = \"providers/5.7.2\";\n//# sourceMappingURL=_version.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 { 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\";\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        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        switch (blockTag) {\n            case \"earliest\": return \"0x0\";\n            case \"latest\":\n            case \"pending\":\n            case \"safe\":\n            case \"finalized\":\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 { 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.7.0\";\n//# sourceMappingURL=_version.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nimport { ForkEvent, Provider } from \"@ethersproject/abstract-provider\";\nimport { encode as base64Encode } from \"@ethersproject/base64\";\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            const skynet = hexBytes.match(/^0x90b2c605([0-9a-f]*)$/);\n            if (skynet) {\n                if (skynet[1].length === (34 * 2)) {\n                    // URL Safe base64; https://datatracker.ietf.org/doc/html/rfc4648#section-5\n                    const urlSafe = { \"=\": \"\", \"+\": \"-\", \"/\": \"_\" };\n                    const hash = base64Encode(\"0x\" + skynet[1]).replace(/[=+\\/]/g, (a) => (urlSafe[a]));\n                    return \"sia:/\\/\" + hash;\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        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                            // This is the first filter for this event, so we want to\n                            // restrict events to events that happened no earlier than now\n                            if (event._lastBlockNumber === -2) {\n                                event._lastBlockNumber = blockNumber - 1;\n                            }\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, since it is quite\n                            // likely there just haven't been any events to move the lastBlockNumber.\n                            const minFromBlock = filter.toBlock - this._maxFilterBlockRange;\n                            if (minFromBlock > filter.fromBlock) {\n                                filter.fromBlock = minFromBlock;\n                            }\n                            if (filter.fromBlock < 0) {\n                                filter.fromBlock = 0;\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 wildcard 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 resolver\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","export const version = \"rlp/5.7.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.7.0\";\n//# sourceMappingURL=_version.js.map"],"sourceRoot":""}