fix: all network related fixes [APE-1436]

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.2.0
+    rev: v4.4.0
     hooks:
     -   id: check-yaml
 
@@ -10,24 +10,24 @@ repos:
       - id: isort
 
 -   repo: https://github.com/psf/black
-    rev: 23.3.0
+    rev: 23.9.1
     hooks:
       - id: black
         name: black
 
 -   repo: https://github.com/pycqa/flake8
-    rev: 6.0.0
+    rev: 6.1.0
     hooks:
     -   id: flake8
 
 -   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.991
+    rev: v1.5.1
     hooks:
     -   id: mypy
         additional_dependencies: [types-setuptools, pydantic]
 
 -   repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.14
+    rev: 0.7.17
     hooks:
     -   id: mdformat
         additional_dependencies: [mdformat-gfm, mdformat-frontmatter]

ape_base/ecosystem.py

@@ -1,39 +1,40 @@
-from typing import Optional, Type, Union, cast
+from typing import Dict, Optional, Type, cast
 
 from ape.api import TransactionAPI
 from ape.api.config import PluginConfig
 from ape.api.networks import LOCAL_NETWORK_NAME
-from ape.exceptions import ApeException
 from ape.types import TransactionSignature
+from ape.utils import DEFAULT_LOCAL_TRANSACTION_ACCEPTANCE_TIMEOUT
 from ape_ethereum.ecosystem import Ethereum, NetworkConfig
 from ape_ethereum.transactions import DynamicFeeTransaction, StaticFeeTransaction, TransactionType
-from eth_typing import HexStr
-from eth_utils import add_0x_prefix
 
 NETWORKS = {
     # chain_id, network_id
     "mainnet": (8453, 8453),
     "goerli": (84531, 84531),
 }
-
-
-class ApeBaseError(ApeException):
-    """
-    Raised in the ape-base plugin.
-    """
+_SECOND_STATIC_TYPE = 126
 
 
 def _create_network_config(
     required_confirmations: int = 1, block_time: int = 2, **kwargs
 ) -> NetworkConfig:
     return NetworkConfig(
-        required_confirmations=required_confirmations, block_time=block_time, **kwargs
+        block_time=block_time,
+        default_transaction_type=TransactionType.STATIC,
+        required_confirmations=required_confirmations,
+        **kwargs,
     )
 
 
-def _create_local_config(default_provider: Optional[str] = None) -> NetworkConfig:
+def _create_local_config(default_provider: Optional[str] = None, **kwargs) -> NetworkConfig:
     return _create_network_config(
-        required_confirmations=0, block_time=0, default_provider=default_provider
+        block_time=0,
+        default_provider=default_provider,
+        gas_limit="max",
+        required_confirmations=0,
+        transaction_acceptance_timeout=DEFAULT_LOCAL_TRANSACTION_ACCEPTANCE_TIMEOUT,
+        **kwargs,
     )
 
 
@@ -55,14 +56,35 @@ def create_transaction(self, **kwargs) -> TransactionAPI:
         """
         Returns a transaction using the given constructor kwargs.
         Overridden because does not support
+
         **kwargs: Kwargs for the transaction class.
+
         Returns:
             :class:`~ape.api.transactions.TransactionAPI`
         """
 
-        transaction_type = _get_transaction_type(kwargs.get("type"))
-        kwargs["type"] = transaction_type.value
-        txn_class = _get_transaction_cls(transaction_type)
+        transaction_types: Dict[int, Type[TransactionAPI]] = {
+            TransactionType.STATIC.value: StaticFeeTransaction,
+            TransactionType.DYNAMIC.value: DynamicFeeTransaction,
+            _SECOND_STATIC_TYPE: StaticFeeTransaction,
+        }
+
+        if "type" in kwargs:
+            if kwargs["type"] is None:
+                # The Default is pre-EIP-1559.
+                version = self.default_transaction_type.value
+            elif not isinstance(kwargs["type"], int):
+                version = self.conversion_manager.convert(kwargs["type"], int)
+            else:
+                version = kwargs["type"]
+
+        elif "gas_price" in kwargs:
+            version = TransactionType.STATIC.value
+        else:
+            version = self.default_transaction_type.value
+
+        kwargs["type"] = version
+        txn_class = transaction_types[version]
 
         if "required_confirmations" not in kwargs or kwargs["required_confirmations"] is None:
             # Attempt to use default required-confirmations from `ape-config.yaml`.
