fix: default network settings

src/ape/api/networks.py

@@ -74,7 +74,7 @@ class EcosystemAPI(BaseInterfaceModel):
     fee_token_decimals: int = 18
     """The number of the decimals the fee token has."""
 
-    _default_network: str = LOCAL_NETWORK_NAME
+    _default_network: Optional[str] = None
 
     def __repr__(self) -> str:
         return f"<{self.name}>"
@@ -254,7 +254,25 @@ def default_network(self) -> str:
         Returns:
             str
         """
-        return self._default_network
+
+        if network := self._default_network:
+            # Was set programatically.
+            return network
+
+        elif network := self.config.get("default_network"):
+            # Default found in config.
+            return network
+
+        elif LOCAL_NETWORK_NAME in self.networks:
+            # Default to the LOCAL_NETWORK_NAME, at last resort.
+            return LOCAL_NETWORK_NAME
+
+        elif len(self.networks) >= 1:
+            # Use the first network.
+            return self.networks[0]
+
+        # Very unlikely scenario.
+        raise ValueError("No networks found.")
 
     def set_default_network(self, network_name: str):
         """
@@ -906,12 +924,19 @@ def default_provider(self) -> Optional[str]:
             Optional[str]
         """
 
-        if self._default_provider:
-            return self._default_provider
+        if provider := self._default_provider:
+            # Was set programatically.
+            return provider
+
+        elif provider_from_config := self._network_config.get("default_provider"):
+            # The default is found in the Network's config class.
+            return provider_from_config
 
-        if len(self.providers) > 0:
+        elif len(self.providers) > 0:
+            # No default set anywhere - use the first installed.
             return list(self.providers)[0]
 
+        # There are no providers at all for this network.
         return None
 
     @property

src/ape/managers/config.py

@@ -5,7 +5,7 @@
 
 from ape._pydantic_compat import root_validator
 from ape.api import ConfigDict, DependencyAPI, PluginConfig
-from ape.exceptions import ConfigError, NetworkError
+from ape.exceptions import ConfigError
 from ape.logging import logger
 from ape.utils import BaseInterfaceModel, load_config
 
@@ -182,11 +182,6 @@ def _plugin_configs(self) -> Dict[str, PluginConfig]:
         configs["compiler"] = compiler_dict
         self.compiler = CompilerConfig(**compiler_dict)
 
-        try:
-            self.network_manager.set_default_ecosystem(self.default_ecosystem)
-        except NetworkError as err:
-            logger.warning(str(err))
-
         dependencies = user_config.pop("dependencies", []) or []
         if not isinstance(dependencies, list):
             raise ConfigError("'dependencies' config item must be a list of dicts.")

src/ape/managers/networks.py

@@ -4,11 +4,9 @@
 import yaml
 
 from ape.api import EcosystemAPI, ProviderAPI, ProviderContextManager
-from ape.api.networks import LOCAL_NETWORK_NAME, NetworkAPI
+from ape.api.networks import NetworkAPI
 from ape.exceptions import ApeAttributeError, NetworkError
-from ape.logging import logger
-
-from .base import BaseManager
+from ape.managers.base import BaseManager
 
 
 class NetworkManager(BaseManager):
@@ -28,7 +26,6 @@ class NetworkManager(BaseManager):
 
     _active_provider: Optional[ProviderAPI] = None
     _default: Optional[str] = None
-    _ecosystems_by_project: Dict[str, Dict[str, EcosystemAPI]] = {}
 
     def __repr__(self):
         provider = self.active_provider
@@ -144,48 +141,15 @@ def ecosystems(self) -> Dict[str, EcosystemAPI]:
         All the registered ecosystems in ``ape``, such as ``ethereum``.
         """
 
-        project_name = self.config_manager.PROJECT_FOLDER.stem
-        if project_name in self._ecosystems_by_project:
-            return self._ecosystems_by_project[project_name]
+        def to_kwargs(name: str) -> Dict:
+            return {
+                "name": name,
+                "data_folder": self.config_manager.DATA_FOLDER / name,
+                "request_header": self.config_manager.REQUEST_HEADER,
+            }
 
