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

web3/contract/async_contract.py

@@ -103,7 +103,7 @@ if TYPE_CHECKING:
 
 class AsyncContractEvent(BaseContractEvent):
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     @combomethod
     async def get_logs(
@@ -238,14 +238,14 @@ class AsyncContractEvent(BaseContractEvent):
 
 class AsyncContractEvents(BaseContractEvents[AsyncContractEvent]):
     def __init__(
-        self, abi: ABI, w3: "AsyncWeb3", address: Optional[ChecksumAddress] = None
+        self, abi: ABI, w3: "AsyncWeb3[Any]", address: Optional[ChecksumAddress] = None
     ) -> None:
         super().__init__(abi, w3, AsyncContractEvent, address)
 
 
 class AsyncContractFunction(BaseContractFunction):
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     async def call(
         self,
@@ -357,7 +357,7 @@ class AsyncContractFunction(BaseContractFunction):
     @staticmethod
     def get_fallback_function(
         abi: ABI,
-        async_w3: "AsyncWeb3",
+        async_w3: "AsyncWeb3[Any]",
         address: Optional[ChecksumAddress] = None,
     ) -> "AsyncContractFunction":
         if abi and fallback_func_abi_exists(abi):
@@ -373,7 +373,7 @@ class AsyncContractFunction(BaseContractFunction):
     @staticmethod
     def get_receive_function(
         abi: ABI,
-        async_w3: "AsyncWeb3",
+        async_w3: "AsyncWeb3[Any]",
         address: Optional[ChecksumAddress] = None,
     ) -> "AsyncContractFunction":
         if abi and receive_func_abi_exists(abi):
@@ -391,7 +391,7 @@ class AsyncContractFunctions(BaseContractFunctions[AsyncContractFunction]):
     def __init__(
         self,
         abi: ABI,
-        w3: "AsyncWeb3",
+        w3: "AsyncWeb3[Any]",
         address: Optional[ChecksumAddress] = None,
         decode_tuples: Optional[bool] = False,
     ) -> None:
@@ -403,7 +403,7 @@ class AsyncContract(BaseContract):
     caller: "AsyncContractCaller" = None
 
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     #: Instance of :class:`ContractEvents` presenting available Event ABIs
     events: AsyncContractEvents = None
@@ -447,7 +447,7 @@ class AsyncContract(BaseContract):
 
     @classmethod
     def factory(
-        cls, w3: "AsyncWeb3", class_name: Optional[str] = None, **kwargs: Any
+        cls, w3: "AsyncWeb3[Any]", class_name: Optional[str] = None, **kwargs: Any
     ) -> Type[Self]:
         kwargs["w3"] = w3
 
@@ -519,7 +519,7 @@ class AsyncContract(BaseContract):
     def find_functions_by_identifier(
         cls,
         contract_abi: ABI,
-        w3: "AsyncWeb3",
+        w3: "AsyncWeb3[Any]",
         address: ChecksumAddress,
         callable_check: Callable[..., Any],
     ) -> List["AsyncContractFunction"]:
@@ -540,7 +540,7 @@ class AsyncContract(BaseContract):
     def find_events_by_identifier(
         cls,
         contract_abi: ABI,
-        w3: "AsyncWeb3",
+        w3: "AsyncWeb3[Any]",
         address: ChecksumAddress,
         callable_check: Callable[..., Any],
     ) -> List["AsyncContractEvent"]:
@@ -557,12 +557,12 @@ class AsyncContract(BaseContract):
 
 class AsyncContractCaller(BaseContractCaller):
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     def __init__(
         self,
         abi: ABI,
-        w3: "AsyncWeb3",
+        w3: "AsyncWeb3[Any]",
         address: ChecksumAddress,
         transaction: Optional[TxParams] = None,
         block_identifier: BlockIdentifier = None,
@@ -613,7 +613,7 @@ class AsyncContractCaller(BaseContractCaller):
 
 class AsyncContractConstructor(BaseContractConstructor):
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     @combomethod
     async def transact(self, transaction: Optional[TxParams] = None) -> HexBytes:

web3/contract/base_contract.py

@@ -169,7 +169,7 @@ class BaseContractEvent:
     name: str = None
     abi_element_identifier: ABIElementIdentifier = None
     signature: str = None
-    w3: Union["Web3", "AsyncWeb3"] = None
+    w3: Union["Web3", "AsyncWeb3[Any]"] = None
     contract_abi: ABI = None
     abi: ABIEvent = None
     argument_names: Tuple[str, ...] = tuple()
@@ -477,7 +477,7 @@ class BaseContractEvents(Generic[TContractEvent]):
     def __init__(
         self,
         abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         contract_event_type: Type[TContractEvent],
         address: Optional[ChecksumAddress] = None,
     ) -> None:
@@ -569,7 +569,7 @@ class BaseContractFunction:
     name: str = None
     signature: str = None
     abi_element_identifier: ABIElementIdentifier = None
-    w3: Union["Web3", "AsyncWeb3"] = None
+    w3: Union["Web3", "AsyncWeb3[Any]"] = None
     contract_abi: ABI = None
     abi: ABIFunction = None
     transaction: TxParams = None
@@ -894,7 +894,7 @@ class BaseContractFunctions(Generic[TContractFn]):
     def __init__(
         self,
         abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         contract_function_class: Type[TContractFn],
         address: Optional[ChecksumAddress] = None,
         decode_tuples: Optional[bool] = False,
@@ -1000,8 +1000,7 @@ class BaseContract:
     * Deploy a new smart contract using :py:meth:`Contract.constructor.transact()`
     """
 
-    # set during class construction
-    w3: Union["Web3", "AsyncWeb3"] = None
+    w3: Union["Web3", "AsyncWeb3[Any]"] = None
 
     # instance level properties
     address: ChecksumAddress = None
@@ -1286,7 +1285,7 @@ class BaseContract:
     def find_functions_by_identifier(
         cls,
         contract_abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         address: ChecksumAddress,
         callable_check: Callable[..., Any],
     ) -> List[Any]:
@@ -1306,7 +1305,7 @@ class BaseContract:
     def find_events_by_identifier(
         cls,
         contract_abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         address: ChecksumAddress,
         callable_check: Callable[..., Any],
     ) -> List[Any]:
@@ -1325,7 +1324,7 @@ class BaseContract:
     @staticmethod
     def get_fallback_function(
         abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         function_type: Type["BaseContractFunction"],
         address: Optional[ChecksumAddress] = None,
     ) -> "BaseContractFunction":
@@ -1345,7 +1344,7 @@ class BaseContract:
     @staticmethod
     def get_receive_function(
         abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         function_type: Type["BaseContractFunction"],
         address: Optional[ChecksumAddress] = None,
     ) -> "BaseContractFunction":
@@ -1469,7 +1468,7 @@ class BaseContractCaller:
     def __init__(
         self,
         abi: ABI,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         address: ChecksumAddress,
         decode_tuples: Optional[bool] = False,
     ) -> None:
@@ -1542,7 +1541,7 @@ class BaseContractConstructor:
 
     def __init__(
         self,
-        w3: Union["Web3", "AsyncWeb3"],
+        w3: Union["Web3", "AsyncWeb3[Any]"],
         abi: ABI,
         bytecode: HexStr,
         *args: Any,

web3/contract/utils.py

@@ -85,7 +85,7 @@ ACCEPTABLE_EMPTY_STRINGS = ["0x", b"0x", "", b""]
 
 @curry
 def format_contract_call_return_data_curried(
-    async_w3: Union["AsyncWeb3", "Web3"],
+    async_w3: Union["AsyncWeb3[Any]", "Web3"],
     decode_tuples: bool,
     fn_abi: ABICallable,
     abi_element_identifier: ABIElementIdentifier,
@@ -332,7 +332,7 @@ def build_transaction_for_function(
 
 def find_functions_by_identifier(
     contract_abi: ABI,
-    w3: Union["Web3", "AsyncWeb3"],
+    w3: Union["Web3", "AsyncWeb3[Any]"],
     address: ChecksumAddress,
     callable_check: Callable[..., Any],
     function_type: Type[TContractFn],
@@ -376,7 +376,7 @@ def get_function_by_identifier(
 
 def find_events_by_identifier(
     contract_abi: ABI,
-    w3: Union["Web3", "AsyncWeb3"],
+    w3: Union["Web3", "AsyncWeb3[Any]"],
     address: ChecksumAddress,
     callable_check: Callable[..., Any],
     event_type: Type[TContractEvent],
@@ -418,7 +418,7 @@ def get_event_by_identifier(
 
 
 async def async_call_contract_function(
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     address: ChecksumAddress,
     normalizers: Tuple[Callable[..., Any], ...],
     abi_element_identifier: ABIElementIdentifier,
@@ -534,7 +534,7 @@ async def async_call_contract_function(
 
 async def async_transact_with_contract_function(
     address: ChecksumAddress,
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     abi_element_identifier: Optional[ABIElementIdentifier] = None,
     transaction: Optional[TxParams] = None,
     contract_abi: Optional[ABI] = None,
@@ -563,7 +563,7 @@ async def async_transact_with_contract_function(
 
 async def async_estimate_gas_for_function(
     address: ChecksumAddress,
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     abi_element_identifier: Optional[ABIElementIdentifier] = None,
     transaction: Optional[TxParams] = None,
     contract_abi: Optional[ABI] = None,
@@ -597,7 +597,7 @@ async def async_estimate_gas_for_function(
 
 async def async_build_transaction_for_function(
     address: ChecksumAddress,
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     abi_element_identifier: Optional[ABIElementIdentifier] = None,
     transaction: Optional[TxParams] = None,
     contract_abi: Optional[ABI] = None,

web3/eth/async_eth.py

@@ -119,7 +119,7 @@ if TYPE_CHECKING:
 
 class AsyncEth(BaseEth):
     # mypy types
-    w3: "AsyncWeb3"
+    w3: "AsyncWeb3[Any]"
 
     is_async = True
 
@@ -720,19 +720,6 @@ class AsyncEth(BaseEth):
         mungers=[default_root_munger],
     )
 
-    _subscribe_with_args: Method[
-        Callable[
-            [
-                SubscriptionType,
-                Optional[Union[LogsSubscriptionArg, bool]],
-            ],
-            Awaitable[HexStr],
-        ]
-    ] = Method(
-        RPC.eth_subscribe,
-        mungers=[default_root_munger],
-    )
-
     async def subscribe(
         self,
         subscription_type: SubscriptionType,
@@ -745,6 +732,7 @@ class AsyncEth(BaseEth):
         handler: Optional[EthSubscriptionHandler] = None,
         handler_context: Optional[Dict[str, Any]] = None,
         label: Optional[str] = None,
+        parallelize: Optional[bool] = None,
     ) -> HexStr:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
             raise MethodNotSupported(
@@ -757,6 +745,7 @@ class AsyncEth(BaseEth):
             handler=handler,
             handler_context=handler_context or {},
             label=label,
+            parallelize=parallelize,
         )
         return await self.w3.subscription_manager.subscribe(sub)
 

web3/exceptions.py

@@ -353,13 +353,20 @@ class PersistentConnectionClosedOK(PersistentConnectionError):
     """
 
 
-class SubscriptionProcessingFinished(Web3Exception):
+class SubscriptionProcessingFinished(PersistentConnectionError):
     """
     Raised to alert the subscription manager that the processing of subscriptions
     has finished.
     """
 
 
+class SubscriptionHandlerTaskException(TaskNotRunning):
+    """
+    Raised to alert the subscription manager that an exception occurred in the
+    subscription processing task.
+    """
+
+
 class Web3RPCError(Web3Exception):
     """
     Raised when a JSON-RPC response contains an error field.

web3/gas_strategies/time_based.py

@@ -104,7 +104,7 @@ def _get_raw_miner_data(
 
 
 def _aggregate_miner_data(
-    raw_data: Iterable[Tuple[ChecksumAddress, HexBytes, Wei]]
+    raw_data: Iterable[Tuple[ChecksumAddress, HexBytes, Wei]],
 ) -> Iterable[MinerData]:
     data_by_miner = groupby(0, raw_data)
 

web3/main.py

@@ -37,10 +37,12 @@ from typing import (
     Callable,
     Dict,
     Generator,
+    Generic,
     List,
     Optional,
     Sequence,
     Type,
+    TypeVar,
     Union,
     cast,
 )
@@ -210,28 +212,36 @@ class BaseWeb3:
     @staticmethod
     @wraps(to_bytes)
     def to_bytes(
-        primitive: Primitives = None, hexstr: HexStr = None, text: str = None
+        primitive: Optional[Primitives] = None,
+        hexstr: Optional[HexStr] = None,
+        text: Optional[str] = None,
     ) -> bytes:
         return to_bytes(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_int)
     def to_int(
-        primitive: Primitives = None, hexstr: HexStr = None, text: str = None
+        primitive: Optional[Primitives] = None,
+        hexstr: Optional[HexStr] = None,
+        text: Optional[str] = None,
     ) -> int:
         return to_int(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_hex)
     def to_hex(
-        primitive: Primitives = None, hexstr: HexStr = None, text: str = None
+        primitive: Optional[Primitives] = None,
+        hexstr: Optional[HexStr] = None,
+        text: Optional[str] = None,
     ) -> HexStr:
         return to_hex(primitive, hexstr, text)
 
     @staticmethod
     @wraps(to_text)
     def to_text(
-        primitive: Primitives = None, hexstr: HexStr = None, text: str = None
+        primitive: Optional[Primitives] = None,
+        hexstr: Optional[HexStr] = None,
+        text: Optional[str] = None,
     ) -> str:
         return to_text(primitive, hexstr, text)
 
@@ -340,7 +350,7 @@ class BaseWeb3:
         return cls.keccak(hexstr=hex_string)
 
     def attach_modules(
-        self, modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]]
+        self, modules: Dict[str, Union[Type[Module], Sequence[Any]]]
     ) -> None:
         """
         Attach modules to the `Web3` instance.
@@ -359,7 +369,7 @@ class BaseWeb3:
 
 
 def _validate_provider(
-    w3: Union["Web3", "AsyncWeb3"],
+    w3: Union["Web3", "AsyncWeb3[Any]"],
     provider: Optional[Union[BaseProvider, AsyncBaseProvider]],
 ) -> None:
     if provider is not None:
@@ -447,7 +457,10 @@ class Web3(BaseWeb3):
 # -- async -- #
 
 
-class AsyncWeb3(BaseWeb3):
+AsyncProviderT = TypeVar("AsyncProviderT", bound=AsyncBaseProvider)
+
+
+class AsyncWeb3(BaseWeb3, Generic[AsyncProviderT]):
     # mypy Types
     eth: AsyncEth
     net: AsyncNet
@@ -460,7 +473,7 @@ class AsyncWeb3(BaseWeb3):
 
     def __init__(
         self,
-        provider: Optional[AsyncBaseProvider] = None,
+        provider: Optional[AsyncProviderT] = None,
         middleware: Optional[Sequence[Any]] = None,
         modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
         external_modules: Optional[
@@ -486,11 +499,11 @@ class AsyncWeb3(BaseWeb3):
         return await self.provider.is_connected(show_traceback)
 
     @property
-    def provider(self) -> AsyncBaseProvider:
-        return cast(AsyncBaseProvider, self.manager.provider)
+    def provider(self) -> AsyncProviderT:
+        return cast(AsyncProviderT, self.manager.provider)
 
     @provider.setter
-    def provider(self, provider: AsyncBaseProvider) -> None:
+    def provider(self, provider: AsyncProviderT) -> None:
         self.manager.provider = provider
 
     @property

web3/manager.py

@@ -105,7 +105,7 @@ class RequestManager:
 
     def __init__(
         self,
-        w3: Union["AsyncWeb3", "Web3"],
+        w3: Union["AsyncWeb3[Any]", "Web3"],
         provider: Optional[Union["BaseProvider", "AsyncBaseProvider"]] = None,
         middleware: Optional[Sequence[Tuple[Middleware, str]]] = None,
     ) -> None:
@@ -167,7 +167,8 @@ class RequestManager:
     ) -> RPCResponse:
         provider = cast("AsyncBaseProvider", self.provider)
         request_func = await provider.request_func(
-            cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
+            cast("AsyncWeb3[Any]", self.w3),
+            cast("MiddlewareOnion", self.middleware_onion),
         )
         self.logger.debug("Making request. Method: %s", method)
         return await request_func(method, params)
@@ -299,7 +300,7 @@ class RequestManager:
         """
         provider = cast(AsyncJSONBaseProvider, self.provider)
         request_func = await provider.batch_request_func(
-            cast("AsyncWeb3", self.w3),
+            cast("AsyncWeb3[Any]", self.w3),
             cast("MiddlewareOnion", self.middleware_onion),
         )
         # since we add items to the batch without awaiting, we unpack the coroutines
@@ -336,7 +337,7 @@ class RequestManager:
                 "can send batch requests."
             )
         send_func = await self._provider.send_batch_func(
-            cast("AsyncWeb3", self.w3),
+            cast("AsyncWeb3[Any]", self.w3),
             cast("MiddlewareOnion", self.middleware_onion),
         )
         self.logger.debug(
@@ -355,7 +356,7 @@ class RequestManager:
                 "can receive batch requests."
             )
         recv_func = await self._provider.recv_batch_func(
-            cast("AsyncWeb3", self.w3),
+            cast("AsyncWeb3[Any]", self.w3),
             cast("MiddlewareOnion", self.middleware_onion),
         )
         self.logger.debug(
@@ -457,7 +458,7 @@ class RequestManager:
 
     async def send(self, method: RPCEndpoint, params: Any) -> RPCRequest:
         provider = cast(PersistentConnectionProvider, self._provider)
-        async_w3 = cast("AsyncWeb3", self.w3)
+        async_w3 = cast("AsyncWeb3[Any]", self.w3)
         middleware_onion = cast("MiddlewareOnion", self.middleware_onion)
         send_func = await provider.send_func(
             async_w3,
@@ -475,7 +476,7 @@ class RequestManager:
 
     async def recv_for_request(self, rpc_request: RPCRequest) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
-        async_w3 = cast("AsyncWeb3", self.w3)
+        async_w3 = cast("AsyncWeb3[Any]", self.w3)
         middleware_onion = cast("MiddlewareOnion", self.middleware_onion)
         recv_func = await provider.recv_func(
             async_w3,
@@ -523,7 +524,7 @@ class RequestManager:
                 "Only providers that maintain an open, persistent connection "
                 "can listen to streams."
             )
-        async_w3 = cast("AsyncWeb3", self.w3)
+        async_w3 = cast("AsyncWeb3[Any]", self.w3)
 
         if self._provider._message_listener_task is None:
             raise ProviderConnectionError(
@@ -550,13 +551,10 @@ class RequestManager:
                 else:
                     # if not an active sub, skip processing and continue
                     continue
-            except TaskNotRunning:
+            except TaskNotRunning as e:
                 await asyncio.sleep(0)
                 self._provider._handle_listener_task_exceptions()
-                self.logger.error(
-                    "Message listener background task has stopped unexpectedly. "
-                    "Stopping message stream."
-                )
+                self.logger.error("Stopping message stream: %s", e.message)
                 return
 
     async def _process_response(

web3/middleware/__init__.py

@@ -78,7 +78,7 @@ def combine_middleware(
 
 async def async_combine_middleware(
     middleware: Sequence[Middleware],
-    async_w3: "AsyncWeb3",
+    async_w3: "AsyncWeb3[Any]",
     provider_request_fn: AsyncMakeRequestFn,
 ) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
     """

web3/middleware/base.py

@@ -35,9 +35,9 @@ class Web3Middleware:
     but instead inherited from.
     """
 
-    _w3: Union["AsyncWeb3", "Web3"]
+    _w3: Union["AsyncWeb3[Any]", "Web3"]
 
-    def __init__(self, w3: Union["AsyncWeb3", "Web3"]) -> None:
+    def __init__(self, w3: Union["AsyncWeb3[Any]", "Web3"]) -> None:
         self._w3 = w3
 
     def __hash__(self) -> int:
@@ -61,7 +61,7 @@ class Web3Middleware:
         self, make_batch_request: "MakeBatchRequestFn"
     ) -> "MakeBatchRequestFn":
         def middleware(
-            requests_info: List[Tuple["RPCEndpoint", Any]]
+            requests_info: List[Tuple["RPCEndpoint", Any]],
         ) -> Union[List["RPCResponse"], "RPCResponse"]:
             req_processed = [
                 self.request_processor(method, params)
@@ -106,7 +106,7 @@ class Web3Middleware:
         self, make_batch_request: "AsyncMakeBatchRequestFn"
     ) -> "AsyncMakeBatchRequestFn":
         async def middleware(
-            requests_info: List[Tuple["RPCEndpoint", Any]]
+            requests_info: List[Tuple["RPCEndpoint", Any]],
         ) -> Union[List["RPCResponse"], "RPCResponse"]:
             req_processed = [
                 await self.async_request_processor(method, params)
@@ -145,7 +145,7 @@ class Web3MiddlewareBuilder(Web3Middleware):
     @staticmethod
     @abstractmethod
     def build(
-        w3: Union["AsyncWeb3", "Web3"],
+        w3: Union["AsyncWeb3[Any]", "Web3"],
         *args: Any,
         **kwargs: Any,
     ) -> Web3Middleware:

web3/middleware/buffered_gas_estimate.py

@@ -52,7 +52,7 @@ class BufferedGasEstimateMiddleware(Web3Middleware):
             transaction = params[0]
             if "gas" not in transaction:
                 gas_estimate = await async_get_buffered_gas_estimate(
-                    cast("AsyncWeb3", self._w3), transaction
+                    cast("AsyncWeb3[Any]", self._w3), transaction
                 )
                 transaction = assoc(transaction, "gas", hex(gas_estimate))
                 params = (transaction,)

web3/middleware/filter.py

@@ -357,7 +357,8 @@ def block_hashes_in_range(
 
 
 async def async_iter_latest_block(
-    w3: "AsyncWeb3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
+    w3: "AsyncWeb3[Any]",
+    to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[BlockNumber]:
     """
     Returns a generator that dispenses the latest block, if
@@ -394,7 +395,7 @@ async def async_iter_latest_block(
 
 
 async def async_iter_latest_block_ranges(
-    w3: "AsyncWeb3",
+    w3: "AsyncWeb3[Any]",
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
@@ -425,7 +426,7 @@ async def async_iter_latest_block_ranges(
 
 
 async def async_get_logs_multipart(
-    w3: "AsyncWeb3",
+    w3: "AsyncWeb3[Any]",
     start_block: BlockNumber,
     stop_block: BlockNumber,
     address: Union[Address, ChecksumAddress, List[Union[Address, ChecksumAddress]]],
@@ -458,7 +459,7 @@ class AsyncRequestLogs:
 
     def __init__(
         self,
-        w3: "AsyncWeb3",
+        w3: "AsyncWeb3[Any]",
         from_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
         to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
         address: Optional[
@@ -544,7 +545,7 @@ class AsyncRequestLogs:
 
 
 class AsyncRequestBlocks:
-    def __init__(self, w3: "AsyncWeb3") -> None:
+    def __init__(self, w3: "AsyncWeb3[Any]") -> None:
         self.w3 = w3
 
     def __await__(self) -> Generator[Any, None, "AsyncRequestBlocks"]:
@@ -569,7 +570,7 @@ class AsyncRequestBlocks:
 
 
 async def async_block_hashes_in_range(
-    w3: "AsyncWeb3", block_range: Tuple[BlockNumber, BlockNumber]
+    w3: "AsyncWeb3[Any]", block_range: Tuple[BlockNumber, BlockNumber]
 ) -> List[Union[None, Hash32]]:
     from_block, to_block = block_range
     if from_block is None or to_block is None:
@@ -594,7 +595,7 @@ def _simulate_rpc_response_with_result(filter_id: str) -> "RPCResponse":
 
 
 class LocalFilterMiddleware(Web3Middleware):
-    def __init__(self, w3: Union["Web3", "AsyncWeb3"]):
+    def __init__(self, w3: Union["Web3", "AsyncWeb3[Any]"]):
         self.filters: Dict[str, SyncFilter] = {}
         self.async_filters: Dict[str, AsyncFilter] = {}
         self.filter_id_counter = itertools.count()
@@ -660,12 +661,12 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 if method == RPC.eth_newFilter:
                     _filter = await AsyncRequestLogs(
-                        cast("AsyncWeb3", self._w3),
+                        cast("AsyncWeb3[Any]", self._w3),
                         **apply_key_map(FILTER_PARAMS_KEY_MAP, params[0])
                     )
 
                 elif method == RPC.eth_newBlockFilter:
-                    _filter = await AsyncRequestBlocks(cast("AsyncWeb3", self._w3))
+                    _filter = await AsyncRequestBlocks(cast("AsyncWeb3[Any]", self._w3))
 
                 else:
                     raise NotImplementedError(method)