@@ -76,8 +98,11 @@ def create_transaction(self, **kwargs) -> TransactionAPI:
         if isinstance(kwargs.get("chainId"), str):
             kwargs["chainId"] = int(kwargs["chainId"], 16)
 
-        if "hash" in kwargs:
-            kwargs["data"] = kwargs.pop("hash")
+        elif "chainId" not in kwargs and self.network_manager.active_provider is not None:
+            kwargs["chainId"] = self.provider.chain_id
+
+        if "input" in kwargs:
+            kwargs["data"] = kwargs.pop("input")
 
         if all(field in kwargs for field in ("v", "r", "s")):
             kwargs["signature"] = TransactionSignature(
@@ -86,32 +111,14 @@ def create_transaction(self, **kwargs) -> TransactionAPI:
                 s=bytes(kwargs["s"]),
             )
 
-        return txn_class.parse_obj(kwargs)
-
-
-def _get_transaction_type(_type: Optional[Union[int, str, bytes]]) -> TransactionType:
-    if not _type or _type == 126:
-        return TransactionType.STATIC
-
-    if _type is None:
-        _type = TransactionType.STATIC.value
-    elif isinstance(_type, int):
-        _type = f"0{_type}"
-    elif isinstance(_type, bytes):
-        _type = _type.hex()
-
-    suffix = _type.replace("0x", "")
-    if len(suffix) == 1:
-        _type = f"{_type.rstrip(suffix)}0{suffix}"
-    return TransactionType(int(add_0x_prefix(HexStr(_type)), 16))
+        if "max_priority_fee_per_gas" in kwargs:
+            kwargs["max_priority_fee"] = kwargs.pop("max_priority_fee_per_gas")
+        if "max_fee_per_gas" in kwargs:
+            kwargs["max_fee"] = kwargs.pop("max_fee_per_gas")
 
+        kwargs["gas"] = kwargs.pop("gas_limit", kwargs.get("gas"))
 
-def _get_transaction_cls(transaction_type: TransactionType) -> Type[TransactionAPI]:
-    transaction_types = {
-        TransactionType.STATIC: StaticFeeTransaction,
-        TransactionType.DYNAMIC: DynamicFeeTransaction,
-    }
-    if transaction_type not in transaction_types:
-        raise ApeBaseError(f"Transaction type '{transaction_type}' not supported.")
+        if "value" in kwargs and not isinstance(kwargs["value"], int):
+            kwargs["value"] = self.conversion_manager.convert(kwargs["value"], int)
 
-    return transaction_types[transaction_type]
+        return txn_class(**kwargs)

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=51.1.1", "wheel", "setuptools_scm[toml]>=5.0"]
+requires = ["setuptools>=51.1.1", "wheel", "setuptools_scm[toml]>=5.0,<8"]
 
 [tool.mypy]
 exclude = "build/"

setup.py

@@ -10,12 +10,12 @@
         "hypothesis>=6.2.0,<7.0",  # Strategy-based fuzzer
     ],
     "lint": [
-        "black>=23.3.0,<24",  # Auto-formatter and linter
-        "mypy>=0.991,<1",  # Static type analyzer
+        "black>=23.9.1,<24",  # Auto-formatter and linter
+        "mypy>=1.5.1,<2",  # Static type analyzer
         "types-setuptools",  # Needed for mypy type shed
-        "flake8>=6.0.0,<7",  # Style linter
+        "flake8>=6.1.0,<7",  # Style linter
         "isort>=5.10.1,<6",  # Import sorting linter
-        "mdformat>=0.7.16",  # Auto-formatter for markdown
+        "mdformat>=0.7.17",  # Auto-formatter for markdown
         "mdformat-gfm>=0.3.5",  # Needed for formatting GitHub-flavored markdown
         "mdformat-frontmatter>=0.4.1",  # Needed for frontmatters-style headers in issue templates
     ],

