@elizaos/autonomous 2.0.0-alpha.71 → 2.0.0-alpha.72

package/test/contracts/lib/openzeppelin-contracts/docs/modules/ROOT/pages/utilities.adoc

@@ -1,190 +0,0 @@
-= Utilities
-
-The OpenZeppelin Contracts provide a ton of useful utilities that you can use in your project. Here are some of the more popular ones.
-
-[[cryptography]]
-== Cryptography
-
-=== Checking Signatures On-Chain
-
-xref:api:utils.adoc#ECDSA[`ECDSA`] provides functions for recovering and managing Ethereum account ECDSA signatures. These are often generated via https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#sign[`web3.eth.sign`], and are a 65 byte array (of type `bytes` in Solidity) arranged the following way: `[[v (1)], [r (32)], [s (32)]]`.
-
-The data signer can be recovered with xref:api:utils.adoc#ECDSA-recover-bytes32-bytes-[`ECDSA.recover`], and its address compared to verify the signature. Most wallets will hash the data to sign and add the prefix '\x19Ethereum Signed Message:\n', so when attempting to recover the signer of an Ethereum signed message hash, you'll want to use xref:api:utils.adoc#ECDSA-toEthSignedMessageHash-bytes32-[`toEthSignedMessageHash`].
-
-[source,solidity]
-----
-using ECDSA for bytes32;
-
-function _verify(bytes32 data, bytes memory signature, address account) internal pure returns (bool) {
-    return data
-        .toEthSignedMessageHash()
-        .recover(signature) == account;
-}
-----
-
-WARNING: Getting signature verification right is not trivial: make sure you fully read and understand xref:api:utils.adoc#ECDSA[`ECDSA`]'s documentation.
-
-=== Verifying Merkle Proofs
-
-xref:api:utils.adoc#MerkleProof[`MerkleProof`] provides:
-
-* xref:api:utils.adoc#MerkleProof-verify-bytes32---bytes32-bytes32-[`verify`] - can prove that some value is part of a https://en.wikipedia.org/wiki/Merkle_tree[Merkle tree].
-
-* xref:api:utils.adoc#MerkleProof-multiProofVerify-bytes32-bytes32---bytes32---bool---[`multiProofVerify`] - can prove multiple values are part of a Merkle tree.
-
-[[introspection]]
-== Introspection
-
-In Solidity, it's frequently helpful to know whether or not a contract supports an interface you'd like to use. ERC165 is a standard that helps do runtime interface detection. Contracts provide helpers both for implementing ERC165 in your contracts and querying other contracts:
-
-* xref:api:utils.adoc#IERC165[`IERC165`] — this is the ERC165 interface that defines xref:api:utils.adoc#IERC165-supportsInterface-bytes4-[`supportsInterface`]. When implementing ERC165, you'll conform to this interface.
-* xref:api:utils.adoc#ERC165[`ERC165`] — inherit this contract if you'd like to support interface detection using a lookup table in contract storage. You can register interfaces using xref:api:utils.adoc#ERC165-_registerInterface-bytes4-[`_registerInterface(bytes4)`]: check out example usage as part of the ERC721 implementation.
-* xref:api:utils.adoc#ERC165Checker[`ERC165Checker`] — ERC165Checker simplifies the process of checking whether or not a contract supports an interface you care about.
-* include with `using ERC165Checker for address;`
-* xref:api:utils.adoc#ERC165Checker-_supportsInterface-address-bytes4-[`myAddress._supportsInterface(bytes4)`]
-* xref:api:utils.adoc#ERC165Checker-_supportsAllInterfaces-address-bytes4---[`myAddress._supportsAllInterfaces(bytes4[\])`]
-
-[source,solidity]
-----
-contract MyContract {
-    using ERC165Checker for address;
-
-    bytes4 private InterfaceId_ERC721 = 0x80ac58cd;
-
-    /**
-     * @dev transfer an ERC721 token from this contract to someone else
-     */
-    function transferERC721(
-        address token,
-        address to,
-        uint256 tokenId
-    )
-        public
-    {
-        require(token.supportsInterface(InterfaceId_ERC721), "IS_NOT_721_TOKEN");
-        IERC721(token).transferFrom(address(this), to, tokenId);
-    }
-}
-----
-
-[[math]]
-== Math
-
-The most popular math related library OpenZeppelin Contracts provides is xref:api:utils.adoc#SafeMath[`SafeMath`], which provides mathematical functions that protect your contract from overflows and underflows.
-
-Include the contract with `using SafeMath for uint256;` and then call the functions:
-
-* `myNumber.add(otherNumber)`
-* `myNumber.sub(otherNumber)`
-* `myNumber.div(otherNumber)`
-* `myNumber.mul(otherNumber)`
-* `myNumber.mod(otherNumber)`
-
-Easy!
-
-[[payment]]
-== Payment
-
-Want to split some payments between multiple people? Maybe you have an app that sends 30% of art purchases to the original creator and 70% of the profits to the current owner; you can build that with xref:api:finance.adoc#PaymentSplitter[`PaymentSplitter`]!
-
-In Solidity, there are some security concerns with blindly sending money to accounts, since it allows them to execute arbitrary code. You can read up on these security concerns in the https://consensys.github.io/smart-contract-best-practices/[Ethereum Smart Contract Best Practices] website. One of the ways to fix reentrancy and stalling problems is, instead of immediately sending Ether to accounts that need it, you can use xref:api:security.adoc#PullPayment[`PullPayment`], which offers an xref:api:security.adoc#PullPayment-_asyncTransfer-address-uint256-[`_asyncTransfer`] function for sending money to something and requesting that they xref:api:security.adoc#PullPayment-withdrawPayments-address-payable-[`withdrawPayments()`] it later.
-
-If you want to Escrow some funds, check out xref:api:utils.adoc#Escrow[`Escrow`] and xref:api:utils.adoc#ConditionalEscrow[`ConditionalEscrow`] for governing the release of some escrowed Ether.
-
-[[collections]]
-== Collections
-
-If you need support for more powerful collections than Solidity's native arrays and mappings, take a look at xref:api:utils.adoc#EnumerableSet[`EnumerableSet`] and xref:api:utils.adoc#EnumerableMap[`EnumerableMap`]. They are similar to mappings in that they store and remove elements in constant time and don't allow for repeated entries, but they also support _enumeration_, which means you can easily query all stored entries both on and off-chain.
-
-[[misc]]
-== Misc
-
-Want to check if an address is a contract? Use xref:api:utils.adoc#Address[`Address`] and xref:api:utils.adoc#Address-isContract-address-[`Address.isContract()`].
-
-Want to keep track of some numbers that increment by 1 every time you want another one? Check out xref:api:utils.adoc#Counters[`Counters`]. This is useful for lots of things, like creating incremental identifiers, as shown on the xref:erc721.adoc[ERC721 guide].
-
-=== Base64
-
-xref:api:utils.adoc#Base64[`Base64`] util allows you to transform `bytes32` data into its Base64 `string` representation. 
-
-This is especially useful for building URL-safe tokenURIs for both xref:api:token/ERC721.adoc#IERC721Metadata-tokenURI-uint256-[`ERC721`] or xref:api:token/ERC1155.adoc#IERC1155MetadataURI-uri-uint256-[`ERC1155`]. This library provides a clever way to serve URL-safe https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URIs/[Data URI] compliant strings to serve on-chain data structures.
-
-Here is an example to send JSON Metadata through a Base64 Data URI using an ERC721:
-
-[source, solidity]
-----
-// contracts/My721Token.sol
-// SPDX-License-Identifier: MIT
-
-import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-import "@openzeppelin/contracts/utils/Strings.sol";
-import "@openzeppelin/contracts/utils/Base64.sol";
-
-contract My721Token is ERC721 {
-    using Strings for uint256;
-
-    constructor() ERC721("My721Token", "MTK") {}
-    
-    ...
-
-    function tokenURI(uint256 tokenId)
-        public
-        pure
-        override
-        returns (string memory)
-    {
-        bytes memory dataURI = abi.encodePacked(
-            '{',
-                '"name": "My721Token #', tokenId.toString(), '"',
-                // Replace with extra ERC721 Metadata properties
-            '}'
-        );
-
-        return string(
-            abi.encodePacked(
-                "data:application/json;base64,", 
-                Base64.encode(dataURI)
-            )
-        );
-    }
-}
-----
-
-=== Multicall
-
-The `Multicall` abstract contract comes with a `multicall` function that bundles together multiple calls in a single external call. With it, external accounts may perform atomic operations comprising several function calls. This is not only useful for EOAs to make multiple calls in a single transaction, it's also a way to revert a previous call if a later one fails.
-
-Consider this dummy contract:
-
-[source,solidity]
-----
-// contracts/Box.sol
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/utils/Multicall.sol";
-
-contract Box is Multicall {
-    function foo() public {
-        ...
-    }
-
-    function bar() public {
-        ...
-    }
-}
-----
-
-This is how to call the `multicall` function using Truffle, allowing `foo` and `bar` to be called in a single transaction:
-[source,javascript]
-----
-// scripts/foobar.js
-
-const Box = artifacts.require('Box');
-const instance = await Box.new();
-
-await instance.multicall([
-    instance.contract.methods.foo().encodeABI(),
-    instance.contract.methods.bar().encodeABI()
-]);
-----

