refactor: refactor base contract creation methods

Author: antazoey

src/ape/api/accounts.py

@@ -173,14 +173,17 @@ def deploy(self, contract: "ContractContainer", *args, **kwargs) -> "ContractIns
         if not receipt.contract_address:
             raise AccountsError(f"'{receipt.txn_hash}' did not create a contract.")
 
-        address = click.style(receipt.contract_address, bold=True)
+        address = receipt.contract_address
+        styled_address = click.style(receipt.contract_address, bold=True)
         contract_name = contract.contract_type.name or "<Unnamed Contract>"
-        logger.success(f"Contract '{contract_name}' deployed to: {address}")
-
-        contract_instance = self.get_contract_instance(
-            address=receipt.contract_address,  # type: ignore
-            contract_type=contract.contract_type,
+        logger.success(f"Contract '{contract_name}' deployed to: {styled_address}")
+        contract_instance = self.chain_manager.contracts.instance_at(
+            address, contract.contract_type
         )
+
+        if not isinstance(contract_instance, ContractInstance):
+            raise ValueError("Failed to deploy contract.")
+
         self.chain_manager.contracts[contract_instance.address] = contract_instance.contract_type
         return contract_instance
 

src/ape/api/projects.py

@@ -235,7 +235,8 @@ def __getattr__(self, contract_name: str) -> "ContractContainer":
     def get(self, contract_name: str) -> Optional["ContractContainer"]:
         manifest = self.extract_manifest()
         if hasattr(manifest, contract_name):
-            return self.create_contract_container(contract_type=getattr(manifest, contract_name))
+            contract_type = getattr(manifest, contract_name)
+            return self.chain_manager.contracts.get_container(contract_type)
 
         return None
 

src/ape/contracts/base.py

@@ -674,10 +674,12 @@ def at(self, address: AddressType) -> ContractInstance:
             :class:`~ape.contracts.ContractInstance`
         """
 
-        return self.get_contract_instance(
-            address=address,
-            contract_type=self.contract_type,
-        )
+        contract = self.chain_manager.contracts.instance_at(address, self.contract_type)
+
+        if not isinstance(contract, ContractInstance):
+            raise ValueError(f"Address '{address}' is not a contract.")
+
+        return contract
 
     def __call__(self, *args, **kwargs) -> TransactionAPI:
         args = self.conversion_manager.convert(args, tuple)

src/ape/managers/chain.py

@@ -576,6 +576,19 @@ def get(
 
         return contract_type
 
+    def get_container(self, contract_type: ContractType) -> ContractContainer:
+        """
+        Get a contract container for the given contract type.
+
+        Args:
+            contract_type (ContractType): The contract type to wrap.
+
+        Returns:
+            ContractContainer: A container object you can deploy.
+        """
+
+        return ContractContainer(contract_type)
+
     def instance_at(
         self, address: Union[str, "AddressType"], contract_type: Optional[ContractType] = None
     ) -> BaseAddress:
@@ -618,8 +631,9 @@ def instance_at(
                     f"Expected type '{ContractType.__name__}' for argument 'contract_type'."
                 )
 
-            return self.get_contract_instance(address, contract_type)
+            return ContractInstance(address, contract_type)
 
+        logger.warning(f"Failed to find contract type at address '{address}'.")
         return Address(address)
 
     def get_deployments(self, contract_container: ContractContainer) -> List[ContractInstance]:

src/ape/managers/project/manager.py

@@ -440,9 +440,7 @@ def _load_dependencies(self) -> Dict[str, Dict[str, DependencyAPI]]:
 
     def _get_contract(self, name: str) -> Optional[ContractContainer]:
         if name in self.contracts:
-            return self.create_contract_container(
-                contract_type=self.contracts[name],
-            )
+            return self.chain_manager.contracts.get_container(self.contracts[name])
 
         return None
 

src/ape/utils/basemodel.py

@@ -1,16 +1,13 @@
 from abc import ABC
 from typing import TYPE_CHECKING, ClassVar, Dict, List, cast
 
-from ethpm_types import ContractType
 from pydantic import BaseModel
 
 from ape.exceptions import ProviderNotConnectedError
-from ape.types import AddressType
 from ape.utils.misc import cached_property, singledispatchmethod
 
 if TYPE_CHECKING:
     from ape.api.providers import ProviderAPI
-    from ape.contracts.base import ContractContainer, ContractInstance
     from ape.managers.accounts import AccountManager
     from ape.managers.chain import ChainManager
     from ape.managers.compilers import CompilerManager
@@ -75,37 +72,6 @@ def provider(self) -> "ProviderAPI":
             raise ProviderNotConnectedError()
         return self.network_manager.active_provider
 
-    def create_contract_container(self, contract_type: ContractType) -> "ContractContainer":
-        """
-        Helper method for creating a ``ContractContainer``.
-
-        Args:
-            contract_type (``ContractType``): Type of contract for the container
-
-        Returns:
-            :class:`~ape.contracts.ContractContainer`
-        """
-        from ape.contracts.base import ContractContainer
-
-        return ContractContainer(contract_type=contract_type)
-
-    def get_contract_instance(
-        self, address: "AddressType", contract_type: "ContractType"
-    ) -> "ContractInstance":
-        """
-        Helper method for creating a ``ContractInstance``.
-
-        Args:
-            address (``AddressType``): Address of contract
-            contract_type (``ContractType``): Type of contract
-
-        Returns:
-            :class:`~ape.contracts.ContractInstance`
-        """
-        from ape.contracts.base import ContractInstance
-
-        return ContractInstance(address=address, contract_type=contract_type)
-
 
 class BaseInterface(ManagerAccessMixin, ABC):
     """

src/ape/utils/trace.py

@@ -132,10 +132,11 @@ def _dim_default_gas(call_sig: str) -> str:
             method = None
             contract_name = contract_type.name
             if "symbol" in contract_type.view_methods:
-                contract = self._receipt.get_contract_instance(address, contract_type)
+                # Type ignores below because we know it's a ContractInstance at this point.
+                contract = self._receipt.chain_manager.contracts.instance_at(address, contract_type)
 
                 try:
-                    contract_name = contract.symbol() or contract_name
+                    contract_name = contract.symbol() or contract_name  # type: ignore
                 except ContractError:
                     contract_name = contract_type.name