Clean up AsyncHTTPProvider instantiation

- Add ``is_async`` flag to base provider classes and appropriately set them to ``True`` or ``False``.
- Use these flags to determine whether to load sync or async default middlewares and default modules.

Author: fselmo

newsfragments/2736.feature.rst

@@ -0,0 +1 @@
+Load the ``AsyncHTTPProvider`` with default async middleware and default async modules, just as the ``HTTPProvider``.

tests/core/providers/test_async_http_provider.py

@@ -4,18 +4,80 @@
     ClientSession,
 )
 
+from web3 import Web3
 from web3._utils import (
     request,
 )
+from web3.eth import (
+    AsyncEth,
+)
+from web3.geth import (
+    AsyncGethAdmin,
+    AsyncGethPersonal,
+    AsyncGethTxPool,
+    Geth,
+)
+from web3.middleware import (
+    async_buffered_gas_estimate_middleware,
+    async_gas_price_strategy_middleware,
+    async_validation_middleware,
+)
+from web3.net import (
+    AsyncNet,
+)
 from web3.providers.async_rpc import (
     AsyncHTTPProvider,
 )
 
+URI = "http://mynode.local:8545"
+
+
+def test_no_args():
+    provider = AsyncHTTPProvider()
+    w3 = Web3(provider)
+    assert w3.manager.provider == provider
+    assert w3.manager.provider.is_async
+
+
+def test_init_kwargs():
+    provider = AsyncHTTPProvider(endpoint_uri=URI, request_kwargs={"timeout": 60})
+    w3 = Web3(provider)
+    assert w3.manager.provider == provider
+
+
+def test_web3_with_async_http_provider_has_default_middlewares_and_modules() -> None:
+    async_w3 = Web3(AsyncHTTPProvider(endpoint_uri="http://mynode.local:8545"))
+
+    # assert default modules
+
+    assert isinstance(async_w3.eth, AsyncEth)
+    assert isinstance(async_w3.geth, Geth)
+    assert isinstance(async_w3.async_net, AsyncNet)
+    assert isinstance(async_w3.geth.admin, AsyncGethAdmin)
+    assert isinstance(async_w3.geth.personal, AsyncGethPersonal)
+    assert isinstance(async_w3.geth.txpool, AsyncGethTxPool)
+
+    # assert default middleware
+
+    # the following length check should fail and will need to be added to once more
+    # async middlewares are added to the defaults
+    assert len(async_w3.middleware_onion.middlewares) == 3
+
+    assert (
+        async_w3.middleware_onion.get("gas_price_strategy")
+        == async_gas_price_strategy_middleware
+    )
+    assert async_w3.middleware_onion.get("validation") == async_validation_middleware
+    assert (
+        async_w3.middleware_onion.get("gas_estimate")
+        == async_buffered_gas_estimate_middleware
+    )
+
 
 @pytest.mark.asyncio
 async def test_user_provided_session() -> None:
     session = ClientSession()
-    provider = AsyncHTTPProvider(endpoint_uri="http://mynode.local:8545")
+    provider = AsyncHTTPProvider(endpoint_uri=URI)
     cached_session = await provider.cache_async_session(session)
     assert len(request._async_session_cache) == 1
     assert cached_session == session

tests/core/providers/test_http_provider.py

@@ -20,6 +20,7 @@ def test_no_args():
     provider = HTTPProvider()
     w3 = Web3(provider)
     assert w3.manager.provider == provider
+    assert not w3.manager.provider.is_async
 
 
 def test_init_kwargs():

tests/integration/go_ethereum/test_goethereum_http.py

@@ -12,23 +12,6 @@
 from web3._utils.module_testing.go_ethereum_personal_module import (
     GoEthereumAsyncPersonalModuleTest,
 )
-from web3.eth import (
-    AsyncEth,
-)
-from web3.geth import (
-    AsyncGethAdmin,
-    AsyncGethPersonal,
-    AsyncGethTxPool,
-    Geth,
-)
-from web3.middleware import (
-    async_buffered_gas_estimate_middleware,
-    async_gas_price_strategy_middleware,
-    async_validation_middleware,
-)
-from web3.net import (
-    AsyncNet,
-)
 from web3.providers.async_rpc import (
     AsyncHTTPProvider,
 )
