{"version":3,"sources":["webpack:///./node_modules/@ethereumjs/common/dist.browser/eips/index.js","webpack:///./node_modules/@ethereumjs/common/dist.browser/index.js","webpack:///./node_modules/@ethereumjs/common/dist.browser/hardforks/index.js","webpack:///./node_modules/@ethereumjs/common/dist.browser/chains/index.js"],"names":["Object","defineProperty","exports","value","EIPs","1153","1559","2315","2537","2565","2718","2929","2930","3198","3529","3540","3541","3554","3607","3651","3670","3675","3855","3860","4345","4399","__extends","this","extendStatics","d","b","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","TypeError","String","__","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","__values","o","Symbol","iterator","m","next","done","ConsensusAlgorithm","ConsensusType","Hardfork","Chain","CustomChain","events_1","crc_32_1","ethereumjs_util_1","chains_1","hardforks_1","eips_1","Common","_super","opts","e_1","_a","_b","_c","_this","_supportedHardforks","_eips","_customChains","customChains","_chainParams","setChain","chain","DEFAULT_HARDFORK","defaultHardfork","Istanbul","_d","hardforks","_e","hf","forkHash","_calcForkHash","name","e_1_1","error","return","_hardfork","supportedHardforks","hardfork","setHardfork","eips","setEIPs","custom","chainParamsOrName","baseChain","standardChainParams","_getChainParams","PolygonMainnet","chainId","networkId","PolygonMumbai","ArbitrumRinkebyTestnet","xDaiChain","OptimisticKovan","Berlin","OptimisticEthereum","Error","concat","forCustomChain","customChainParams","isSupportedChainId","initializedChains","_getInitializedChains","Boolean","toString","BN","isBN","e_2","plainCustomChains","isArray","map","e","required_1","required_1_1","param","e_2_1","e_3","_isSupportedHardfork","existing","HARDFORK_CHANGES_1","HARDFORK_CHANGES_1_1","emit","e_3_1","getHardforkByBlockNumber","blockNumber","td","e_4","toType","TypeOutput","minTdHF","maxTdHF","previousHF","Chainstart","block","gte","e_4_1","msgAdd","hardforkGteHardfork","msg","setHardforkByBlockNumber","_chooseHardfork","onlySupported","_getHardfork","e_5","hfs","hfs_1","hfs_1_1","e_5_1","chainName","e_6","e_6_1","e_7","_loop_1","eip","minHF","this_1","gteHardfork","requiredEIPs","forEach","elem","includes","isActivatedEIP","eips_2","eips_2_1","e_7_1","topic","e_8","paramByEIP","e_8_1","paramByHardfork","e_9","e_10","HARDFORK_CHANGES_2","HARDFORK_CHANGES_2_1","hfChanges","hfEIPs","hfEIPs_1","hfEIPs_1_1","valueEIP","e_10_1","v","e_9_1","eipParams","paramByBlock","activeHfs","activeHardforks","e_11","HARDFORK_CHANGES_3","HARDFORK_CHANGES_3_1","e_11_1","hardforkIsActiveOnBlock","hfBlock","hardforkBlockBN","activeOnBlock","hardfork1","hardfork2","e_12","onlyActive","posHf1","posHf2","index","hardforks_2","hardforks_2_1","e_12_1","hardforkIsActiveOnChain","e_13","e_13_1","e_14","hfs_2","hfs_2_1","push","e_14_1","activeHardfork","hardforkBlock","Number","hardforkTD","isHardforkBlock","eq","nextHardforkBlock","nextHardforkBlockBN","nextHfBlock","reduce","acc","gt","isNextHardforkBlock","e_15","genesis","Buffer","from","hash","substr","hfBuffer","alloc","prevBlock","hfBlockBuffer","padStart","e_15_1","inputBuffer","forkhash","intToBuffer","buf","data","hardforkForForkHash","resArray","filter","genesisState","e_16","chainArrayWithGenesis","e_16_1","bootstrapNodes","dnsNetworks","chainIdBN","networkIdBN","consensusType","e_17","HARDFORK_CHANGES_4","HARDFORK_CHANGES_4_1","e_17_1","consensusAlgorithm","e_18","HARDFORK_CHANGES_5","HARDFORK_CHANGES_5_1","e_18_1","consensusConfig","e_19","HARDFORK_CHANGES_6","HARDFORK_CHANGES_6_1","e_19_1","copy","getPrototypeOf","removeAllListeners","EventEmitter","default","__importDefault","mod","__esModule","chains","mainnet_json_1","ropsten_json_1","rinkeby_json_1","kovan_json_1","goerli_json_1","sepolia_json_1","names","mainnet","ropsten","rinkeby","kovan","goerli","sepolia","customChains_1","customChains_1_1","name_1"],"mappings":"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","file":"js/chunk-vendors~474544b1.099b95cc.js","sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.EIPs = void 0;\nexports.EIPs = {\n    1153: require('./1153.json'),\n    1559: require('./1559.json'),\n    2315: require('./2315.json'),\n    2537: require('./2537.json'),\n    2565: require('./2565.json'),\n    2718: require('./2718.json'),\n    2929: require('./2929.json'),\n    2930: require('./2930.json'),\n    3198: require('./3198.json'),\n    3529: require('./3529.json'),\n    3540: require('./3540.json'),\n    3541: require('./3541.json'),\n    3554: require('./3554.json'),\n    3607: require('./3607.json'),\n    3651: require('./3651.json'),\n    3670: require('./3670.json'),\n    3675: require('./3675.json'),\n    3855: require('./3855.json'),\n    3860: require('./3860.json'),\n    4345: require('./4345.json'),\n    4399: require('./4399.json'),\n};\n//# sourceMappingURL=index.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ConsensusAlgorithm = exports.ConsensusType = exports.Hardfork = exports.Chain = exports.CustomChain = void 0;\nvar events_1 = require(\"events\");\nvar crc_32_1 = require(\"crc-32\");\nvar ethereumjs_util_1 = require(\"ethereumjs-util\");\nvar chains_1 = require(\"./chains\");\nvar hardforks_1 = require(\"./hardforks\");\nvar eips_1 = require(\"./eips\");\nvar CustomChain;\n(function (CustomChain) {\n    /**\n     * Polygon (Matic) Mainnet\n     *\n     * - [Documentation](https://docs.matic.network/docs/develop/network-details/network)\n     */\n    CustomChain[\"PolygonMainnet\"] = \"polygon-mainnet\";\n    /**\n     * Polygon (Matic) Mumbai Testnet\n     *\n     * - [Documentation](https://docs.matic.network/docs/develop/network-details/network)\n     */\n    CustomChain[\"PolygonMumbai\"] = \"polygon-mumbai\";\n    /**\n     * Arbitrum Rinkeby Testnet\n     *\n     * - [Documentation](https://developer.offchainlabs.com/docs/public_testnet)\n     */\n    CustomChain[\"ArbitrumRinkebyTestnet\"] = \"arbitrum-rinkeby-testnet\";\n    /**\n     * xDai EVM sidechain with a native stable token\n     *\n     * - [Documentation](https://www.xdaichain.com/)\n     */\n    CustomChain[\"xDaiChain\"] = \"x-dai-chain\";\n    /**\n     * Optimistic Kovan - testnet for Optimism roll-up\n     *\n     * - [Documentation](https://community.optimism.io/docs/developers/tutorials.html)\n     */\n    CustomChain[\"OptimisticKovan\"] = \"optimistic-kovan\";\n    /**\n     * Optimistic Ethereum - mainnet for Optimism roll-up\n     *\n     * - [Documentation](https://community.optimism.io/docs/developers/tutorials.html)\n     */\n    CustomChain[\"OptimisticEthereum\"] = \"optimistic-ethereum\";\n})(CustomChain = exports.CustomChain || (exports.CustomChain = {}));\nvar Chain;\n(function (Chain) {\n    Chain[Chain[\"Mainnet\"] = 1] = \"Mainnet\";\n    Chain[Chain[\"Ropsten\"] = 3] = \"Ropsten\";\n    Chain[Chain[\"Rinkeby\"] = 4] = \"Rinkeby\";\n    Chain[Chain[\"Kovan\"] = 42] = \"Kovan\";\n    Chain[Chain[\"Goerli\"] = 5] = \"Goerli\";\n    Chain[Chain[\"Sepolia\"] = 11155111] = \"Sepolia\";\n})(Chain = exports.Chain || (exports.Chain = {}));\nvar Hardfork;\n(function (Hardfork) {\n    Hardfork[\"Chainstart\"] = \"chainstart\";\n    Hardfork[\"Homestead\"] = \"homestead\";\n    Hardfork[\"Dao\"] = \"dao\";\n    Hardfork[\"TangerineWhistle\"] = \"tangerineWhistle\";\n    Hardfork[\"SpuriousDragon\"] = \"spuriousDragon\";\n    Hardfork[\"Byzantium\"] = \"byzantium\";\n    Hardfork[\"Constantinople\"] = \"constantinople\";\n    Hardfork[\"Petersburg\"] = \"petersburg\";\n    Hardfork[\"Istanbul\"] = \"istanbul\";\n    Hardfork[\"MuirGlacier\"] = \"muirGlacier\";\n    Hardfork[\"Berlin\"] = \"berlin\";\n    Hardfork[\"London\"] = \"london\";\n    Hardfork[\"ArrowGlacier\"] = \"arrowGlacier\";\n    Hardfork[\"Shanghai\"] = \"shanghai\";\n    Hardfork[\"MergeForkIdTransition\"] = \"mergeForkIdTransition\";\n    Hardfork[\"Merge\"] = \"merge\";\n})(Hardfork = exports.Hardfork || (exports.Hardfork = {}));\nvar ConsensusType;\n(function (ConsensusType) {\n    ConsensusType[\"ProofOfStake\"] = \"pos\";\n    ConsensusType[\"ProofOfWork\"] = \"pow\";\n    ConsensusType[\"ProofOfAuthority\"] = \"poa\";\n})(ConsensusType = exports.ConsensusType || (exports.ConsensusType = {}));\nvar ConsensusAlgorithm;\n(function (ConsensusAlgorithm) {\n    ConsensusAlgorithm[\"Ethash\"] = \"ethash\";\n    ConsensusAlgorithm[\"Clique\"] = \"clique\";\n    ConsensusAlgorithm[\"Casper\"] = \"casper\";\n})(ConsensusAlgorithm = exports.ConsensusAlgorithm || (exports.ConsensusAlgorithm = {}));\n/**\n * Common class to access chain and hardfork parameters and to provide\n * a unified and shared view on the network and hardfork state.\n *\n * Use the {@link Common.custom} static constructor for creating simple\n * custom chain {@link Common} objects (more complete custom chain setups\n * can be created via the main constructor and the {@link CommonOpts.customChains} parameter).\n */\nvar Common = /** @class */ (function (_super) {\n    __extends(Common, _super);\n    /**\n     *\n     * @constructor\n     */\n    function Common(opts) {\n        var e_1, _a;\n        var _this = this;\n        var _b, _c;\n        _this = _super.call(this) || this;\n        _this._supportedHardforks = [];\n        _this._eips = [];\n        _this._customChains = (_b = opts.customChains) !== null && _b !== void 0 ? _b : [];\n        _this._chainParams = _this.setChain(opts.chain);\n        _this.DEFAULT_HARDFORK = (_c = _this._chainParams.defaultHardfork) !== null && _c !== void 0 ? _c : Hardfork.Istanbul;\n        try {\n            for (var _d = __values(_this._chainParams.hardforks), _e = _d.next(); !_e.done; _e = _d.next()) {\n                var hf = _e.value;\n                if (!hf.forkHash) {\n                    hf.forkHash = _this._calcForkHash(hf.name);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        _this._hardfork = _this.DEFAULT_HARDFORK;\n        if (opts.supportedHardforks) {\n            _this._supportedHardforks = opts.supportedHardforks;\n        }\n        if (opts.hardfork) {\n            _this.setHardfork(opts.hardfork);\n        }\n        if (opts.eips) {\n            _this.setEIPs(opts.eips);\n        }\n        return _this;\n    }\n    /**\n     * Creates a {@link Common} object for a custom chain, based on a standard one.\n     *\n     * It uses all the {@link Chain} parameters from the {@link baseChain} option except the ones overridden\n     * in a provided {@link chainParamsOrName} dictionary. Some usage example:\n     *\n     * ```javascript\n     * Common.custom({chainId: 123})\n     * ```\n     *\n     * There are also selected supported custom chains which can be initialized by using one of the\n     * {@link CustomChains} for {@link chainParamsOrName}, e.g.:\n     *\n     * ```javascript\n     * Common.custom(CustomChains.MaticMumbai)\n     * ```\n     *\n     * Note that these supported custom chains only provide some base parameters (usually the chain and\n     * network ID and a name) and can only be used for selected use cases (e.g. sending a tx with\n     * the `@ethereumjs/tx` library to a Layer-2 chain).\n     *\n     * @param chainParamsOrName Custom parameter dict (`name` will default to `custom-chain`) or string with name of a supported custom chain\n     * @param opts Custom chain options to set the {@link CustomCommonOpts.baseChain}, selected {@link CustomCommonOpts.hardfork} and others\n     */\n    Common.custom = function (chainParamsOrName, opts) {\n        var _a;\n        if (opts === void 0) { opts = {}; }\n        var baseChain = (_a = opts.baseChain) !== null && _a !== void 0 ? _a : 'mainnet';\n        var standardChainParams = __assign({}, Common._getChainParams(baseChain));\n        standardChainParams['name'] = 'custom-chain';\n        if (typeof chainParamsOrName !== 'string') {\n            return new Common(__assign({ chain: __assign(__assign({}, standardChainParams), chainParamsOrName) }, opts));\n        }\n        else {\n            if (chainParamsOrName === CustomChain.PolygonMainnet) {\n                return Common.custom({\n                    name: CustomChain.PolygonMainnet,\n                    chainId: 137,\n                    networkId: 137,\n                }, opts);\n            }\n            if (chainParamsOrName === CustomChain.PolygonMumbai) {\n                return Common.custom({\n                    name: CustomChain.PolygonMumbai,\n                    chainId: 80001,\n                    networkId: 80001,\n                }, opts);\n            }\n            if (chainParamsOrName === CustomChain.ArbitrumRinkebyTestnet) {\n                return Common.custom({\n                    name: CustomChain.ArbitrumRinkebyTestnet,\n                    chainId: 421611,\n                    networkId: 421611,\n                }, opts);\n            }\n            if (chainParamsOrName === CustomChain.xDaiChain) {\n                return Common.custom({\n                    name: CustomChain.xDaiChain,\n                    chainId: 100,\n                    networkId: 100,\n                }, opts);\n            }\n            if (chainParamsOrName === CustomChain.OptimisticKovan) {\n                return Common.custom({\n                    name: CustomChain.OptimisticKovan,\n                    chainId: 69,\n                    networkId: 69,\n                }, __assign({ hardfork: Hardfork.Berlin }, opts));\n            }\n            if (chainParamsOrName === CustomChain.OptimisticEthereum) {\n                return Common.custom({\n                    name: CustomChain.OptimisticEthereum,\n                    chainId: 10,\n                    networkId: 10,\n                }, __assign({ hardfork: Hardfork.Berlin }, opts));\n            }\n            throw new Error(\"Custom chain \".concat(chainParamsOrName, \" not supported\"));\n        }\n    };\n    /**\n     * Creates a {@link Common} object for a custom chain, based on a standard one. It uses all the `Chain`\n     * params from {@link baseChain} except the ones overridden in {@link customChainParams}.\n     *\n     * @deprecated Use {@link Common.custom} instead\n     *\n     * @param baseChain The name (`mainnet`) or id (`1`) of a standard chain used to base the custom\n     * chain params on.\n     * @param customChainParams The custom parameters of the chain.\n     * @param hardfork String identifier ('byzantium') for hardfork (optional)\n     * @param supportedHardforks Limit parameter returns to the given hardforks (optional)\n     */\n    Common.forCustomChain = function (baseChain, customChainParams, hardfork, supportedHardforks) {\n        var standardChainParams = Common._getChainParams(baseChain);\n        return new Common({\n            chain: __assign(__assign({}, standardChainParams), customChainParams),\n            hardfork: hardfork,\n            supportedHardforks: supportedHardforks,\n        });\n    };\n    /**\n     * Static method to determine if a {@link chainId} is supported as a standard chain\n     * @param chainId BN id (`1`) of a standard chain\n     * @returns boolean\n     */\n    Common.isSupportedChainId = function (chainId) {\n        var initializedChains = (0, chains_1._getInitializedChains)();\n        return Boolean(initializedChains['names'][chainId.toString()]);\n    };\n    Common._getChainParams = function (chain, customChains) {\n        var initializedChains = (0, chains_1._getInitializedChains)(customChains);\n        if (typeof chain === 'number' || ethereumjs_util_1.BN.isBN(chain)) {\n            chain = chain.toString();\n            if (initializedChains['names'][chain]) {\n                var name_1 = initializedChains['names'][chain];\n                return initializedChains[name_1];\n            }\n            throw new Error(\"Chain with ID \".concat(chain, \" not supported\"));\n        }\n        if (initializedChains[chain]) {\n            return initializedChains[chain];\n        }\n        throw new Error(\"Chain with name \".concat(chain, \" not supported\"));\n    };\n    /**\n     * Sets the chain\n     * @param chain String ('mainnet') or Number (1) chain\n     *     representation. Or, a Dictionary of chain parameters for a private network.\n     * @returns The dictionary with parameters set as chain\n     */\n    Common.prototype.setChain = function (chain) {\n        var e_2, _a;\n        if (typeof chain === 'number' || typeof chain === 'string' || ethereumjs_util_1.BN.isBN(chain)) {\n            // Filter out genesis states if passed in to customChains\n            var plainCustomChains = void 0;\n            if (this._customChains &&\n                this._customChains.length > 0 &&\n                Array.isArray(this._customChains[0])) {\n                plainCustomChains = this._customChains.map(function (e) { return e[0]; });\n            }\n            else {\n                plainCustomChains = this._customChains;\n            }\n            this._chainParams = Common._getChainParams(chain, plainCustomChains);\n        }\n        else if (typeof chain === 'object') {\n            if (this._customChains.length > 0) {\n                throw new Error('Chain must be a string, number, or BN when initialized with customChains passed in');\n            }\n            var required = ['networkId', 'genesis', 'hardforks', 'bootstrapNodes'];\n            try {\n                for (var required_1 = __values(required), required_1_1 = required_1.next(); !required_1_1.done; required_1_1 = required_1.next()) {\n                    var param = required_1_1.value;\n                    if (chain[param] === undefined) {\n                        throw new Error(\"Missing required chain parameter: \".concat(param));\n                    }\n                }\n            }\n            catch (e_2_1) { e_2 = { error: e_2_1 }; }\n            finally {\n                try {\n                    if (required_1_1 && !required_1_1.done && (_a = required_1.return)) _a.call(required_1);\n                }\n                finally { if (e_2) throw e_2.error; }\n            }\n            this._chainParams = chain;\n        }\n        else {\n            throw new Error('Wrong input format');\n        }\n        return this._chainParams;\n    };\n    /**\n     * Sets the hardfork to get params for\n     * @param hardfork String identifier (e.g. 'byzantium') or {@link Hardfork} enum\n     */\n    Common.prototype.setHardfork = function (hardfork) {\n        var e_3, _a;\n        if (!this._isSupportedHardfork(hardfork)) {\n            throw new Error(\"Hardfork \".concat(hardfork, \" not set as supported in supportedHardforks\"));\n        }\n        var existing = false;\n        try {\n            for (var HARDFORK_CHANGES_1 = __values(hardforks_1.hardforks), HARDFORK_CHANGES_1_1 = HARDFORK_CHANGES_1.next(); !HARDFORK_CHANGES_1_1.done; HARDFORK_CHANGES_1_1 = HARDFORK_CHANGES_1.next()) {\n                var hfChanges = HARDFORK_CHANGES_1_1.value;\n                if (hfChanges[0] === hardfork) {\n                    if (this._hardfork !== hardfork) {\n                        this._hardfork = hardfork;\n                        this.emit('hardforkChanged', hardfork);\n                    }\n                    existing = true;\n                }\n            }\n        }\n        catch (e_3_1) { e_3 = { error: e_3_1 }; }\n        finally {\n            try {\n                if (HARDFORK_CHANGES_1_1 && !HARDFORK_CHANGES_1_1.done && (_a = HARDFORK_CHANGES_1.return)) _a.call(HARDFORK_CHANGES_1);\n            }\n            finally { if (e_3) throw e_3.error; }\n        }\n        if (!existing) {\n            throw new Error(\"Hardfork with name \".concat(hardfork, \" not supported\"));\n        }\n    };\n    /**\n     * Returns the hardfork based on the block number or an optional\n     * total difficulty (Merge HF) provided.\n     *\n     * An optional TD takes precedence in case the corresponding HF block\n     * is set to `null` or otherwise needs to match (if not an error\n     * will be thrown).\n     *\n     * @param blockNumber\n     * @param td\n     * @returns The name of the HF\n     */\n    Common.prototype.getHardforkByBlockNumber = function (blockNumber, td) {\n        var e_4, _a;\n        blockNumber = (0, ethereumjs_util_1.toType)(blockNumber, ethereumjs_util_1.TypeOutput.BN);\n        td = (0, ethereumjs_util_1.toType)(td, ethereumjs_util_1.TypeOutput.BN);\n        var hardfork = Hardfork.Chainstart;\n        var minTdHF;\n        var maxTdHF;\n        var previousHF;\n        try {\n            for (var _b = __values(this.hardforks()), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var hf = _c.value;\n                // Skip comparison for not applied HFs\n                if (hf.block === null) {\n                    if (td !== undefined && td !== null && hf.td !== undefined && hf.td !== null) {\n                        if (td.gte(new ethereumjs_util_1.BN(hf.td))) {\n                            return hf.name;\n                        }\n                    }\n                    continue;\n                }\n                if (blockNumber.gte(new ethereumjs_util_1.BN(hf.block))) {\n                    hardfork = hf.name;\n                }\n                if (td && hf.td) {\n                    if (td.gte(new ethereumjs_util_1.BN(hf.td))) {\n                        minTdHF = hf.name;\n                    }\n                    else {\n                        maxTdHF = previousHF;\n                    }\n                }\n                previousHF = hf.name;\n            }\n        }\n        catch (e_4_1) { e_4 = { error: e_4_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_4) throw e_4.error; }\n        }\n        if (td) {\n            var msgAdd = \"block number: \".concat(blockNumber, \" (-> \").concat(hardfork, \"), \");\n            if (minTdHF) {\n                if (!this.hardforkGteHardfork(hardfork, minTdHF)) {\n                    var msg = 'HF determined by block number is lower than the minimum total difficulty HF';\n                    msgAdd += \"total difficulty: \".concat(td, \" (-> \").concat(minTdHF, \")\");\n                    throw new Error(\"\".concat(msg, \": \").concat(msgAdd));\n                }\n            }\n            if (maxTdHF) {\n                if (!this.hardforkGteHardfork(maxTdHF, hardfork)) {\n                    var msg = 'Maximum HF determined by total difficulty is lower than the block number HF';\n                    msgAdd += \"total difficulty: \".concat(td, \" (-> \").concat(maxTdHF, \")\");\n                    throw new Error(\"\".concat(msg, \": \").concat(msgAdd));\n                }\n            }\n        }\n        return hardfork;\n    };\n    /**\n     * Sets a new hardfork based on the block number or an optional\n     * total difficulty (Merge HF) provided.\n     *\n     * An optional TD takes precedence in case the corresponding HF block\n     * is set to `null` or otherwise needs to match (if not an error\n     * will be thrown).\n     *\n     * @param blockNumber\n     * @param td\n     * @returns The name of the HF set\n     */\n    Common.prototype.setHardforkByBlockNumber = function (blockNumber, td) {\n        var hardfork = this.getHardforkByBlockNumber(blockNumber, td);\n        this.setHardfork(hardfork);\n        return hardfork;\n    };\n    /**\n     * Internal helper function to choose between hardfork set and hardfork provided as param\n     * @param hardfork Hardfork given to function as a parameter\n     * @returns Hardfork chosen to be used\n     */\n    Common.prototype._chooseHardfork = function (hardfork, onlySupported) {\n        if (onlySupported === void 0) { onlySupported = true; }\n        if (!hardfork) {\n            hardfork = this._hardfork;\n        }\n        else if (onlySupported && !this._isSupportedHardfork(hardfork)) {\n            throw new Error(\"Hardfork \".concat(hardfork, \" not set as supported in supportedHardforks\"));\n        }\n        return hardfork;\n    };\n    /**\n     * Internal helper function, returns the params for the given hardfork for the chain set\n     * @param hardfork Hardfork name\n     * @returns Dictionary with hardfork params\n     */\n    Common.prototype._getHardfork = function (hardfork) {\n        var e_5, _a;\n        var hfs = this.hardforks();\n        try {\n            for (var hfs_1 = __values(hfs), hfs_1_1 = hfs_1.next(); !hfs_1_1.done; hfs_1_1 = hfs_1.next()) {\n                var hf = hfs_1_1.value;\n                if (hf['name'] === hardfork)\n                    return hf;\n            }\n        }\n        catch (e_5_1) { e_5 = { error: e_5_1 }; }\n        finally {\n            try {\n                if (hfs_1_1 && !hfs_1_1.done && (_a = hfs_1.return)) _a.call(hfs_1);\n            }\n            finally { if (e_5) throw e_5.error; }\n        }\n        throw new Error(\"Hardfork \".concat(hardfork, \" not defined for chain \").concat(this.chainName()));\n    };\n    /**\n     * Internal helper function to check if a hardfork is set to be supported by the library\n     * @param hardfork Hardfork name\n     * @returns True if hardfork is supported\n     */\n    Common.prototype._isSupportedHardfork = function (hardfork) {\n        var e_6, _a;\n        if (this._supportedHardforks.length > 0) {\n            try {\n                for (var _b = __values(this._supportedHardforks), _c = _b.next(); !_c.done; _c = _b.next()) {\n                    var supportedHf = _c.value;\n                    if (hardfork === supportedHf)\n                        return true;\n                }\n            }\n            catch (e_6_1) { e_6 = { error: e_6_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n                }\n                finally { if (e_6) throw e_6.error; }\n            }\n        }\n        else {\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Sets the active EIPs\n     * @param eips\n     */\n    Common.prototype.setEIPs = function (eips) {\n        var e_7, _a;\n        var _this = this;\n        if (eips === void 0) { eips = []; }\n        var _loop_1 = function (eip) {\n            if (!(eip in eips_1.EIPs)) {\n                throw new Error(\"\".concat(eip, \" not supported\"));\n            }\n            var minHF = this_1.gteHardfork(eips_1.EIPs[eip]['minimumHardfork']);\n            if (!minHF) {\n                throw new Error(\"\".concat(eip, \" cannot be activated on hardfork \").concat(this_1.hardfork(), \", minimumHardfork: \").concat(minHF));\n            }\n            if (eips_1.EIPs[eip].requiredEIPs) {\n                ;\n                eips_1.EIPs[eip].requiredEIPs.forEach(function (elem) {\n                    if (!(eips.includes(elem) || _this.isActivatedEIP(elem))) {\n                        throw new Error(\"\".concat(eip, \" requires EIP \").concat(elem, \", but is not included in the EIP list\"));\n                    }\n                });\n            }\n        };\n        var this_1 = this;\n        try {\n            for (var eips_2 = __values(eips), eips_2_1 = eips_2.next(); !eips_2_1.done; eips_2_1 = eips_2.next()) {\n                var eip = eips_2_1.value;\n                _loop_1(eip);\n            }\n        }\n        catch (e_7_1) { e_7 = { error: e_7_1 }; }\n        finally {\n            try {\n                if (eips_2_1 && !eips_2_1.done && (_a = eips_2.return)) _a.call(eips_2);\n            }\n            finally { if (e_7) throw e_7.error; }\n        }\n        this._eips = eips;\n    };\n    /**\n     * Returns a parameter for the current chain setup\n     *\n     * If the parameter is present in an EIP, the EIP always takes precendence.\n     * Otherwise the parameter if taken from the latest applied HF with\n     * a change on the respective parameter.\n     *\n     * @param topic Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow')\n     * @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)\n     * @returns The value requested or `null` if not found\n     */\n    Common.prototype.param = function (topic, name) {\n        var e_8, _a;\n        // TODO: consider the case that different active EIPs\n        // can change the same parameter\n        var value = null;\n        try {\n            for (var _b = __values(this._eips), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var eip = _c.value;\n                value = this.paramByEIP(topic, name, eip);\n                if (value !== null) {\n                    return value;\n                }\n            }\n        }\n        catch (e_8_1) { e_8 = { error: e_8_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_8) throw e_8.error; }\n        }\n        return this.paramByHardfork(topic, name, this._hardfork);\n    };\n    /**\n     * Returns the parameter corresponding to a hardfork\n     * @param topic Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow')\n     * @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)\n     * @param hardfork Hardfork name\n     * @returns The value requested or `null` if not found\n     */\n    Common.prototype.paramByHardfork = function (topic, name, hardfork) {\n        var e_9, _a, e_10, _b;\n        hardfork = this._chooseHardfork(hardfork);\n        var value = null;\n        try {\n            for (var HARDFORK_CHANGES_2 = __values(hardforks_1.hardforks), HARDFORK_CHANGES_2_1 = HARDFORK_CHANGES_2.next(); !HARDFORK_CHANGES_2_1.done; HARDFORK_CHANGES_2_1 = HARDFORK_CHANGES_2.next()) {\n                var hfChanges = HARDFORK_CHANGES_2_1.value;\n                // EIP-referencing HF file (e.g. berlin.json)\n                if ('eips' in hfChanges[1]) {\n                    var hfEIPs = hfChanges[1]['eips'];\n                    try {\n                        for (var hfEIPs_1 = (e_10 = void 0, __values(hfEIPs)), hfEIPs_1_1 = hfEIPs_1.next(); !hfEIPs_1_1.done; hfEIPs_1_1 = hfEIPs_1.next()) {\n                            var eip = hfEIPs_1_1.value;\n                            var valueEIP = this.paramByEIP(topic, name, eip);\n                            value = valueEIP !== null ? valueEIP : value;\n                        }\n                    }\n                    catch (e_10_1) { e_10 = { error: e_10_1 }; }\n                    finally {\n                        try {\n                            if (hfEIPs_1_1 && !hfEIPs_1_1.done && (_b = hfEIPs_1.return)) _b.call(hfEIPs_1);\n                        }\n                        finally { if (e_10) throw e_10.error; }\n                    }\n                    // Paramater-inlining HF file (e.g. istanbul.json)\n                }\n                else {\n                    if (!hfChanges[1][topic]) {\n                        throw new Error(\"Topic \".concat(topic, \" not defined\"));\n                    }\n                    if (hfChanges[1][topic][name] !== undefined) {\n                        value = hfChanges[1][topic][name].v;\n                    }\n                }\n                if (hfChanges[0] === hardfork)\n                    break;\n            }\n        }\n        catch (e_9_1) { e_9 = { error: e_9_1 }; }\n        finally {\n            try {\n                if (HARDFORK_CHANGES_2_1 && !HARDFORK_CHANGES_2_1.done && (_a = HARDFORK_CHANGES_2.return)) _a.call(HARDFORK_CHANGES_2);\n            }\n            finally { if (e_9) throw e_9.error; }\n        }\n        return value;\n    };\n    /**\n     * Returns a parameter corresponding to an EIP\n     * @param topic Parameter topic ('gasConfig', 'gasPrices', 'vm', 'pow')\n     * @param name Parameter name (e.g. 'minGasLimit' for 'gasConfig' topic)\n     * @param eip Number of the EIP\n     * @returns The value requested or `null` if not found\n     */\n    Common.prototype.paramByEIP = function (topic, name, eip) {\n        if (!(eip in eips_1.EIPs)) {\n            throw new Error(\"\".concat(eip, \" not supported\"));\n        }\n        var eipParams = eips_1.EIPs[eip];\n        if (!(topic in eipParams)) {\n            throw new Error(\"Topic \".concat(topic, \" not defined\"));\n        }\n        if (eipParams[topic][name] === undefined) {\n            return null;\n        }\n        var value = eipParams[topic][name].v;\n        return value;\n    };\n    /**\n     * Returns a parameter for the hardfork active on block number\n     * @param topic Parameter topic\n     * @param name Parameter name\n     * @param blockNumber Block number\n     */\n    Common.prototype.paramByBlock = function (topic, name, blockNumber) {\n        var activeHfs = this.activeHardforks(blockNumber);\n        var hardfork = activeHfs[activeHfs.length - 1]['name'];\n        return this.paramByHardfork(topic, name, hardfork);\n    };\n    /**\n     * Checks if an EIP is activated by either being included in the EIPs\n     * manually passed in with the {@link CommonOpts.eips} or in a\n     * hardfork currently being active\n     *\n     * Note: this method only works for EIPs being supported\n     * by the {@link CommonOpts.eips} constructor option\n     * @param eip\n     */\n    Common.prototype.isActivatedEIP = function (eip) {\n        var e_11, _a;\n        if (this.eips().includes(eip)) {\n            return true;\n        }\n        try {\n            for (var HARDFORK_CHANGES_3 = __values(hardforks_1.hardforks), HARDFORK_CHANGES_3_1 = HARDFORK_CHANGES_3.next(); !HARDFORK_CHANGES_3_1.done; HARDFORK_CHANGES_3_1 = HARDFORK_CHANGES_3.next()) {\n                var hfChanges = HARDFORK_CHANGES_3_1.value;\n                var hf = hfChanges[1];\n                if (this.gteHardfork(hf['name']) && 'eips' in hf) {\n                    if (hf['eips'].includes(eip)) {\n                        return true;\n                    }\n                }\n            }\n        }\n        catch (e_11_1) { e_11 = { error: e_11_1 }; }\n        finally {\n            try {\n                if (HARDFORK_CHANGES_3_1 && !HARDFORK_CHANGES_3_1.done && (_a = HARDFORK_CHANGES_3.return)) _a.call(HARDFORK_CHANGES_3);\n            }\n            finally { if (e_11) throw e_11.error; }\n        }\n        return false;\n    };\n    /**\n     * Checks if set or provided hardfork is active on block number\n     * @param hardfork Hardfork name or null (for HF set)\n     * @param blockNumber\n     * @param opts Hardfork options (onlyActive unused)\n     * @returns True if HF is active on block number\n     */\n    Common.prototype.hardforkIsActiveOnBlock = function (hardfork, blockNumber, opts) {\n        var _a;\n        if (opts === void 0) { opts = {}; }\n        blockNumber = (0, ethereumjs_util_1.toType)(blockNumber, ethereumjs_util_1.TypeOutput.BN);\n        var onlySupported = (_a = opts.onlySupported) !== null && _a !== void 0 ? _a : false;\n        hardfork = this._chooseHardfork(hardfork, onlySupported);\n        var hfBlock = this.hardforkBlockBN(hardfork);\n        if (hfBlock && blockNumber.gte(hfBlock)) {\n            return true;\n        }\n        return false;\n    };\n    /**\n     * Alias to hardforkIsActiveOnBlock when hardfork is set\n     * @param blockNumber\n     * @param opts Hardfork options (onlyActive unused)\n     * @returns True if HF is active on block number\n     */\n    Common.prototype.activeOnBlock = function (blockNumber, opts) {\n        return this.hardforkIsActiveOnBlock(null, blockNumber, opts);\n    };\n    /**\n     * Sequence based check if given or set HF1 is greater than or equal HF2\n     * @param hardfork1 Hardfork name or null (if set)\n     * @param hardfork2 Hardfork name\n     * @param opts Hardfork options\n     * @returns True if HF1 gte HF2\n     */\n    Common.prototype.hardforkGteHardfork = function (hardfork1, hardfork2, opts) {\n        var e_12, _a;\n        if (opts === void 0) { opts = {}; }\n        var onlyActive = opts.onlyActive === undefined ? false : opts.onlyActive;\n        hardfork1 = this._chooseHardfork(hardfork1, opts.onlySupported);\n        var hardforks;\n        if (onlyActive) {\n            hardforks = this.activeHardforks(null, opts);\n        }\n        else {\n            hardforks = this.hardforks();\n        }\n        var posHf1 = -1, posHf2 = -1;\n        var index = 0;\n        try {\n            for (var hardforks_2 = __values(hardforks), hardforks_2_1 = hardforks_2.next(); !hardforks_2_1.done; hardforks_2_1 = hardforks_2.next()) {\n                var hf = hardforks_2_1.value;\n                if (hf['name'] === hardfork1)\n                    posHf1 = index;\n                if (hf['name'] === hardfork2)\n                    posHf2 = index;\n                index += 1;\n            }\n        }\n        catch (e_12_1) { e_12 = { error: e_12_1 }; }\n        finally {\n            try {\n                if (hardforks_2_1 && !hardforks_2_1.done && (_a = hardforks_2.return)) _a.call(hardforks_2);\n            }\n            finally { if (e_12) throw e_12.error; }\n        }\n        return posHf1 >= posHf2 && posHf2 !== -1;\n    };\n    /**\n     * Alias to hardforkGteHardfork when hardfork is set\n     * @param hardfork Hardfork name\n     * @param opts Hardfork options\n     * @returns True if hardfork set is greater than hardfork provided\n     */\n    Common.prototype.gteHardfork = function (hardfork, opts) {\n        return this.hardforkGteHardfork(null, hardfork, opts);\n    };\n    /**\n     * Checks if given or set hardfork is active on the chain\n     * @param hardfork Hardfork name, optional if HF set\n     * @param opts Hardfork options (onlyActive unused)\n     * @returns True if hardfork is active on the chain\n     */\n    Common.prototype.hardforkIsActiveOnChain = function (hardfork, opts) {\n        var e_13, _a;\n        var _b;\n        if (opts === void 0) { opts = {}; }\n        var onlySupported = (_b = opts.onlySupported) !== null && _b !== void 0 ? _b : false;\n        hardfork = this._chooseHardfork(hardfork, onlySupported);\n        try {\n            for (var _c = __values(this.hardforks()), _d = _c.next(); !_d.done; _d = _c.next()) {\n                var hf = _d.value;\n                if (hf['name'] === hardfork && hf['block'] !== null)\n                    return true;\n            }\n        }\n        catch (e_13_1) { e_13 = { error: e_13_1 }; }\n        finally {\n            try {\n                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n            }\n            finally { if (e_13) throw e_13.error; }\n        }\n        return false;\n    };\n    /**\n     * Returns the active hardfork switches for the current chain\n     * @param blockNumber up to block if provided, otherwise for the whole chain\n     * @param opts Hardfork options (onlyActive unused)\n     * @return Array with hardfork arrays\n     */\n    Common.prototype.activeHardforks = function (blockNumber, opts) {\n        var e_14, _a;\n        if (opts === void 0) { opts = {}; }\n        var activeHardforks = [];\n        var hfs = this.hardforks();\n        try {\n            for (var hfs_2 = __values(hfs), hfs_2_1 = hfs_2.next(); !hfs_2_1.done; hfs_2_1 = hfs_2.next()) {\n                var hf = hfs_2_1.value;\n                if (hf['block'] === null)\n                    continue;\n                if (blockNumber !== undefined && blockNumber !== null && blockNumber < hf['block'])\n                    break;\n                if (opts.onlySupported && !this._isSupportedHardfork(hf['name']))\n                    continue;\n                activeHardforks.push(hf);\n            }\n        }\n        catch (e_14_1) { e_14 = { error: e_14_1 }; }\n        finally {\n            try {\n                if (hfs_2_1 && !hfs_2_1.done && (_a = hfs_2.return)) _a.call(hfs_2);\n            }\n            finally { if (e_14) throw e_14.error; }\n        }\n        return activeHardforks;\n    };\n    /**\n     * Returns the latest active hardfork name for chain or block or throws if unavailable\n     * @param blockNumber up to block if provided, otherwise for the whole chain\n     * @param opts Hardfork options (onlyActive unused)\n     * @return Hardfork name\n     */\n    Common.prototype.activeHardfork = function (blockNumber, opts) {\n        if (opts === void 0) { opts = {}; }\n        var activeHardforks = this.activeHardforks(blockNumber, opts);\n        if (activeHardforks.length > 0) {\n            return activeHardforks[activeHardforks.length - 1]['name'];\n        }\n        else {\n            throw new Error(\"No (supported) active hardfork found\");\n        }\n    };\n    /**\n     * Returns the hardfork change block for hardfork provided or set\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns Block number or null if unscheduled\n     * @deprecated Please use {@link Common.hardforkBlockBN} for large number support\n     */\n    Common.prototype.hardforkBlock = function (hardfork) {\n        var block = this.hardforkBlockBN(hardfork);\n        return (0, ethereumjs_util_1.toType)(block, ethereumjs_util_1.TypeOutput.Number);\n    };\n    /**\n     * Returns the hardfork change block for hardfork provided or set\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns Block number or null if unscheduled\n     */\n    Common.prototype.hardforkBlockBN = function (hardfork) {\n        hardfork = this._chooseHardfork(hardfork, false);\n        var block = this._getHardfork(hardfork)['block'];\n        if (block === undefined || block === null) {\n            return null;\n        }\n        return new ethereumjs_util_1.BN(block);\n    };\n    /**\n     * Returns the hardfork change total difficulty (Merge HF) for hardfork provided or set\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns Total difficulty or null if no set\n     */\n    Common.prototype.hardforkTD = function (hardfork) {\n        hardfork = this._chooseHardfork(hardfork, false);\n        var td = this._getHardfork(hardfork)['td'];\n        if (td === undefined || td === null) {\n            return null;\n        }\n        return new ethereumjs_util_1.BN(td);\n    };\n    /**\n     * True if block number provided is the hardfork (given or set) change block\n     * @param blockNumber Number of the block to check\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns True if blockNumber is HF block\n     */\n    Common.prototype.isHardforkBlock = function (blockNumber, hardfork) {\n        blockNumber = (0, ethereumjs_util_1.toType)(blockNumber, ethereumjs_util_1.TypeOutput.BN);\n        hardfork = this._chooseHardfork(hardfork, false);\n        var block = this.hardforkBlockBN(hardfork);\n        return block ? block.eq(blockNumber) : false;\n    };\n    /**\n     * Returns the change block for the next hardfork after the hardfork provided or set\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns Block number or null if not available\n     * @deprecated Please use {@link Common.nextHardforkBlockBN} for large number support\n     */\n    Common.prototype.nextHardforkBlock = function (hardfork) {\n        var block = this.nextHardforkBlockBN(hardfork);\n        return (0, ethereumjs_util_1.toType)(block, ethereumjs_util_1.TypeOutput.Number);\n    };\n    /**\n     * Returns the change block for the next hardfork after the hardfork provided or set\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns Block number or null if not available\n     */\n    Common.prototype.nextHardforkBlockBN = function (hardfork) {\n        hardfork = this._chooseHardfork(hardfork, false);\n        var hfBlock = this.hardforkBlockBN(hardfork);\n        if (hfBlock === null) {\n            return null;\n        }\n        // Next fork block number or null if none available\n        // Logic: if accumulator is still null and on the first occurrence of\n        // a block greater than the current hfBlock set the accumulator,\n        // pass on the accumulator as the final result from this time on\n        var nextHfBlock = this.hardforks().reduce(function (acc, hf) {\n            var block = new ethereumjs_util_1.BN(hf.block);\n            return block.gt(hfBlock) && acc === null ? block : acc;\n        }, null);\n        return nextHfBlock;\n    };\n    /**\n     * True if block number provided is the hardfork change block following the hardfork given or set\n     * @param blockNumber Number of the block to check\n     * @param hardfork Hardfork name, optional if HF set\n     * @returns True if blockNumber is HF block\n     */\n    Common.prototype.isNextHardforkBlock = function (blockNumber, hardfork) {\n        blockNumber = (0, ethereumjs_util_1.toType)(blockNumber, ethereumjs_util_1.TypeOutput.BN);\n        hardfork = this._chooseHardfork(hardfork, false);\n        var nextHardforkBlock = this.nextHardforkBlockBN(hardfork);\n        return nextHardforkBlock === null ? false : nextHardforkBlock.eq(blockNumber);\n    };\n    /**\n     * Internal helper function to calculate a fork hash\n     * @param hardfork Hardfork name\n     * @returns Fork hash as hex string\n     */\n    Common.prototype._calcForkHash = function (hardfork) {\n        var e_15, _a;\n        var genesis = Buffer.from(this.genesis().hash.substr(2), 'hex');\n        var hfBuffer = Buffer.alloc(0);\n        var prevBlock = 0;\n        try {\n            for (var _b = __values(this.hardforks()), _c = _b.next(); !_c.done; _c = _b.next()) {\n                var hf = _c.value;\n                var block = hf.block;\n                // Skip for chainstart (0), not applied HFs (null) and\n                // when already applied on same block number HFs\n                if (block !== 0 && block !== null && block !== prevBlock) {\n                    var hfBlockBuffer = Buffer.from(block.toString(16).padStart(16, '0'), 'hex');\n                    hfBuffer = Buffer.concat([hfBuffer, hfBlockBuffer]);\n                }\n                if (hf.name === hardfork)\n                    break;\n                if (block !== null) {\n                    prevBlock = block;\n                }\n            }\n        }\n        catch (e_15_1) { e_15 = { error: e_15_1 }; }\n        finally {\n            try {\n                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n            }\n            finally { if (e_15) throw e_15.error; }\n        }\n        var inputBuffer = Buffer.concat([genesis, hfBuffer]);\n        // CRC32 delivers result as signed (negative) 32-bit integer,\n        // convert to hex string\n        var forkhash = (0, ethereumjs_util_1.intToBuffer)((0, crc_32_1.buf)(inputBuffer) >>> 0).toString('hex');\n        return \"0x\".concat(forkhash);\n    };\n    /**\n     * Returns an eth/64 compliant fork hash (EIP-2124)\n     * @param hardfork Hardfork name, optional if HF set\n     */\n    Common.prototype.forkHash = function (hardfork) {\n        hardfork = this._chooseHardfork(hardfork, false);\n        var data = this._getHardfork(hardfork);\n        if (data['block'] === null && data['td'] === undefined) {\n            var msg = 'No fork hash calculation possible for future hardfork';\n            throw new Error(msg);\n        }\n        if (data['forkHash'] !== undefined) {\n            return data['forkHash'];\n        }\n        return this._calcForkHash(hardfork);\n    };\n    /**\n     *\n     * @param forkHash Fork hash as a hex string\n     * @returns Array with hardfork data (name, block, forkHash)\n     */\n    Common.prototype.hardforkForForkHash = function (forkHash) {\n        var resArray = this.hardforks().filter(function (hf) {\n            return hf.forkHash === forkHash;\n        });\n        return resArray.length >= 1 ? resArray[resArray.length - 1] : null;\n    };\n    /**\n     * Returns the Genesis parameters of the current chain\n     * @returns Genesis dictionary\n     */\n    Common.prototype.genesis = function () {\n        return this._chainParams['genesis'];\n    };\n    /**\n     * Returns the Genesis state of the current chain,\n     * all values are provided as hex-prefixed strings.\n     */\n    Common.prototype.genesisState = function () {\n        var e_16, _a;\n        // Use require statements here in favor of import statements\n        // to load json files on demand\n        // (high memory usage by large mainnet.json genesis state file)\n        switch (this.chainName()) {\n            case 'mainnet':\n                return require('./genesisStates/mainnet.json');\n            case 'ropsten':\n                return require('./genesisStates/ropsten.json');\n            case 'rinkeby':\n                return require('./genesisStates/rinkeby.json');\n            case 'kovan':\n                return require('./genesisStates/kovan.json');\n            case 'goerli':\n                return require('./genesisStates/goerli.json');\n            case 'sepolia':\n                return require('./genesisStates/sepolia.json');\n        }\n        // Custom chains with genesis state provided\n        if (this._customChains &&\n            this._customChains.length > 0 &&\n            Array.isArray(this._customChains[0])) {\n            try {\n                for (var _b = __values(this._customChains), _c = _b.next(); !_c.done; _c = _b.next()) {\n                    var chainArrayWithGenesis = _c.value;\n                    if (chainArrayWithGenesis[0].name === this.chainName()) {\n                        return chainArrayWithGenesis[1];\n                    }\n                }\n            }\n            catch (e_16_1) { e_16 = { error: e_16_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n                }\n                finally { if (e_16) throw e_16.error; }\n            }\n        }\n        return {};\n    };\n    /**\n     * Returns the hardforks for current chain\n     * @returns {Array} Array with arrays of hardforks\n     */\n    Common.prototype.hardforks = function () {\n        return this._chainParams['hardforks'];\n    };\n    /**\n     * Returns bootstrap nodes for the current chain\n     * @returns {Dictionary} Dict with bootstrap nodes\n     */\n    Common.prototype.bootstrapNodes = function () {\n        return this._chainParams['bootstrapNodes'];\n    };\n    /**\n     * Returns DNS networks for the current chain\n     * @returns {String[]} Array of DNS ENR urls\n     */\n    Common.prototype.dnsNetworks = function () {\n        return this._chainParams['dnsNetworks'];\n    };\n    /**\n     * Returns the hardfork set\n     * @returns Hardfork name\n     */\n    Common.prototype.hardfork = function () {\n        return this._hardfork;\n    };\n    /**\n     * Returns the Id of current chain\n     * @returns chain Id\n     * @deprecated Please use {@link Common.chainIdBN} for large number support\n     */\n    Common.prototype.chainId = function () {\n        return (0, ethereumjs_util_1.toType)(this.chainIdBN(), ethereumjs_util_1.TypeOutput.Number);\n    };\n    /**\n     * Returns the Id of current chain\n     * @returns chain Id\n     */\n    Common.prototype.chainIdBN = function () {\n        return new ethereumjs_util_1.BN(this._chainParams['chainId']);\n    };\n    /**\n     * Returns the name of current chain\n     * @returns chain name (lower case)\n     */\n    Common.prototype.chainName = function () {\n        return this._chainParams['name'];\n    };\n    /**\n     * Returns the Id of current network\n     * @returns network Id\n     * @deprecated Please use {@link Common.networkIdBN} for large number support\n     */\n    Common.prototype.networkId = function () {\n        return (0, ethereumjs_util_1.toType)(this.networkIdBN(), ethereumjs_util_1.TypeOutput.Number);\n    };\n    /**\n     * Returns the Id of current network\n     * @returns network Id\n     */\n    Common.prototype.networkIdBN = function () {\n        return new ethereumjs_util_1.BN(this._chainParams['networkId']);\n    };\n    /**\n     * Returns the active EIPs\n     * @returns List of EIPs\n     */\n    Common.prototype.eips = function () {\n        return this._eips;\n    };\n    /**\n     * Returns the consensus type of the network\n     * Possible values: \"pow\"|\"poa\"|\"pos\"\n     *\n     * Note: This value can update along a hardfork.\n     */\n    Common.prototype.consensusType = function () {\n        var e_17, _a;\n        var hardfork = this.hardfork();\n        var value;\n        try {\n            for (var HARDFORK_CHANGES_4 = __values(hardforks_1.hardforks), HARDFORK_CHANGES_4_1 = HARDFORK_CHANGES_4.next(); !HARDFORK_CHANGES_4_1.done; HARDFORK_CHANGES_4_1 = HARDFORK_CHANGES_4.next()) {\n                var hfChanges = HARDFORK_CHANGES_4_1.value;\n                if ('consensus' in hfChanges[1]) {\n                    value = hfChanges[1]['consensus']['type'];\n                }\n                if (hfChanges[0] === hardfork)\n                    break;\n            }\n        }\n        catch (e_17_1) { e_17 = { error: e_17_1 }; }\n        finally {\n            try {\n                if (HARDFORK_CHANGES_4_1 && !HARDFORK_CHANGES_4_1.done && (_a = HARDFORK_CHANGES_4.return)) _a.call(HARDFORK_CHANGES_4);\n            }\n            finally { if (e_17) throw e_17.error; }\n        }\n        if (value) {\n            return value;\n        }\n        return this._chainParams['consensus']['type'];\n    };\n    /**\n     * Returns the concrete consensus implementation\n     * algorithm or protocol for the network\n     * e.g. \"ethash\" for \"pow\" consensus type,\n     * \"clique\" for \"poa\" consensus type or\n     * \"casper\" for \"pos\" consensus type.\n     *\n     * Note: This value can update along a hardfork.\n     */\n    Common.prototype.consensusAlgorithm = function () {\n        var e_18, _a;\n        var hardfork = this.hardfork();\n        var value;\n        try {\n            for (var HARDFORK_CHANGES_5 = __values(hardforks_1.hardforks), HARDFORK_CHANGES_5_1 = HARDFORK_CHANGES_5.next(); !HARDFORK_CHANGES_5_1.done; HARDFORK_CHANGES_5_1 = HARDFORK_CHANGES_5.next()) {\n                var hfChanges = HARDFORK_CHANGES_5_1.value;\n                if ('consensus' in hfChanges[1]) {\n                    value = hfChanges[1]['consensus']['algorithm'];\n                }\n                if (hfChanges[0] === hardfork)\n                    break;\n            }\n        }\n        catch (e_18_1) { e_18 = { error: e_18_1 }; }\n        finally {\n            try {\n                if (HARDFORK_CHANGES_5_1 && !HARDFORK_CHANGES_5_1.done && (_a = HARDFORK_CHANGES_5.return)) _a.call(HARDFORK_CHANGES_5);\n            }\n            finally { if (e_18) throw e_18.error; }\n        }\n        if (value) {\n            return value;\n        }\n        return this._chainParams['consensus']['algorithm'];\n    };\n    /**\n     * Returns a dictionary with consensus configuration\n     * parameters based on the consensus algorithm\n     *\n     * Expected returns (parameters must be present in\n     * the respective chain json files):\n     *\n     * ethash: -\n     * clique: period, epoch\n     * aura: -\n     * casper: -\n     *\n     * Note: This value can update along a hardfork.\n     */\n    Common.prototype.consensusConfig = function () {\n        var e_19, _a;\n        var hardfork = this.hardfork();\n        var value;\n        try {\n            for (var HARDFORK_CHANGES_6 = __values(hardforks_1.hardforks), HARDFORK_CHANGES_6_1 = HARDFORK_CHANGES_6.next(); !HARDFORK_CHANGES_6_1.done; HARDFORK_CHANGES_6_1 = HARDFORK_CHANGES_6.next()) {\n                var hfChanges = HARDFORK_CHANGES_6_1.value;\n                if ('consensus' in hfChanges[1]) {\n                    // The config parameter is named after the respective consensus algorithm\n                    value = hfChanges[1]['consensus'][hfChanges[1]['consensus']['algorithm']];\n                }\n                if (hfChanges[0] === hardfork)\n                    break;\n            }\n        }\n        catch (e_19_1) { e_19 = { error: e_19_1 }; }\n        finally {\n            try {\n                if (HARDFORK_CHANGES_6_1 && !HARDFORK_CHANGES_6_1.done && (_a = HARDFORK_CHANGES_6.return)) _a.call(HARDFORK_CHANGES_6);\n            }\n            finally { if (e_19) throw e_19.error; }\n        }\n        if (value) {\n            return value;\n        }\n        var consensusAlgorithm = this.consensusAlgorithm();\n        return this._chainParams['consensus'][consensusAlgorithm];\n    };\n    /**\n     * Returns a deep copy of this {@link Common} instance.\n     */\n    Common.prototype.copy = function () {\n        var copy = Object.assign(Object.create(Object.getPrototypeOf(this)), this);\n        copy.removeAllListeners();\n        return copy;\n    };\n    return Common;\n}(events_1.EventEmitter));\nexports.default = Common;\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.hardforks = void 0;\nexports.hardforks = [\n    ['chainstart', require('./chainstart.json')],\n    ['homestead', require('./homestead.json')],\n    ['dao', require('./dao.json')],\n    ['tangerineWhistle', require('./tangerineWhistle.json')],\n    ['spuriousDragon', require('./spuriousDragon.json')],\n    ['byzantium', require('./byzantium.json')],\n    ['constantinople', require('./constantinople.json')],\n    ['petersburg', require('./petersburg.json')],\n    ['istanbul', require('./istanbul.json')],\n    ['muirGlacier', require('./muirGlacier.json')],\n    ['berlin', require('./berlin.json')],\n    ['london', require('./london.json')],\n    ['shanghai', require('./shanghai.json')],\n    ['arrowGlacier', require('./arrowGlacier.json')],\n    ['mergeForkIdTransition', require('./mergeForkIdTransition.json')],\n    ['merge', require('./merge.json')],\n];\n//# sourceMappingURL=index.js.map","\"use strict\";\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.chains = exports._getInitializedChains = void 0;\nvar mainnet_json_1 = __importDefault(require(\"./mainnet.json\"));\nvar ropsten_json_1 = __importDefault(require(\"./ropsten.json\"));\nvar rinkeby_json_1 = __importDefault(require(\"./rinkeby.json\"));\nvar kovan_json_1 = __importDefault(require(\"./kovan.json\"));\nvar goerli_json_1 = __importDefault(require(\"./goerli.json\"));\nvar sepolia_json_1 = __importDefault(require(\"./sepolia.json\"));\n/**\n * @hidden\n */\nfunction _getInitializedChains(customChains) {\n    var e_1, _a;\n    var names = {\n        '1': 'mainnet',\n        '3': 'ropsten',\n        '4': 'rinkeby',\n        '42': 'kovan',\n        '5': 'goerli',\n        '11155111': 'sepolia',\n    };\n    var chains = {\n        mainnet: mainnet_json_1.default,\n        ropsten: ropsten_json_1.default,\n        rinkeby: rinkeby_json_1.default,\n        kovan: kovan_json_1.default,\n        goerli: goerli_json_1.default,\n        sepolia: sepolia_json_1.default,\n    };\n    if (customChains) {\n        try {\n            for (var customChains_1 = __values(customChains), customChains_1_1 = customChains_1.next(); !customChains_1_1.done; customChains_1_1 = customChains_1.next()) {\n                var chain = customChains_1_1.value;\n                var name_1 = chain.name;\n                names[chain.chainId.toString()] = name_1;\n                chains[name_1] = chain;\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (customChains_1_1 && !customChains_1_1.done && (_a = customChains_1.return)) _a.call(customChains_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n    }\n    chains['names'] = names;\n    return chains;\n}\nexports._getInitializedChains = _getInitializedChains;\n/**\n * @deprecated this constant will be internalized (removed)\n * on next major version update\n */\nexports.chains = _getInitializedChains();\n//# sourceMappingURL=index.js.map"],"sourceRoot":""}