-        ecosystem_dict = {}
-        for plugin_name, ecosystem_class in self.plugin_manager.ecosystems:
-            ecosystem = ecosystem_class(  # type: ignore
-                name=plugin_name,
-                data_folder=self.config_manager.DATA_FOLDER / plugin_name,
-                request_header=self.config_manager.REQUEST_HEADER,
-            )
-            ecosystem_config = self.config_manager.get_config(plugin_name).dict()
-            default_network = ecosystem_config.get("default_network", LOCAL_NETWORK_NAME)
-
-            try:
-                ecosystem.set_default_network(default_network)
-            except NetworkError as err:
-                message = f"Failed setting default network: {err}"
-                logger.error(message)
-
-            if ecosystem_config:
-                for network_name, network in ecosystem.networks.items():
-                    network_name = network_name.replace("-", "_")
-                    if network_name not in ecosystem_config:
-                        continue
-
-                    network_config = ecosystem_config[network_name]
-                    if "default_provider" not in network_config:
-                        continue
-
-                    default_provider = network_config["default_provider"]
-                    if default_provider:
-                        try:
-                            network.set_default_provider(default_provider)
-                        except NetworkError as err:
-                            message = f"Failed setting default provider: {err}"
-                            logger.error(message)
-
-            ecosystem_dict[plugin_name] = ecosystem
-
-        self._ecosystems_by_project[project_name] = ecosystem_dict
-        return ecosystem_dict
+        ecosystems = self.plugin_manager.ecosystems
+        return {n: cls(**to_kwargs(n)) for n, cls in ecosystems}  # type: ignore
 
     def create_adhoc_geth_provider(self, uri: str) -> ProviderAPI:
         """
@@ -486,6 +450,9 @@ def default_ecosystem(self) -> EcosystemAPI:
         if self._default:
             return ecosystems[self._default]
 
+        elif self.config_manager.default_ecosystem:
+            return ecosystems[self.config_manager.default_ecosystem]
+
         # If explicit default is not set, use first registered ecosystem
         elif len(ecosystems) > 0:
             return list(ecosystems.values())[0]

tests/functional/test_config.py

@@ -24,14 +24,16 @@ def test_integer_deployment_addresses(networks):
 
 
 @pytest.mark.parametrize(
-    "ecosystems,networks,err_part",
+    "ecosystem_names,network_names,err_part",
     [(["ERRORS"], ["mainnet"], "ecosystem"), (["ethereum"], ["ERRORS"], "network")],
 )
-def test_bad_value_in_deployments(ecosystems, networks, err_part, ape_caplog, plugin_manager):
+def test_bad_value_in_deployments(
+    ecosystem_names, network_names, err_part, ape_caplog, plugin_manager
+):
     deployments = _create_deployments()
     all_ecosystems = dict(plugin_manager.ecosystems)
-    ecosystem_dict = {e: all_ecosystems[e] for e in ecosystems if e in all_ecosystems}
-    data = {**deployments, "valid_ecosystems": ecosystem_dict, "valid_networks": networks}
+    ecosystem_dict = {e: all_ecosystems[e] for e in ecosystem_names if e in all_ecosystems}
+    data = {**deployments, "valid_ecosystems": ecosystem_dict, "valid_networks": network_names}
     ape_caplog.assert_last_log_with_retries(
         lambda: DeploymentConfigCollection(__root__=data),
         f"Invalid {err_part}",

tests/integration/cli/test_networks.py

@@ -108,8 +108,11 @@ def test_list_yaml(ape_cli, runner):
 
 
 @skip_projects_except("geth")
-def test_geth(ape_cli, runner, networks):
+def test_geth(ape_cli, runner, networks, project):
     result = runner.invoke(ape_cli, ["networks", "list"])
+    assert (
+        networks.provider.network.default_provider == "geth"
+    ), "Setup failed - default provider didn't apply from config"
     assert_rich_text(result.output, _GETH_NETWORKS_TREE)
 
     # Assert that URI still exists for local network