@@ -142,26 +125,7 @@ class TestGoEthereumTxPoolModuleTest(GoEthereumTxPoolModuleTest):
 @pytest_asyncio.fixture(scope="module")
 async def async_w3(geth_process, endpoint_uri):
     await wait_for_aiohttp(endpoint_uri)
-    _w3 = Web3(
-        AsyncHTTPProvider(endpoint_uri),
-        middlewares=[
-            async_buffered_gas_estimate_middleware,
-            async_gas_price_strategy_middleware,
-            async_validation_middleware,
-        ],
-        modules={
-            "eth": AsyncEth,
-            "async_net": AsyncNet,
-            "geth": (
-                Geth,
-                {
-                    "txpool": (AsyncGethTxPool,),
-                    "personal": (AsyncGethPersonal,),
-                    "admin": (AsyncGethAdmin,),
-                },
-            ),
-        },
-    )
+    _w3 = Web3(AsyncHTTPProvider(endpoint_uri))
     return _w3
 
 

web3/main.py

@@ -74,9 +74,13 @@
     abi_ens_resolver,
 )
 from web3.eth import (
+    AsyncEth,
     Eth,
 )
 from web3.geth import (
+    AsyncGethAdmin,
+    AsyncGethPersonal,
+    AsyncGethTxPool,
     Geth,
     GethAdmin,
     GethMiner,
@@ -126,6 +130,21 @@
     from web3._utils.empty import Empty  # noqa: F401
 
 
+def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
+    return {
+        "eth": AsyncEth,
+        "async_net": AsyncNet,
+        "geth": (
+            Geth,
+            {
+                "admin": AsyncGethAdmin,
+                "personal": AsyncGethPersonal,
+                "txpool": AsyncGethTxPool,
+            },
+        ),
+    }
+
+
 def get_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
     return {
         "eth": Eth,
@@ -237,7 +256,10 @@ def __init__(
         self.codec = ABICodec(build_default_registry())
 
         if modules is None:
-            modules = get_default_modules()
+            if provider and provider.is_async:
+                modules = get_async_default_modules()
+            else:
+                modules = get_default_modules()
 
         self.attach_modules(modules)
 

web3/manager.py

@@ -37,6 +37,9 @@
 )
 from web3.middleware import (
     abi_middleware,
+    async_buffered_gas_estimate_middleware,
+    async_gas_price_strategy_middleware,
+    async_validation_middleware,
     attrdict_middleware,
     buffered_gas_estimate_middleware,
     gas_price_strategy_middleware,
@@ -49,6 +52,7 @@
     AutoProvider,
 )
 from web3.types import (  # noqa: F401
+    AsyncMiddleware,
     Middleware,
     MiddlewareOnion,
     RPCEndpoint,
@@ -101,16 +105,19 @@ def __init__(
         self.w3 = w3
         self.pending_requests: Dict[UUID, ThreadWithReturn[RPCResponse]] = {}
 
-        if middlewares is None:
-            middlewares = self.default_middlewares(w3)
-
-        self.middleware_onion: MiddlewareOnion = NamedElementOnion(middlewares)
-
         if provider is None:
             self.provider = AutoProvider()
         else:
             self.provider = provider
 
+        if middlewares is None:
+            if self.provider.is_async:
+                middlewares = self.async_default_middlewares(w3)
+            else:
+                middlewares = self.default_middlewares(w3)
+
+        self.middleware_onion: MiddlewareOnion = NamedElementOnion(middlewares)
+
     w3: "Web3" = None
     _provider = None
 
@@ -139,6 +146,18 @@ def default_middlewares(w3: "Web3") -> List[Tuple[Middleware, str]]:
             (buffered_gas_estimate_middleware, "gas_estimate"),
         ]
 
+    @staticmethod
+    def async_default_middlewares(w3: "Web3") -> List[Tuple[Middleware, str]]:
+        """
+        List the default middlewares for the request manager.
+        Leaving ens unspecified will prevent the middleware from resolving names.
+        """
+        return [
+            (async_gas_price_strategy_middleware, "gas_price_strategy"),
+            (async_validation_middleware, "validation"),
+            (async_buffered_gas_estimate_middleware, "gas_estimate"),
+        ]
+
     #
     # Provider requests and response
     #

web3/providers/async_base.py

@@ -39,6 +39,7 @@ class AsyncBaseProvider:
         None,
     )
 
+    is_async = True
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 

web3/providers/base.py

@@ -38,6 +38,7 @@ class BaseProvider:
         None,
     )
 
+    is_async = False
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4