bugfix: Fix batching for AutoProvider

- We can't set the provider, we must let `AutoProvider` decide when it
  makes proxy calls using the "active" provider.

- For the reason above, we need to implement a proxy batch request
  so that it can instead pull the active provider and make the
  batch request using it.

- Make sure current tests fail with the old implementation and pass
  with the new one.

closes #3711

Author: fselmo

newsfragments/3712.bugfix.rst

@@ -0,0 +1 @@
+Fix ``AutoProvider`` batching setup by adding a proxy batch request.

tests/integration/go_ethereum/test_goethereum_http.py

@@ -7,6 +7,7 @@
 
 from web3 import (
     AsyncWeb3,
+    AutoProvider,
     Web3,
 )
 from web3._utils.module_testing.go_ethereum_admin_module import (
@@ -102,8 +103,17 @@ class TestGoEthereumDebugModuleTest(GoEthereumDebugModuleTest):
 
 class TestGoEthereumEthModuleTest(GoEthereumEthModuleTest):
     def test_auto_provider_batching(self, auto_w3: "Web3") -> None:
-        # test that batch_requests doesn't error out when using the auto provider
-        auto_w3.batch_requests()
+        with auto_w3.batch_requests() as batch:
+            assert isinstance(auto_w3.provider, AutoProvider)
+            assert auto_w3.provider._is_batching
+            assert auto_w3.provider._batching_context is not None
+            batch.add(auto_w3.eth.get_block("latest"))
+            batch.add(auto_w3.eth.get_block("earliest"))
+            batch.add(auto_w3.eth.get_block("pending"))
+            results = batch.execute()
+
+        assert not auto_w3.provider._is_batching
+        assert len(results) == 3
 
 
 class TestGoEthereumNetModuleTest(GoEthereumNetModuleTest):

tests/integration/go_ethereum/test_goethereum_ipc.py

@@ -7,6 +7,7 @@
 from web3 import (
     AsyncIPCProvider,
     AsyncWeb3,
+    AutoProvider,
     Web3,
 )
 from web3._utils.module_testing.persistent_connection_provider import (
@@ -81,8 +82,17 @@ class TestGoEthereumDebugModuleTest(GoEthereumDebugModuleTest):
 
 class TestGoEthereumEthModuleTest(GoEthereumEthModuleTest):
     def test_auto_provider_batching(self, auto_w3: "Web3") -> None:
-        # test that batch_requests doesn't error out when using the auto provider
-        auto_w3.batch_requests()
+        with auto_w3.batch_requests() as batch:
+            assert isinstance(auto_w3.provider, AutoProvider)
+            assert auto_w3.provider._is_batching
+            assert auto_w3.provider._batching_context is not None
+            batch.add(auto_w3.eth.get_block("latest"))
+            batch.add(auto_w3.eth.get_block("earliest"))
+            batch.add(auto_w3.eth.get_block("pending"))
+            results = batch.execute()
+
+        assert not auto_w3.provider._is_batching
+        assert len(results) == 3
 
 
 class TestGoEthereumNetModuleTest(GoEthereumNetModuleTest):

web3/manager.py

@@ -254,9 +254,9 @@ def _batch_requests(self) -> RequestBatcher[Method[Callable[..., Any]]]:
         """
         Context manager for making batch requests
         """
-        if isinstance(self.provider, AutoProvider):
-            self.provider = self.provider._get_active_provider(use_cache=True)
-        if not isinstance(self.provider, (AsyncJSONBaseProvider, JSONBaseProvider)):
+        if not isinstance(
+            self.provider, (AsyncJSONBaseProvider, JSONBaseProvider, AutoProvider)
+        ):
             raise Web3TypeError("Batch requests are not supported by this provider.")
         return RequestBatcher(self.w3)
 

web3/providers/auto.py

@@ -3,6 +3,7 @@
     Any,
     Callable,
     Dict,
+    List,
     Optional,
     Sequence,
     Tuple,
@@ -21,9 +22,9 @@
     CannotHandleRequest,
 )
 from web3.providers import (
-    BaseProvider,
     HTTPProvider,
     IPCProvider,
+    JSONBaseProvider,
     LegacyWebSocketProvider,
 )
 from web3.types import (
@@ -35,7 +36,7 @@
 WS_SCHEMES = {"ws", "wss"}
 
 
-def load_provider_from_environment() -> BaseProvider:
+def load_provider_from_environment() -> Optional[JSONBaseProvider]:
     uri_string = URI(os.environ.get("WEB3_PROVIDER_URI", ""))
     if not uri_string:
         return None
@@ -45,7 +46,7 @@ def load_provider_from_environment() -> BaseProvider:
 
 def load_provider_from_uri(
     uri_string: URI, headers: Optional[Dict[str, Tuple[str, str]]] = None
-) -> BaseProvider:
+) -> JSONBaseProvider:
     uri = urlparse(uri_string)
     if uri.scheme == "file":
         return IPCProvider(uri.path)
@@ -60,7 +61,7 @@ def load_provider_from_uri(
         )
 
 
-class AutoProvider(BaseProvider):
+class AutoProvider(JSONBaseProvider):
     default_providers = (
         load_provider_from_environment,
         IPCProvider,
@@ -72,7 +73,7 @@ class AutoProvider(BaseProvider):
     def __init__(
         self,
         potential_providers: Optional[
-            Sequence[Union[Callable[..., BaseProvider], Type[BaseProvider]]]
+            Sequence[Union[Callable[..., JSONBaseProvider], Type[JSONBaseProvider]]]
         ] = None,
     ) -> None:
         """
@@ -83,6 +84,7 @@ def __init__(
         in an attempt to find an active node. The list will default to
         :attribute:`default_providers`.
         """
+        super().__init__()
         if potential_providers:
             self._potential_providers = potential_providers
         else:
@@ -94,6 +96,14 @@ def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         except OSError:
             return self._proxy_request(method, params, use_cache=False)
 
+    def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> Union[List[RPCResponse], RPCResponse]:
+        try:
+            return self._proxy_batch_request(requests)
+        except OSError:
+            return self._proxy_batch_request(requests, use_cache=False)
+
     def is_connected(self, show_traceback: bool = False) -> bool:
         provider = self._get_active_provider(use_cache=True)
         return provider is not None and provider.is_connected(show_traceback)
@@ -110,7 +120,19 @@ def _proxy_request(
 
         return provider.make_request(method, params)
 
-    def _get_active_provider(self, use_cache: bool) -> Optional[BaseProvider]:
+    def _proxy_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]], use_cache: bool = True
+    ) -> Union[List[RPCResponse], RPCResponse]:
+        provider = self._get_active_provider(use_cache)
+        if provider is None:
+            raise CannotHandleRequest(
+                "Could not discover provider while making batch request: "
+                f"requests:{requests}\n"
+            )
+
+        return provider.make_batch_request(requests)
+
+    def _get_active_provider(self, use_cache: bool) -> Optional[JSONBaseProvider]:
         if use_cache and self._active_provider is not None:
             return self._active_provider