tests/conftest.py

@@ -1,7 +1,5 @@
 import ape
 import pytest
-from ape._cli import cli as ape_cli
-from click.testing import CliRunner
 
 
 @pytest.fixture
@@ -15,10 +13,14 @@ def accounts():
 
 
 @pytest.fixture
-def runner():
-    return CliRunner()
+def base(networks):
+    return networks.base
 
 
 @pytest.fixture
-def cli():
-    return ape_cli
+def eth_tester_provider():
+    if not ape.networks.active_provider or ape.networks.provider.name != "test":
+        with ape.networks.base.local.use_provider("test") as provider:
+            yield provider
+    else:
+        yield ape.networks.provider

tests/test_ecosystem.py

@@ -0,0 +1,36 @@
+import pytest
+from ape_ethereum.transactions import TransactionType
+from ethpm_types import MethodABI
+
+from ape_base.ecosystem import _SECOND_STATIC_TYPE
+
+
+def test_gas_limit(base, eth_tester_provider):
+    assert base.config.local.gas_limit == "max"
+
+
+# NOTE: None because we want to show the default is STATIC
+@pytest.mark.parametrize("tx_type", (None, 0, "0x0"))
+def test_create_transaction(base, tx_type, eth_tester_provider):
+    tx = base.create_transaction(type=tx_type)
+    assert tx.type == TransactionType.STATIC.value
+    assert tx.gas_limit == eth_tester_provider.max_gas
+
+
+@pytest.mark.parametrize(
+    "tx_type",
+    (TransactionType.STATIC.value, TransactionType.DYNAMIC.value, _SECOND_STATIC_TYPE),
+)
+def test_encode_transaction(tx_type, base, eth_tester_provider):
+    abi = MethodABI.parse_obj(
+        {
+            "type": "function",
+            "name": "fooAndBar",
+            "stateMutability": "nonpayable",
+            "inputs": [],
+            "outputs": [],
+        }
+    )
+    address = "0x274b028b03A250cA03644E6c578D81f019eE1323"
+    actual = base.encode_transaction(address, abi, sender=address, type=tx_type)
+    assert actual.gas_limit == eth_tester_provider.max_gas

tests/test_integration.py

@@ -0,0 +1,53 @@
+import pytest
+from ape._cli import cli as ape_cli
+from click.testing import CliRunner
+
+EXPECTED_OUTPUT = """
+base
+├── mainnet
+│   └── geth  (default)
+├── goerli
+│   └── geth  (default)
+└── local  (default)
+    └── test  (default)
+""".strip()
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+@pytest.fixture
+def cli():
+    return ape_cli
+
+
+def assert_rich_text(actual: str, expected: str):
+    """
+    The output from `rich` causes a bunch of extra spaces to
+    appear at the end of each line. For easier testing, we remove those here.
+    Also, we ignore whether the expected line is at the end or in the middle
+    of the output to handle cases when the test-runner has additional plugins
+    installed.
+    """
+    expected_lines = [
+        x.replace("└", "").replace("├", "").replace("│", "").strip()
+        for x in expected.strip().split("\n")
+    ]
+    actual_lines = [
+        x.replace("└", "").replace("├", "").replace("│", "").strip()
+        for x in actual.strip().split("\n")
+    ]
+
+    for expected_line in expected_lines:
+        assert expected_line in actual_lines
+
+
+def test_networks(runner, cli, base):
+    # Do this in case local env changed it.
+    base.mainnet.set_default_provider("geth")
+    base.goerli.set_default_provider("geth")
+
+    result = runner.invoke(cli, ["networks", "list"])
+    assert_rich_text(result.output, EXPECTED_OUTPUT)