feat: add gas limit configuration

docs/userguides/config.md

@@ -132,6 +132,20 @@ ethereum:
     default_provider: hardhat
 ```
 
+Set the gas limit for a given network:
+
+```yaml
+ethereum:
+  default_network: mainnet-fork
+  gas_limit: max
+```
+
+You may use one of:
+
+- `"auto"` - gas limit is estimated for each transaction
+- `"max"` - the maximum block gas limit is used
+- A number or numeric string, base 10 or 16 (e.g. `1234`, `"1234"`, `0x1234`, `"0x1234"`)
+
 ## Plugins
 
 Set which plugins you want to always use:
@@ -157,4 +171,4 @@ Configure your test accounts:
 test:
   mnemonic: test test test test test test test test test test test junk
   number_of_accounts: 5
-```
+```

docs/userguides/networks.md

@@ -38,6 +38,20 @@ default_ecosystem: <ecosystem-name>
     default_provider: <provider-name>
 ```
 
+You may also configure a specific gas limit for a given network:
+
+```yaml
+<ecosystem-name>:
+  default_network: <network-name>
+  <network-name>:
+    gas_limit: "max"
+```
+
+You may use one of:
+- `"auto"` - gas limit is estimated for each transaction
+- `"max"` - the maximum block gas limit is used
+- A number or numeric string, base 10 or 16 (e.g. `1234`, `"1234"`, `0x1234`, `"0x1234"`)
+
 ## Local Network
 
 The default network in Ape is the local network (keyword `"local"`).

src/ape/api/networks.py

