web3 7.12.1__py3-none-any.whl → 7.14.0__py3-none-any.whl

web3/_utils/module_testing/go_ethereum_admin_module.py

@@ -1,6 +1,7 @@
 import pytest
 from typing import (
     TYPE_CHECKING,
+    Any,
     List,
 )
 
@@ -70,29 +71,29 @@ class GoEthereumAdminModuleTest:
 
 class GoEthereumAsyncAdminModuleTest:
     @pytest.mark.asyncio
-    async def test_async_datadir(self, async_w3: "AsyncWeb3") -> None:
+    async def test_async_datadir(self, async_w3: "AsyncWeb3[Any]") -> None:
         datadir = await async_w3.geth.admin.datadir()
         assert isinstance(datadir, str)
 
     @pytest.mark.asyncio
-    async def test_async_node_info(self, async_w3: "AsyncWeb3") -> None:
+    async def test_async_node_info(self, async_w3: "AsyncWeb3[Any]") -> None:
         node_info = await async_w3.geth.admin.node_info()
         assert "Geth" in node_info["name"]
 
     @pytest.mark.asyncio
-    async def test_async_nodes(self, async_w3: "AsyncWeb3") -> None:
+    async def test_async_nodes(self, async_w3: "AsyncWeb3[Any]") -> None:
         nodes = await async_w3.geth.admin.peers()
         assert isinstance(nodes, List)
 
     @pytest.mark.asyncio
-    async def test_admin_peers(self, async_w3: "AsyncWeb3") -> None:
+    async def test_admin_peers(self, async_w3: "AsyncWeb3[Any]") -> None:
         node_info = await async_w3.geth.admin.node_info()
         await async_w3.geth.admin.add_peer(node_info["enode"])
         result = await async_w3.geth.admin.peers()
         assert len(result) == 1
 
     @pytest.mark.asyncio
-    async def test_admin_start_stop_http(self, async_w3: "AsyncWeb3") -> None:
+    async def test_admin_start_stop_http(self, async_w3: "AsyncWeb3[Any]") -> None:
         stop = await async_w3.geth.admin.stop_http()
         assert stop is True
 
@@ -100,7 +101,7 @@ class GoEthereumAsyncAdminModuleTest:
         assert start is True
 
     @pytest.mark.asyncio
-    async def test_admin_start_stop_ws(self, async_w3: "AsyncWeb3") -> None:
+    async def test_admin_start_stop_ws(self, async_w3: "AsyncWeb3[Any]") -> None:
         stop = await async_w3.geth.admin.stop_ws()
         assert stop is True
 

web3/_utils/module_testing/go_ethereum_debug_module.py

@@ -1,5 +1,6 @@
 import pytest
 from typing import (
+    Any,
     cast,
 )
 