package/test/contracts/lib/openzeppelin-contracts/docs/templates/contract.hbs

@@ -1,85 +0,0 @@
-{{#each items}}
-:{{name}}: pass:normal[xref:#{{anchor}}[`++{{name}}++`]]
-{{/each}}
-
-[.contract]
-[[{{anchor}}]]
-=== `++{{name}}++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v{{oz-version}}/{{__item_context.file.absolutePath}}[{github-icon},role=heading-link]
-
-[.hljs-theme-light.nopadding]
-```solidity
-import "@openzeppelin/{{__item_context.file.absolutePath}}";
-```
-
-{{{natspec.dev}}}
-
-{{#if modifiers}}
-[.contract-index]
-.Modifiers
---
-{{#each modifiers}}
-* {xref-{{anchor~}} }[`++{{name}}({{names params}})++`]
-{{/each}}
---
-{{/if}}
-
-{{#if has-functions}}
-[.contract-index]
-.Functions
---
-{{#each inherited-functions}}
-{{#unless @first}}
-[.contract-subindex-inherited]
-.{{contract.name}}
-{{/unless}}
-{{#each functions}}
-* {xref-{{anchor~}} }[`++{{name}}({{names params}})++`]
-{{/each}}
-
-{{/each}}
---
-{{/if}}
-
-{{#if has-events}}
-[.contract-index]
-.Events
---
-{{#each inheritance}}
-{{#unless @first}}
-[.contract-subindex-inherited]
-.{{name}}
-{{/unless}}
-{{#each events}}
-* {xref-{{anchor~}} }[`++{{name}}({{names params}})++`]
-{{/each}}
-
-{{/each}}
---
-{{/if}}
-
-{{#each modifiers}}
-[.contract-item]
-[[{{anchor}}]]
-==== `[.contract-item-name]#++{{name}}++#++({{typed-params params}})++` [.item-kind]#modifier#
-
-{{{natspec.dev}}}
-
-{{/each}}
-
-{{#each functions}}
-[.contract-item]
-[[{{anchor}}]]
-==== `[.contract-item-name]#++{{name}}++#++({{typed-params params}}){{#if returns}} → {{typed-params returns}}{{/if}}++` [.item-kind]#{{visibility}}#
-
-{{{natspec.dev}}}
-
-{{/each}}
-
-{{#each events}}
-[.contract-item]
-[[{{anchor}}]]
-==== `[.contract-item-name]#++{{name}}++#++({{typed-params params}})++` [.item-kind]#event#
-
-{{{natspec.dev}}}
-
-{{/each}}

package/test/contracts/lib/openzeppelin-contracts/docs/templates/helpers.js

@@ -1,46 +0,0 @@
-const { version } = require('../../package.json');
-
-module.exports['oz-version'] = () => version;
-
-module.exports['readme-path'] = opts => {
-  return 'contracts/' + opts.data.root.id.replace(/\.adoc$/, '') + '/README.adoc';
-};
-
-module.exports.names = params => params.map(p => p.name).join(', ');
-
-module.exports['typed-params'] = params => {
-  return params?.map(p => `${p.type}${p.indexed ? ' indexed' : ''}${p.name ? ' ' + p.name : ''}`).join(', ');
-};
-
-const slug = (module.exports.slug = str => {
-  if (str === undefined) {
-    throw new Error('Missing argument');
-  }
-  return str.replace(/\W/g, '-');
-});
-
-const linksCache = new WeakMap();
-
-function getAllLinks(items) {
-  if (linksCache.has(items)) {
-    return linksCache.get(items);
-  }
-  const res = {};
-  linksCache.set(items, res);
-  for (const item of items) {
-    res[`xref-${item.anchor}`] = `xref:${item.__item_context.page}#${item.anchor}`;
-    res[slug(item.fullName)] = `pass:normal[xref:${item.__item_context.page}#${item.anchor}[\`${item.fullName}\`]]`;
-  }
-  return res;
-}
-
-module.exports['with-prelude'] = opts => {
-  const links = getAllLinks(opts.data.site.items);
-  const contents = opts.fn();
-  const neededLinks = contents
-    .match(/\{[-._a-z0-9]+\}/gi)
-    .map(m => m.replace(/^\{(.+)\}$/, '$1'))
-    .filter(k => k in links);
-  const prelude = neededLinks.map(k => `:${k}: ${links[k]}`).join('\n');
-  return prelude + '\n' + contents;
-};

package/test/contracts/lib/openzeppelin-contracts/docs/templates/page.hbs

@@ -1,4 +0,0 @@
-:github-icon: pass:[<svg class="icon"><use href="#github-icon"/></svg>]
-{{#with-prelude}}
-{{readme (readme-path)}}
-{{/with-prelude}}

package/test/contracts/lib/openzeppelin-contracts/docs/templates/properties.js

@@ -1,45 +0,0 @@
-const { isNodeType } = require('solidity-ast/utils');
-const { slug } = require('./helpers');
-
-module.exports.anchor = function anchor({ item, contract }) {
-  let res = '';
-  if (contract) {
-    res += contract.name + '-';
-  }
-  res += item.name;
-  if ('parameters' in item) {
-    const signature = item.parameters.parameters.map(v => v.typeName.typeDescriptions.typeString).join(',');
-    res += slug('(' + signature + ')');
-  }
-  if (isNodeType('VariableDeclaration', item)) {
-    res += '-' + slug(item.typeName.typeDescriptions.typeString);
-  }
-  return res;
-};
-
-module.exports.inheritance = function ({ item, build }) {
-  if (!isNodeType('ContractDefinition', item)) {
-    throw new Error('used inherited-items on non-contract');
-  }
-
-  return item.linearizedBaseContracts
-    .map(id => build.deref('ContractDefinition', id))
-    .filter((c, i) => c.name !== 'Context' || i === 0);
-};
-
-module.exports['has-functions'] = function ({ item }) {
-  return item.inheritance.some(c => c.functions.length > 0);
-};
-
-module.exports['has-events'] = function ({ item }) {
-  return item.inheritance.some(c => c.events.length > 0);
-};
-
-module.exports['inherited-functions'] = function ({ item }) {
-  const { inheritance } = item;
-  const baseFunctions = new Set(inheritance.flatMap(c => c.functions.flatMap(f => f.baseFunctions ?? [])));
-  return inheritance.map((contract, i) => ({
-    contract,
-    functions: contract.functions.filter(f => !baseFunctions.has(f.id) && (f.name !== 'constructor' || i === 0)),
-  }));
-};

package/test/contracts/lib/openzeppelin-contracts/foundry.toml

@@ -1,3 +0,0 @@
-[fuzz]
-runs = 10000
-max_test_rejects = 150000

package/test/contracts/lib/openzeppelin-contracts/hardhat/env-artifacts.js

@@ -1,24 +0,0 @@
-const { HardhatError } = require('hardhat/internal/core/errors');
-
-// Modifies `artifacts.require(X)` so that instead of X it loads the XUpgradeable contract.
-// This allows us to run the same test suite on both the original and the transpiled and renamed Upgradeable contracts.
-
-extendEnvironment(env => {
-  const artifactsRequire = env.artifacts.require;
-
-  env.artifacts.require = name => {
-    for (const suffix of ['UpgradeableWithInit', 'Upgradeable', '']) {
-      try {
-        return artifactsRequire(name + suffix);
-      } catch (e) {
-        // HH700: Artifact not found - from https://hardhat.org/hardhat-runner/docs/errors#HH700
-        if (HardhatError.isHardhatError(e) && e.number === 700 && suffix !== '') {
-          continue;
-        } else {
-          throw e;
-        }
-      }
-    }
-    throw new Error('Unreachable');
-  };
-});

package/test/contracts/lib/openzeppelin-contracts/hardhat/env-contract.js

@@ -1,10 +0,0 @@
-extendEnvironment(env => {
-  const { contract } = env;
-
-  env.contract = function (name, body) {
-    // remove the default account from the accounts list used in tests, in order
-    // to protect tests against accidentally passing due to the contract
-    // deployer being used subsequently as function caller
-    contract(name, accounts => body(accounts.slice(1)));
-  };
-});

package/test/contracts/lib/openzeppelin-contracts/hardhat/ignore-unreachable-warnings.js

@@ -1,45 +0,0 @@
-// Warnings about unreachable code are emitted with a source location that corresponds to the unreachable code.
-// We have some testing contracts that purposely cause unreachable code, but said code is in the library contracts, and
-// with hardhat-ignore-warnings we are not able to selectively ignore them without potentially ignoring relevant
-// warnings that we don't want to miss.
-// Thus, we need to handle these warnings separately. We force Hardhat to compile them in a separate compilation job and
-// then ignore the warnings about unreachable code that come from that compilation job.
-
-const { task } = require('hardhat/config');
-const {
-  TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOB_FOR_FILE,
-  TASK_COMPILE_SOLIDITY_COMPILE,
-} = require('hardhat/builtin-tasks/task-names');
-
-const marker = Symbol('unreachable');
-const markedCache = new WeakMap();
-
-task(TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOB_FOR_FILE, async (params, _, runSuper) => {
-  const job = await runSuper(params);
-  // If the file is in the unreachable directory, we make a copy of the config and mark it, which will cause it to get
-  // compiled separately (along with the other marked files).
-  if (params.file.sourceName.startsWith('contracts/mocks/') && /\bunreachable\b/.test(params.file.sourceName)) {
-    const originalConfig = job.solidityConfig;
-    let markedConfig = markedCache.get(originalConfig);
-    if (markedConfig === undefined) {
-      markedConfig = { ...originalConfig, [marker]: true };
-      markedCache.set(originalConfig, markedConfig);
-    }
-    job.solidityConfig = markedConfig;
-  }
-  return job;
-});
-
-const W_UNREACHABLE_CODE = '5740';
-
-task(TASK_COMPILE_SOLIDITY_COMPILE, async (params, _, runSuper) => {
-  const marked = params.compilationJob.solidityConfig[marker];
-  const result = await runSuper(params);
-  if (marked) {
-    result.output = {
-      ...result.output,
-      errors: result.output.errors?.filter(e => e.severity !== 'warning' || e.errorCode !== W_UNREACHABLE_CODE),
-    };
-  }
-  return result;
-});

package/test/contracts/lib/openzeppelin-contracts/hardhat/skip-foundry-tests.js

@@ -1,6 +0,0 @@
-const { subtask } = require('hardhat/config');
-const { TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS } = require('hardhat/builtin-tasks/task-names');
-
-subtask(TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS).setAction(async (_, __, runSuper) =>
-  (await runSuper()).filter(path => !path.endsWith('.t.sol')),
-);

package/test/contracts/lib/openzeppelin-contracts/hardhat/task-test-get-files.js

@@ -1,25 +0,0 @@
-const { internalTask } = require('hardhat/config');
-const { TASK_TEST_GET_TEST_FILES } = require('hardhat/builtin-tasks/task-names');
-
-// Modifies `hardhat test` to skip the proxy tests after proxies are removed by the transpiler for upgradeability.
-
-internalTask(TASK_TEST_GET_TEST_FILES).setAction(async (args, hre, runSuper) => {
-  const path = require('path');
-  const { promises: fs } = require('fs');
-
-  const hasProxies = await fs
-    .access(path.join(hre.config.paths.sources, 'proxy/Proxy.sol'))
-    .then(() => true)
-    .catch(() => false);
-
-  const ignoredIfProxy = [
-    'proxy/beacon/BeaconProxy.test.js',
-    'proxy/beacon/UpgradeableBeacon.test.js',
-    'proxy/ERC1967/ERC1967Proxy.test.js',
-    'proxy/transparent/ProxyAdmin.test.js',
-    'proxy/transparent/TransparentUpgradeableProxy.test.js',
-    'proxy/utils/UUPSUpgradeable.test.js',
-  ].map(p => path.join(hre.config.paths.tests, p));
-
-  return (await runSuper(args)).filter(file => hasProxies || !ignoredIfProxy.includes(file));
-});

package/test/contracts/lib/openzeppelin-contracts/hardhat.config.js

@@ -1,118 +0,0 @@
-/// ENVVAR
-// - CI:                output gas report to file instead of stdout
-// - COVERAGE:          enable coverage report
-// - ENABLE_GAS_REPORT: enable gas report
-// - COMPILE_MODE:      production modes enables optimizations (default: development)
-// - COMPILE_VERSION:   compiler version (default: 0.8.9)
-// - COINMARKETCAP:     coinmarkercat api key for USD value in gas report
-
-const fs = require('fs');
-const path = require('path');
-const argv = require('yargs/yargs')()
-  .env('')
-  .options({
-    coverage: {
-      type: 'boolean',
-      default: false,
-    },
-    gas: {
-      alias: 'enableGasReport',
-      type: 'boolean',
-      default: false,
-    },
-    gasReport: {
-      alias: 'enableGasReportPath',
-      type: 'string',
-      implies: 'gas',
-      default: undefined,
-    },
-    mode: {
-      alias: 'compileMode',
-      type: 'string',
-      choices: ['production', 'development'],
-      default: 'development',
-    },
-    ir: {
-      alias: 'enableIR',
-      type: 'boolean',
-      default: false,
-    },
-    compiler: {
-      alias: 'compileVersion',
-      type: 'string',
-      default: '0.8.13',
-    },
-    coinmarketcap: {
-      alias: 'coinmarketcapApiKey',
-      type: 'string',
-    },
-  }).argv;
-
-require('@nomiclabs/hardhat-truffle5');
-require('hardhat-ignore-warnings');
-require('hardhat-exposed');
-
-require('solidity-docgen');
-
-for (const f of fs.readdirSync(path.join(__dirname, 'hardhat'))) {
-  require(path.join(__dirname, 'hardhat', f));
-}
-
-const withOptimizations = argv.gas || argv.compileMode === 'production';
-
-/**
- * @type import('hardhat/config').HardhatUserConfig
- */
-module.exports = {
-  solidity: {
-    version: argv.compiler,
-    settings: {
-      optimizer: {
-        enabled: withOptimizations,
-        runs: 200,
-      },
-      viaIR: withOptimizations && argv.ir,
-      outputSelection: { '*': { '*': ['storageLayout'] } },
-    },
-  },
-  warnings: {
-    'contracts-exposed/**/*': {
-      'code-size': 'off',
-    },
-    '*': {
-      'code-size': withOptimizations,
-      'unused-param': !argv.coverage, // coverage causes unused-param warnings
-      default: 'error',
-    },
-  },
-  networks: {
-    hardhat: {
-      blockGasLimit: 10000000,
-      allowUnlimitedContractSize: !withOptimizations,
-    },
-  },
-  exposed: {
-    initializers: true,
-    exclude: [
-      'vendor/**/*',
-      // Exclude Timers from hardhat-exposed because its overloaded functions are not transformed correctly
-      'utils/Timers{,Upgradeable}.sol',
-    ],
-  },
-  docgen: require('./docs/config'),
-};
-
-if (argv.gas) {
-  require('hardhat-gas-reporter');
-  module.exports.gasReporter = {
-    showMethodSig: true,
-    currency: 'USD',
-    outputFile: argv.gasReport,
-    coinmarketcap: argv.coinmarketcap,
-  };
-}
-
-if (argv.coverage) {
-  require('solidity-coverage');
-  module.exports.networks.hardhat.initialBaseFeePerGas = 0;
-}