@@ -1,7 +1,7 @@
 from functools import partial
 from pathlib import Path
 from tempfile import mkdtemp
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Literal, Optional, Tuple, Type, Union
 
 from eth_account import Account as EthAccount
 from eth_account._utils.legacy_transactions import (
@@ -607,6 +607,10 @@ def config(self) -> PluginConfig:
     def _network_config(self) -> Dict:
         return self.config.get(self.name, {})
 
+    @cached_property
+    def gas_limit(self) -> Union[Literal["auto", "max"], int]:
+        return self._network_config.get("gas_limit", "auto")
+
     @property
     def chain_id(self) -> int:
         """

src/ape/api/providers.py

@@ -662,8 +662,18 @@ def estimate_gas_cost(self, txn: TransactionAPI, **kwargs) -> int:
 
         Returns:
             int: The estimated cost of gas to execute the transaction
-            reported in the fee-currency's smallest unit, e.g. Wei.
-        """
+            reported in the fee-currency's smallest unit, e.g. Wei. If the
+            provider's network has been configured with a gas limit override, it
+            will be returned. If the gas limit configuration is "max" this will
+            return the block maximum gas limit.
+        """
+        if isinstance(self.network.gas_limit, int):
+            return self.network.gas_limit
+
+        if self.network.gas_limit == "max":
+            block = self.web3.eth.get_block("latest")
+            return block["gasLimit"]
+        # else: Handle "auto" gas limit via estimation
 
         txn_dict = txn.dict()
         try:

src/ape/managers/config.py

@@ -268,12 +268,13 @@ def using_project(
         self.project_manager.path = project_folder
         os.chdir(project_folder)
 
-        self.load(force_reload=True)
-        yield self.project_manager
-
-        self.PROJECT_FOLDER = initial_project_folder
-        self.contracts_folder = initial_contracts_folder
-        self.project_manager.path = initial_project_folder
-
-        if initial_project_folder.is_dir():
-            os.chdir(initial_project_folder)
+        try:
+            self.load(force_reload=True)
+            yield self.project_manager
+        finally:
+            self.PROJECT_FOLDER = initial_project_folder
+            self.contracts_folder = initial_contracts_folder
+            self.project_manager.path = initial_project_folder
+
+            if initial_project_folder.is_dir():
+                os.chdir(initial_project_folder)

src/ape/types/__init__.py

@@ -46,6 +46,15 @@
 """
 
 
+GasLimit = Union[Literal["auto", "max"], int, str]
+"""
+A value you can give to Ape for handling gas-limit calculations.
+``"auto"`` refers to automatically figuring out the gas,
+``"max"`` refers to using the maximum block gas limit,
+and otherwise you can provide a numeric value.
+"""
+
+
 TopicFilter = List[Union[Optional[HexStr], List[Optional[HexStr]]]]
 
 

src/ape_ethereum/ecosystem.py

@@ -1,21 +1,21 @@
 import re
 from enum import IntEnum
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+from typing import Any, Dict, Iterator, List, Literal, Optional, Tuple, Union
 
 from eth_abi import decode, encode
 from eth_abi.exceptions import InsufficientDataBytes
 from eth_typing import HexStr
 from eth_utils import add_0x_prefix, encode_hex, keccak, to_bytes, to_checksum_address
 from ethpm_types.abi import ABIType, ConstructorABI, EventABI, MethodABI
 from hexbytes import HexBytes
-from pydantic import Field
+from pydantic import Field, validator
 
 from ape.api import BlockAPI, EcosystemAPI, PluginConfig, ReceiptAPI, TransactionAPI
 from ape.api.networks import LOCAL_NETWORK_NAME, ProxyInfoAPI
 from ape.contracts.base import ContractCall
 from ape.exceptions import APINotImplementedError, DecodingError, TransactionError
 from ape.logging import logger
-from ape.types import AddressType, ContractLog, RawAddress, TransactionSignature
+from ape.types import AddressType, ContractLog, GasLimit, RawAddress, TransactionSignature
 from ape.utils import (
     DEFAULT_LOCAL_TRANSACTION_ACCEPTANCE_TIMEOUT,
     DEFAULT_TRANSACTION_ACCEPTANCE_TIMEOUT,
@@ -76,6 +76,35 @@ class NetworkConfig(PluginConfig):
     block_time: int = 0
     transaction_acceptance_timeout: int = DEFAULT_TRANSACTION_ACCEPTANCE_TIMEOUT
 
+    gas_limit: GasLimit = "auto"
+    """
+    The gas limit override to use for the network. If set to ``"auto"``, ape will
+    estimate gas limits based on the transaction. If set to ``"max"`` the gas limit
+    will be set to the maximum block gas limit for the network. Otherwise an ``int``
+    can be used to specify an explicit gas limit amount (either base 10 or 16).
+    """
+
+    class Config:
+        smart_union = True
+
+    @validator("gas_limit", pre=True)
+    def validate_gas_limit(cls, value: GasLimit) -> Union[Literal["auto", "max"], int]:
+        if isinstance(value, str):
+            if value.lower() in ("auto", "max"):
+                return value.lower()  # type: ignore
+
+            # Value could be an integer string
+            if value.isdigit():
+                return int(value)
+            # Enforce "0x" prefix on base 16 integer strings
+            elif value.lower().startswith("0x"):
+                return int(value, 16)
+            else:
+                raise ValueError("Invalid gas_limit, must be 'auto', 'max', or a number")
+
+        # Value is an integer literal
+        return value
+
 
 class EthereumConfig(PluginConfig):
     mainnet: NetworkConfig = NetworkConfig(required_confirmations=7, block_time=13)  # type: ignore

src/ape_test/providers.py

@@ -57,6 +57,13 @@ def update_settings(self, new_settings: dict):
         pass
 
     def estimate_gas_cost(self, txn: TransactionAPI, **kwargs) -> int:
+        if isinstance(self.network.gas_limit, int):
+            return self.network.gas_limit
+
+        elif self.network.gas_limit == "max":
+            block = self.web3.eth.get_block("latest")
+            return block["gasLimit"]
+
         block_id = kwargs.pop("block_identifier", None)
         estimate_gas = self.web3.eth.estimate_gas
 

tests/conftest.py

@@ -70,6 +70,7 @@ def project_folder(config):
 
 @pytest.fixture(scope="session")
 def project(config):
+    config.PROJECT_FOLDER.mkdir(parents=True, exist_ok=True)
     yield ape.Project(config.PROJECT_FOLDER)
 
 

tests/functional/test_config.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict
+from typing import Dict, Literal, Union
 
 import pytest
 
@@ -54,6 +54,62 @@ def test_ethereum_network_configs(config, temp_config):
         assert actual.rinkeby.block_time == 15
 
 
+def test_network_gas_limit_default(config):
+    eth_config = config.get_config("ethereum")
+
+    assert eth_config.rinkeby.gas_limit == "auto"
+    assert eth_config.local.gas_limit == "auto"
+
+
+def _rinkeby_with_gas_limit(gas_limit: Union[Literal["auto", "max"], int]) -> dict:
+    return {
+        "ethereum": {
+            "rinkeby": {
+                "default_provider": "test",
+                "gas_limit": gas_limit,
+            }
+        }
+    }
+
+
+@pytest.mark.parametrize("gas_limit", ("auto", "max"))
+def test_network_gas_limit_string_config(gas_limit, config, temp_config):
+    eth_config = _rinkeby_with_gas_limit(gas_limit)
+
+    with temp_config(eth_config):
+        actual = config.get_config("ethereum")
+
+        assert actual.rinkeby.gas_limit == gas_limit
+
+        # Local configuration is unaffected
+        assert actual.local.gas_limit == "auto"
+
+
+@pytest.mark.parametrize("gas_limit", (1234, "1234", 0x4D2, "0x4D2"))
+def test_network_gas_limit_numeric_config(gas_limit, config, temp_config):
+    eth_config = _rinkeby_with_gas_limit(gas_limit)
+
+    with temp_config(eth_config):
+        actual = config.get_config("ethereum")
+
+        assert actual.rinkeby.gas_limit == 1234
+
+        # Local configuration is unaffected
+        assert actual.local.gas_limit == "auto"
+
+
+def test_network_gas_limit_invalid_numeric_string(config, temp_config):
+    """
+    Test that using hex strings for a network's gas_limit config must be
+    prefixed with '0x'
+    """
+    eth_config = _rinkeby_with_gas_limit("4D2")
+
+    with pytest.raises(ValueError, match="Invalid gas_limit, must be 'auto', 'max', or a number"):
+        with temp_config(eth_config):
+            pass
+
+
 def test_dependencies(dependency_config, config):
     assert len(config.dependencies) == 1
     assert config.dependencies[0].name == "testdependency"

tests/functional/test_contract_container.py

@@ -22,10 +22,7 @@ def test_deploy_and_publish_local_network(owner, contract_container):
         contract_container.deploy(sender=owner, publish=True)
 
 
-def test_deploy_and_publish_live_network_no_explorer(
-    owner, project, contract_container, dummy_live_network
-):
-    _ = project  # Ensure active project for `track_deployment` to work
+def test_deploy_and_publish_live_network_no_explorer(owner, contract_container, dummy_live_network):
     dummy_live_network.__dict__["explorer"] = None
     expected_message = "Unable to publish contract - no explorer plugin installed."
     with pytest.raises(NetworkError, match=expected_message):

tests/functional/test_networks.py

@@ -235,3 +235,11 @@ def test_ecosystems_when_default_provider_not_exists(temp_config, caplog, networ
         f"Failed setting default provider: "
         f"Provider '{bad_provider}' not found in network 'kovan'."
     )
+
+
+def test_gas_limits(ethereum):
+    """
+    Test the default gas limit configurations for local and live networks.
+    """
+    assert ethereum.rinkeby.gas_limit == "auto"
+    assert ethereum.local.gas_limit == "auto"

tests/functional/test_provider.py

@@ -1,3 +1,5 @@
+from unittest import mock
+
 import pytest
 from eth_typing import HexStr
 
@@ -16,6 +18,15 @@ def test_get_block(eth_tester_provider, block_id):
     assert latest_block.gas_used == 0
 
 
+def test_estimate_gas_with_max_value_from_block(mocker, eth_tester_provider):
+    mock_txn = mocker.patch("ape.api.networks.NetworkAPI.gas_limit", new_callable=mock.PropertyMock)
+    mock_txn.return_value = "max"
+    gas_cost = eth_tester_provider.estimate_gas_cost(mock_txn)
+    latest_block = eth_tester_provider.get_block("latest")
+
+    assert gas_cost == latest_block.gas_limit
+
+
 def test_chain_id(eth_tester_provider):
     chain_id = eth_tester_provider.chain_id
     assert chain_id == CHAIN_ID