@@ -24,7 +25,7 @@ from web3.types import (
 class GoEthereumAsyncDebugModuleTest:
     @pytest.mark.asyncio
     async def test_async_geth_debug_trace_transaction_opcode_logger(
-        self, async_w3: "AsyncWeb3", txn_hash_with_log: HexStr
+        self, async_w3: "AsyncWeb3[Any]", txn_hash_with_log: HexStr
     ) -> None:
         result = await async_w3.geth.debug.trace_transaction(txn_hash_with_log)
         assert "structLogs" in dict(result).keys()
@@ -33,7 +34,7 @@ class GoEthereumAsyncDebugModuleTest:
 
     @pytest.mark.asyncio
     async def test_async_geth_debug_trace_transaction_call_tracer(
-        self, async_w3: "AsyncWeb3", txn_hash_with_log: HexStr
+        self, async_w3: "AsyncWeb3[Any]", txn_hash_with_log: HexStr
     ) -> None:
         result = cast(
             CallTrace,
@@ -45,7 +46,7 @@ class GoEthereumAsyncDebugModuleTest:
 
     @pytest.mark.asyncio
     async def test_async_geth_debug_trace_transaction_prestate_tracer_diffMode(
-        self, async_w3: "AsyncWeb3", txn_hash_with_log: HexStr
+        self, async_w3: "AsyncWeb3[Any]", txn_hash_with_log: HexStr
     ) -> None:
         result = cast(
             DiffModeTrace,
@@ -60,7 +61,7 @@ class GoEthereumAsyncDebugModuleTest:
     @pytest.mark.asyncio
     async def test_async_geth_debug_trace_transaction_prestate_tracer(
         self,
-        async_w3: "AsyncWeb3",
+        async_w3: "AsyncWeb3[Any]",
         txn_hash_with_log: HexStr,
         async_block_with_txn_with_log: BlockData,
     ) -> None:

web3/_utils/module_testing/go_ethereum_txpool_module.py

@@ -1,4 +1,7 @@
 import pytest
+from typing import (
+    Any,
+)
 
 from web3 import (
     AsyncWeb3,
@@ -8,17 +11,17 @@ from web3 import (
 
 class GoEthereumAsyncTxPoolModuleTest:
     @pytest.mark.asyncio
-    async def test_async_geth_txpool_inspect(self, async_w3: "AsyncWeb3") -> None:
+    async def test_async_geth_txpool_inspect(self, async_w3: "AsyncWeb3[Any]") -> None:
         test_data = await async_w3.geth.txpool.inspect()
         assert "pending" in test_data
 
     @pytest.mark.asyncio
-    async def test_async_geth_txpool_content(self, async_w3: "AsyncWeb3") -> None:
+    async def test_async_geth_txpool_content(self, async_w3: "AsyncWeb3[Any]") -> None:
         test_data = await async_w3.geth.txpool.content()
         assert "pending" in test_data
 
     @pytest.mark.asyncio
-    async def test_async_geth_txpool_status(self, async_w3: "AsyncWeb3") -> None:
+    async def test_async_geth_txpool_status(self, async_w3: "AsyncWeb3[Any]") -> None:
         test_data = await async_w3.geth.txpool.status()
         assert "pending" in test_data
 

web3/_utils/module_testing/module_testing_utils.py

@@ -132,7 +132,7 @@ def async_mock_offchain_lookup_request_response(
 
         @staticmethod
         def raise_for_status() -> None:
-            raise Exception("called raise_for_status()")  # noqa: E501, E704
+            raise Exception("called raise_for_status()")  # noqa: E704
 
     async def _mock_specific_request(
         *args: Any, **kwargs: Any

web3/_utils/module_testing/net_module.py

@@ -1,6 +1,7 @@
 import pytest
 from typing import (
     TYPE_CHECKING,
+    Any,
 )
 
 from eth_utils import (
@@ -36,20 +37,20 @@ class NetModuleTest:
 
 class AsyncNetModuleTest:
     @pytest.mark.asyncio
-    async def test_net_version(self, async_w3: "AsyncWeb3") -> None:
+    async def test_net_version(self, async_w3: "AsyncWeb3[Any]") -> None:
         version = await async_w3.net.version
 
         assert is_string(version)
         assert version.isdigit()
 
     @pytest.mark.asyncio
-    async def test_net_listening(self, async_w3: "AsyncWeb3") -> None:
+    async def test_net_listening(self, async_w3: "AsyncWeb3[Any]") -> None:
         listening = await async_w3.net.listening
 
         assert is_boolean(listening)
 
     @pytest.mark.asyncio
-    async def test_net_peer_count(self, async_w3: "AsyncWeb3") -> None:
+    async def test_net_peer_count(self, async_w3: "AsyncWeb3[Any]") -> None:
         peer_count = await async_w3.net.peer_count
 
         assert is_integer(peer_count)

web3/_utils/module_testing/persistent_connection_provider.py

@@ -9,6 +9,7 @@ from typing import (
     Dict,
     Generator,
     List,
+    Sequence,
     Tuple,
     Union,
     cast,
@@ -44,6 +45,7 @@ from web3.types import (
     LogReceipt,
     Nonce,
     RPCEndpoint,
+    TopicFilter,
     TxData,
     Wei,
 )
@@ -171,7 +173,7 @@ async def idle_handler(
 
 
 async def emit_contract_event(
-    async_w3: AsyncWeb3,
+    async_w3: "AsyncWeb3[Any]",
     acct: ChecksumAddress,
     contract_function: "AsyncContractFunction",
     args: Any = (),
@@ -184,7 +186,7 @@ async def emit_contract_event(
 
 
 async def log_indexed_and_non_indexed_args_task(
-    async_w3: AsyncWeb3,
+    async_w3: "AsyncWeb3[Any]",
     async_emitter_contract: "AsyncContract",
     acct: ChecksumAddress,
     delay: float = 0.1,
@@ -224,14 +226,14 @@ async def clean_up_task(task: "asyncio.Task[Any]") -> None:
 
 class PersistentConnectionProviderTest:
     @pytest.fixture(autouse=True)
-    def clear_caches(self, async_w3: AsyncWeb3) -> Generator[None, None, None]:
+    def clear_caches(self, async_w3: "AsyncWeb3[Any]") -> Generator[None, None, None]:
         yield
         async_w3.provider._request_processor.clear_caches()
         async_w3.subscription_manager.total_handler_calls = 0
 
     @staticmethod
     async def seed_transactions_to_geth(
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
         acct: ChecksumAddress,
         num_txs: int = 1,
         delay: float = 0.1,
@@ -303,7 +305,7 @@ class PersistentConnectionProviderTest:
     )
     async def test_async_eth_subscribe_syncing_mocked(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
         subscription_params: Tuple[Any, ...],
         ws_subscription_response: Dict[str, Any],
         expected_formatted_result: Any,
@@ -334,7 +336,9 @@ class PersistentConnectionProviderTest:
         )
 
     @pytest.mark.asyncio
-    async def test_async_eth_subscribe_new_heads(self, async_w3: AsyncWeb3) -> None:
+    async def test_async_eth_subscribe_new_heads(
+        self, async_w3: "AsyncWeb3[Any]"
+    ) -> None:
         sub_id = await async_w3.eth.subscribe("newHeads")
         assert is_hexstr(sub_id)
 
@@ -353,7 +357,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_async_eth_subscribe_creates_and_handles_new_heads_subscription_type(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         sub_manager = async_w3.subscription_manager
         new_heads_handler_test = SubscriptionHandlerTest()
@@ -380,7 +384,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_async_eth_subscribe_process_pending_tx_true(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         sub_id = await async_w3.eth.subscribe("newPendingTransactions", True)
         assert is_hexstr(sub_id)
@@ -423,7 +427,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_async_eth_subscribe_and_process_pending_tx_false(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         sub_id = await async_w3.eth.subscribe("newPendingTransactions")
         assert is_hexstr(sub_id)
@@ -460,7 +464,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_async_eth_subscribe_creates_and_handles_pending_tx_subscription_type(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         sub_manager = async_w3.subscription_manager
         pending_tx_handler_test = SubscriptionHandlerTest()
@@ -497,7 +501,7 @@ class PersistentConnectionProviderTest:
 
     @pytest.mark.asyncio
     async def test_async_eth_subscribe_and_process_logs(
-        self, async_w3: AsyncWeb3, async_emitter_contract: "AsyncContract"
+        self, async_w3: "AsyncWeb3[Any]", async_emitter_contract: "AsyncContract"
     ) -> None:
         event = async_emitter_contract.events.LogIndexedAndNotIndexed
         event_topic = async_w3.keccak(text=event.abi_element_identifier).to_0x_hex()
@@ -536,7 +540,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_async_eth_subscribe_creates_and_handles_logs_subscription_type(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
         async_emitter_contract: "AsyncContract",
     ) -> None:
         sub_manager = async_w3.subscription_manager
@@ -580,10 +584,116 @@ class PersistentConnectionProviderTest:
         sub_manager.total_handler_calls = 0
         await clean_up_task(emit_event_task)
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "topics",
+        [
+            pytest.param(
+                [
+                    HexStr(
+                        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"  # noqa: E501
+                    )
+                ],
+                id="Single specific topic at position 0",
+            ),
+            pytest.param(
+                [
+                    None,
+                    HexStr(
+                        "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"  # noqa: E501
+                    ),
+                ],
+                id="Wildcard at position 0, specific topic at position 1",
+            ),
+            pytest.param(
+                [
+                    [
+                        HexStr(
+                            "0x1111111111111111111111111111111111111111111111111111111111111111"  # noqa: E501
+                        ),
+                        HexStr(
+                            "0x2222222222222222222222222222222222222222222222222222222222222222"  # noqa: E501
+                        ),
+                    ]
+                ],
+                id="OR pattern: topic A or B at position 0",
+            ),
+            pytest.param(
+                [
+                    [
+                        HexStr(
+                            "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"  # noqa: E501
+                        ),
+                        HexStr(
+                            "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"  # noqa: E501
+                        ),
+                    ],
+                    HexStr(
+                        "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"  # noqa: E501
+                    ),
+                ],
+                id="Complex: (A or B) at position 0 AND C at position 1",
+            ),
+            pytest.param(
+                [
+                    HexBytes(
+                        "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"  # noqa: E501
+                    )
+                ],
+                id="Single specific topic at position 0 with HexBytes",
+            ),
+            pytest.param(
+                [
+                    [
+                        HexBytes(
+                            "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"  # noqa: E501
+                        ),
+                        HexStr(
+                            "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"  # noqa: E501
+                        ),
+                        b"\xcc" * 32,
+                    ]
+                ],
+                id="OR pattern with mixed HexBytes, HexStr, and bytes at position 0",
+            ),
+        ],
+    )
+    async def test_async_logs_subscription_with_and_or_topic_patterns(
+        self,
+        async_w3: "AsyncWeb3[Any]",
+        async_emitter_contract: "AsyncContract",
+        topics: Sequence[TopicFilter],
+    ) -> None:
+        """Test that LogsSubscription properly handles AND/OR topic patterns."""
+        sub_manager = async_w3.subscription_manager
+
+        subscription = LogsSubscription(
+            address=async_emitter_contract.address,
+            topics=topics,
+            handler=idle_handler,
+        )
+
+        await sub_manager.subscribe(subscription)
+        assert len(sub_manager.subscriptions) == 1
+        assert isinstance(sub_manager.subscriptions[0], LogsSubscription)
+        assert sub_manager.subscriptions[0].topics == topics
+
+        assert subscription.subscription_params == (
+            "logs",
+            {
+                "address": async_emitter_contract.address,
+                "topics": topics,
+            },
+        )
+
+        # clean up
+        await sub_manager.unsubscribe(subscription)
+        assert len(sub_manager.subscriptions) == 0
+
     @pytest.mark.asyncio
     async def test_async_extradata_poa_middleware_on_eth_subscription(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         async_w3.middleware_onion.inject(
             ExtraDataToPOAMiddleware, "poa_middleware", layer=0
@@ -626,7 +736,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_asyncio_gather_for_multiple_requests_matches_the_responses(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         (
             latest,
@@ -662,7 +772,7 @@ class PersistentConnectionProviderTest:
         assert chain_id == chain_id2 == chain_id3 == 131277322940537
 
     @pytest.mark.asyncio
-    async def test_async_public_socket_api(self, async_w3: AsyncWeb3) -> None:
+    async def test_async_public_socket_api(self, async_w3: "AsyncWeb3[Any]") -> None:
         # clear all caches and queues
         async_w3.provider._request_processor.clear_caches()
 
@@ -691,7 +801,7 @@ class PersistentConnectionProviderTest:
 
     @pytest.mark.asyncio
     async def test_async_subscription_manager_subscribes_to_many_subscriptions(
-        self, async_w3: AsyncWeb3, async_emitter_contract: "AsyncContract"
+        self, async_w3: "AsyncWeb3[Any]", async_emitter_contract: "AsyncContract"
     ) -> None:
         sub_manager = async_w3.subscription_manager
 
@@ -754,7 +864,9 @@ class PersistentConnectionProviderTest:
         await clean_up_task(emit_event_task)
 
     @pytest.mark.asyncio
-    async def test_subscription_handler_context(self, async_w3: AsyncWeb3) -> None:
+    async def test_subscription_handler_context(
+        self, async_w3: "AsyncWeb3[Any]"
+    ) -> None:
         base_url = "http://localhost:1337"
         async_beacon = AsyncBeacon(base_url)
         handler_test = SubscriptionHandlerTest()
@@ -802,7 +914,7 @@ class PersistentConnectionProviderTest:
 
     @pytest.mark.asyncio
     async def test_subscriptions_with_handler_and_without(
-        self, async_w3: AsyncWeb3
+        self, async_w3: "AsyncWeb3[Any]"
     ) -> None:
         handler_test = SubscriptionHandlerTest()
         stream_passed = False
@@ -851,7 +963,7 @@ class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     async def test_handle_subscriptions_breaks_on_unsubscribe(
         self,
-        async_w3: AsyncWeb3,
+        async_w3: "AsyncWeb3[Any]",
     ) -> None:
         async def unsubscribe_subs(
             subs: List[Union[NewHeadsSubscription, LogsSubscription]],
@@ -879,7 +991,7 @@ class PersistentConnectionProviderTest:
 
     @pytest.mark.asyncio
     async def test_run_forever_starts_with_0_subs_and_runs_until_task_cancelled(
-        self, async_w3: AsyncWeb3
+        self, async_w3: "AsyncWeb3[Any]"
     ) -> None:
         sub_manager = async_w3.subscription_manager
         assert_no_subscriptions_left(sub_manager._subscription_container)

web3/_utils/module_testing/utils.py

@@ -97,7 +97,7 @@ class RequestMocker:
 
     def __init__(
         self,
-        w3: Union["AsyncWeb3", "Web3"],
+        w3: Union["AsyncWeb3[Any]", "Web3"],
         mock_results: Dict[Union["RPCEndpoint", str], Any] = None,
         mock_errors: Dict[Union["RPCEndpoint", str], Any] = None,
         mock_responses: Dict[Union["RPCEndpoint", str], Any] = None,
@@ -131,8 +131,9 @@ class RequestMocker:
         return self
 
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        # mypy error: Cannot assign to a method
-        self.w3.provider.make_request = self._make_request  # type: ignore[assignment]
+        self.w3.provider.make_request = (  # type: ignore[method-assign]
+            self._make_request
+        )
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 
@@ -204,7 +205,7 @@ class RequestMocker:
     async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
             # mypy error: Cannot assign to a method
-            self.w3.provider.make_request = self._make_request  # type: ignore[assignment]  # noqa: E501
+            self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
             # reset request func cache to re-build request_func w/ original make_request
             self.w3.provider._request_func_cache = (None, None)
         else:
@@ -261,7 +262,7 @@ class RequestMocker:
     async def _async_mock_request_handler(
         self, method: "RPCEndpoint", params: Any
     ) -> "RPCResponse":
-        self.w3 = cast("AsyncWeb3", self.w3)
+        self.w3 = cast("AsyncWeb3[Any]", self.w3)
         self._make_request = cast("AsyncMakeRequestFn", self._make_request)
         if all(
             method not in mock_dict
@@ -299,7 +300,7 @@ class RequestMocker:
     async def _async_mock_recv_handler(
         self, rpc_request: "RPCRequest"
     ) -> "RPCResponse":
-        self.w3 = cast("AsyncWeb3", self.w3)
+        self.w3 = cast("AsyncWeb3[Any]", self.w3)
         method = rpc_request["method"]
         request_id = rpc_request["id"]
         if all(

web3/_utils/module_testing/web3_module.py

@@ -565,13 +565,13 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
     # an asynchronous test should have the exact same name.
 
     @pytest.mark.asyncio
-    async def test_web3_client_version(self, async_w3: AsyncWeb3) -> None:  # type: ignore[override]  # noqa: E501
+    async def test_web3_client_version(self, async_w3: AsyncWeb3[Any]) -> None:
         client_version = await async_w3.client_version
         self._check_web3_client_version(client_version)
 
     @pytest.mark.asyncio
-    async def test_batch_requests(  # type: ignore[override]
-        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"
+    async def test_batch_requests(
+        self, async_w3: AsyncWeb3[Any], async_math_contract: "AsyncContract"
     ) -> None:
         async with async_w3.batch_requests() as batch:
             batch.add(async_w3.eth.get_block(6))
@@ -638,8 +638,10 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
         assert last_three_responses[2]["number"] == 5
 
     @pytest.mark.asyncio
-    async def test_batch_requests_initialized_as_object(  # type: ignore[override]
-        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"  # type: ignore[override]  # noqa: E501
+    async def test_batch_requests_initialized_as_object(
+        self,
+        async_w3: AsyncWeb3[Any],
+        async_math_contract: "AsyncContract",
     ) -> None:
         batch = async_w3.batch_requests()
         batch.add(async_w3.eth.get_block(1))
@@ -686,7 +688,7 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
         assert cast(BlockData, b4)["number"] == 4
 
     @pytest.mark.asyncio
-    async def test_batch_requests_clear(self, async_w3: AsyncWeb3) -> None:  # type: ignore[override]  # noqa: E501
+    async def test_batch_requests_clear(self, async_w3: AsyncWeb3[Any]) -> None:
         async with async_w3.batch_requests() as batch:
             batch.add(async_w3.eth.get_block(1))
             batch.add(async_w3.eth.get_block(2))
@@ -715,7 +717,7 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
         assert cast(BlockData, r3)["number"] == 6
 
     @pytest.mark.asyncio
-    async def test_batch_requests_cancel(self, async_w3: AsyncWeb3) -> None:  # type: ignore[override]  # noqa: E501
+    async def test_batch_requests_cancel(self, async_w3: AsyncWeb3[Any]) -> None:
         # as context manager
         async with async_w3.batch_requests() as batch:
             batch.add(async_w3.eth.get_block(1))
@@ -755,8 +757,10 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
         assert isinstance(block_num, int)
 
     @pytest.mark.asyncio
-    async def test_batch_requests_raises_for_common_unsupported_methods(  # type: ignore[override]  # noqa: E501
-        self, async_w3: AsyncWeb3, async_math_contract: "AsyncContract"  # type: ignore[override]  # noqa: E501
+    async def test_batch_requests_raises_for_common_unsupported_methods(
+        self,
+        async_w3: AsyncWeb3[Any],
+        async_math_contract: "AsyncContract",
     ) -> None:
         async with async_w3.batch_requests() as batch:
             with pytest.raises(MethodNotSupported, match="eth_sendTransaction"):
@@ -779,8 +783,8 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
                 await batch.async_execute()
 
     @pytest.mark.asyncio
-    async def test_batch_requests_concurrently_with_regular_requests(  # type: ignore[override]  # noqa: E501
-        self, async_w3: AsyncWeb3  # type: ignore[override]
+    async def test_batch_requests_concurrently_with_regular_requests(
+        self, async_w3: AsyncWeb3[Any]
     ) -> None:
         responses = []
         batch_response = []

web3/_utils/normalizers.py

@@ -72,7 +72,7 @@ if TYPE_CHECKING:
 
 
 def implicitly_identity(
-    to_wrap: Callable[[TypeStr, Any], Any]
+    to_wrap: Callable[[TypeStr, Any], Any],
 ) -> Callable[[TypeStr, Any], Tuple[TypeStr, Any]]:
     @functools.wraps(to_wrap)
     def wrapper(type_str: TypeStr, data: Any) -> Tuple[TypeStr, Any]:
@@ -112,7 +112,7 @@ def decode_abi_strings(type_str: TypeStr, data: Any) -> Tuple[TypeStr, str]:
 
 
 def parse_basic_type_str(
-    old_normalizer: Callable[[BasicType, TypeStr, Any], Tuple[TypeStr, Any]]
+    old_normalizer: Callable[[BasicType, TypeStr, Any], Tuple[TypeStr, Any]],
 ) -> Callable[[TypeStr, Any], Tuple[TypeStr, Any]]:
     """
     Modifies a normalizer to automatically parse the incoming type string.  If
@@ -283,7 +283,7 @@ def normalize_bytecode(bytecode: Optional[bytes]) -> Union[HexBytes, None]:
 
 
 async def async_abi_ens_resolver(
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     type_str: TypeStr,
     val: Any,
 ) -> Tuple[TypeStr, Any]:

web3/_utils/transactions.py

@@ -1,6 +1,7 @@
 import math
 from typing import (
     TYPE_CHECKING,
+    Any,
     Dict,
     List,
     Literal,
@@ -230,7 +231,7 @@ def assert_valid_transaction_params(transaction_params: TxParams) -> None:
 
 
 def prepare_replacement_transaction(
-    w3: Union["Web3", "AsyncWeb3"],
+    w3: Union["Web3", "AsyncWeb3[Any]"],
     original_transaction: TxData,
     replacement_transaction: TxParams,
     gas_multiplier: float = 1.125,