web3 7.14.1__py3-none-any.whl → 8.0.0b1__py3-none-any.whl

web3/providers/persistent/websocket.py

@@ -4,9 +4,6 @@ import logging
 import os
 from typing import (
     Any,
-    Dict,
-    Optional,
-    Union,
 )
 
 from eth_typing import (
@@ -15,13 +12,16 @@ from eth_typing import (
 from toolz import (
     merge,
 )
+from websockets.asyncio.client import (
+    ClientConnection,
+    connect,
+)
 from websockets.exceptions import (
     ConnectionClosedOK,
     WebSocketException,
 )
-from websockets.legacy.client import (
-    WebSocketClientProtocol,
-    connect,
+from websockets.protocol import (
+    State,
 )
 
 from web3.exceptions import (
@@ -59,10 +59,10 @@ class WebSocketProvider(PersistentConnectionProvider):
 
     def __init__(
         self,
-        endpoint_uri: Optional[Union[URI, str]] = None,
-        websocket_kwargs: Optional[Dict[str, Any]] = None,
+        endpoint_uri: URI | str | None = None,
+        websocket_kwargs: dict[str, Any] | None = None,
         # uses binary frames by default
-        use_text_frames: Optional[bool] = False,
+        use_text_frames: bool | None = False,
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
@@ -72,7 +72,7 @@ class WebSocketProvider(PersistentConnectionProvider):
         )
         super().__init__(**kwargs)
         self.use_text_frames = use_text_frames
-        self._ws: Optional[WebSocketClientProtocol] = None
+        self._ws: ClientConnection | None = None
 
         if not any(
             self.endpoint_uri.startswith(prefix)
@@ -119,7 +119,7 @@ class WebSocketProvider(PersistentConnectionProvider):
                 "Connection to websocket has not been initiated for the provider."
             )
 
-        payload: Union[bytes, str] = request_data
+        payload: bytes | str = request_data
         if self.use_text_frames:
             payload = request_data.decode("utf-8")
 
@@ -134,9 +134,12 @@ class WebSocketProvider(PersistentConnectionProvider):
     async def _provider_specific_connect(self) -> None:
         self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
 
+    def is_open(self) -> bool:
+        return self._ws.state == State.OPEN
+
     async def _provider_specific_disconnect(self) -> None:
         # this should remain idempotent
-        if self._ws is not None and not self._ws.closed:
+        if self._ws is not None and self.is_open():
             await self._ws.close()
             self._ws = None
 

web3/providers/rpc/async_rpc.py

@@ -2,12 +2,7 @@ import asyncio
 import logging
 from typing import (
     Any,
-    Dict,
     Iterable,
-    List,
-    Optional,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -60,11 +55,10 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
 
     def __init__(
         self,
-        endpoint_uri: Optional[Union[URI, str]] = None,
-        request_kwargs: Optional[Any] = None,
-        exception_retry_configuration: Optional[
-            Union[ExceptionRetryConfiguration, Empty]
-        ] = empty,
+        endpoint_uri: URI | str | None = None,
+        request_kwargs: Any | None = None,
+        exception_retry_configuration: None
+        | (ExceptionRetryConfiguration | Empty) = empty,
         **kwargs: Any,
     ) -> None:
         self._request_session_manager = HTTPSessionManager()
@@ -99,18 +93,18 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
 
     @exception_retry_configuration.setter
     def exception_retry_configuration(
-        self, value: Union[ExceptionRetryConfiguration, Empty]
+        self, value: ExceptionRetryConfiguration | Empty
     ) -> None:
         self._exception_retry_configuration = value
 
     @to_dict
-    def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
+    def get_request_kwargs(self) -> Iterable[tuple[str, Any]]:
         if "headers" not in self._request_kwargs:
             yield "headers", self.get_request_headers()
         yield from self._request_kwargs.items()
 
     @combomethod
-    def get_request_headers(cls) -> Dict[str, str]:
+    def get_request_headers(cls) -> dict[str, str]:
         if isinstance(cls, AsyncHTTPProvider):
             cls_name = cls.__class__.__name__
         else:
@@ -169,8 +163,8 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         return response
 
     async def make_batch_request(
-        self, batch_requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> Union[List[RPCResponse], RPCResponse]:
+        self, batch_requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCResponse] | RPCResponse:
         self.logger.debug("Making batch request HTTP - uri: `%s`", self.endpoint_uri)
         request_data = self.encode_batch_rpc_request(batch_requests)
         raw_response = await self._request_session_manager.async_make_post_request(
@@ -182,7 +176,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
             # RPC errors return only one response with the error object
             return response
         return sort_batch_response_by_response_ids(
-            cast(List[RPCResponse], sort_batch_response_by_response_ids(response))
+            cast(list[RPCResponse], sort_batch_response_by_response_ids(response))
         )
 
     async def disconnect(self) -> None:

web3/providers/rpc/rpc.py

@@ -3,12 +3,7 @@ import time
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Iterable,
-    List,
-    Optional,
-    Tuple,
-    Union,
     cast,
 )
 
@@ -63,18 +58,15 @@ class HTTPProvider(JSONBaseProvider):
 
     def __init__(
         self,
-        endpoint_uri: Optional[Union[URI, str]] = None,
-        request_kwargs: Optional[Any] = None,
-        session: Optional[Any] = None,
-        exception_retry_configuration: Optional[
-            Union[ExceptionRetryConfiguration, Empty]
-        ] = empty,
+        endpoint_uri: URI | str | None = None,
+        request_kwargs: Any | None = None,
+        session: Any | None = None,
+        exception_retry_configuration: None
+        | (ExceptionRetryConfiguration | Empty) = empty,
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
-        # Pass explicit session to manager so it's used for ALL requests,
-        # regardless of which thread makes them
-        self._request_session_manager = HTTPSessionManager(explicit_session=session)
+        self._request_session_manager = HTTPSessionManager()
 
         if endpoint_uri is None:
             self.endpoint_uri = (
@@ -86,6 +78,11 @@ class HTTPProvider(JSONBaseProvider):
         self._request_kwargs = request_kwargs or {}
         self._exception_retry_configuration = exception_retry_configuration
 
+        if session:
+            self._request_session_manager.cache_and_return_session(
+                self.endpoint_uri, session
+            )
+
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
 
@@ -103,18 +100,18 @@ class HTTPProvider(JSONBaseProvider):
 
     @exception_retry_configuration.setter
     def exception_retry_configuration(
-        self, value: Union[ExceptionRetryConfiguration, Empty]
+        self, value: ExceptionRetryConfiguration | Empty
     ) -> None:
         self._exception_retry_configuration = value
 
     @to_dict
-    def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
+    def get_request_kwargs(self) -> Iterable[tuple[str, Any]]:
         if "headers" not in self._request_kwargs:
             yield "headers", self.get_request_headers()
         yield from self._request_kwargs.items()
 
     @combomethod
-    def get_request_headers(cls) -> Dict[str, str]:
+    def get_request_headers(cls) -> dict[str, str]:
         if isinstance(cls, HTTPProvider):
             cls_name = cls.__class__.__name__
         else:
@@ -174,8 +171,8 @@ class HTTPProvider(JSONBaseProvider):
         return response
 
     def make_batch_request(
-        self, batch_requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> Union[List[RPCResponse], RPCResponse]:
+        self, batch_requests: list[tuple[RPCEndpoint, Any]]
+    ) -> list[RPCResponse] | RPCResponse:
         self.logger.debug("Making batch request HTTP, uri: `%s`", self.endpoint_uri)
         request_data = self.encode_batch_rpc_request(batch_requests)
         raw_response = self._request_session_manager.make_post_request(
@@ -187,5 +184,5 @@ class HTTPProvider(JSONBaseProvider):
             # RPC errors return only one response with the error object
             return response
         return sort_batch_response_by_response_ids(
-            cast(List[RPCResponse], sort_batch_response_by_response_ids(response))
+            cast(list[RPCResponse], sort_batch_response_by_response_ids(response))
         )

web3/providers/rpc/utils.py

@@ -1,6 +1,5 @@
 from typing import (
     Sequence,
-    Type,
 )
 
 from pydantic import (
@@ -72,14 +71,14 @@ def check_if_retry_on_failure(
 
 
 class ExceptionRetryConfiguration(BaseModel):
-    errors: Sequence[Type[BaseException]]
+    errors: Sequence[type[BaseException]]
     retries: int
     backoff_factor: float
     method_allowlist: Sequence[str]
 
     def __init__(
         self,
-        errors: Sequence[Type[BaseException]] = None,
+        errors: Sequence[type[BaseException]] = None,
         retries: int = 5,
         backoff_factor: float = 0.125,
         method_allowlist: Sequence[str] = None,

web3/scripts/release/test_package.py

@@ -5,9 +5,6 @@ import subprocess
 from tempfile import (
     TemporaryDirectory,
 )
-from typing import (
-    Tuple,
-)
 import venv
 
 
@@ -33,7 +30,7 @@ def find_wheel(project_path: Path) -> Path:
 
 
 def install_wheel(
-    venv_path: Path, wheel_path: Path, extras: Tuple[str, ...] = ()
+    venv_path: Path, wheel_path: Path, extras: tuple[str, ...] = ()
 ) -> None:
     if extras:
         extra_suffix = f"[{','.join(extras)}]"

web3/testing.py

@@ -1,7 +1,3 @@
-from typing import (
-    Optional,
-)
-
 from web3._utils.rpc_abi import (
     RPC,
 )
@@ -24,7 +20,7 @@ class Testing(Module):
     def reset(self) -> None:
         self.w3.manager.request_blocking(RPC.evm_reset, [])
 
-    def revert(self, snapshot_idx: Optional[int] = None) -> None:
+    def revert(self, snapshot_idx: int | None = None) -> None:
         if snapshot_idx is None:
             revert_target = self.last_snapshot_idx
         else:

web3/tracing.py

@@ -1,9 +1,5 @@
 from typing import (
     Callable,
-    List,
-    Optional,
-    Tuple,
-    Union,
 )
 
 from eth_typing import (
@@ -53,8 +49,8 @@ class Tracing(Module):
         self._default_block = value
 
     def trace_replay_transaction_munger(
-        self, block_identifier: Union[_Hash32, BlockIdentifier], mode: TraceMode = None
-    ) -> Tuple[Union[BlockIdentifier, _Hash32], TraceMode]:
+        self, block_identifier: _Hash32 | BlockIdentifier, mode: TraceMode = None
+    ) -> tuple[BlockIdentifier | _Hash32, TraceMode]:
         if mode is None:
             mode = ["trace"]
         return (block_identifier, mode)
@@ -64,21 +60,21 @@ class Tracing(Module):
         mungers=[trace_replay_transaction_munger],
     )
 
-    trace_replay_block_transactions: Method[Callable[..., List[BlockTrace]]] = Method(
+    trace_replay_block_transactions: Method[Callable[..., list[BlockTrace]]] = Method(
         RPC.trace_replayBlockTransactions, mungers=[trace_replay_transaction_munger]
     )
 
-    trace_block: Method[Callable[[BlockIdentifier], List[BlockTrace]]] = Method(
+    trace_block: Method[Callable[[BlockIdentifier], list[BlockTrace]]] = Method(
         RPC.trace_block,
         mungers=[default_root_munger],
     )
 
-    trace_filter: Method[Callable[[TraceFilterParams], List[FilterTrace]]] = Method(
+    trace_filter: Method[Callable[[TraceFilterParams], list[FilterTrace]]] = Method(
         RPC.trace_filter,
         mungers=[default_root_munger],
     )
 
-    trace_transaction: Method[Callable[[_Hash32], List[FilterTrace]]] = Method(
+    trace_transaction: Method[Callable[[_Hash32], list[FilterTrace]]] = Method(
         RPC.trace_transaction,
         mungers=[default_root_munger],
     )
@@ -87,8 +83,8 @@ class Tracing(Module):
         self,
         transaction: TxParams,
         mode: TraceMode = None,
-        block_identifier: Optional[BlockIdentifier] = None,
-    ) -> Tuple[TxParams, TraceMode, BlockIdentifier]:
+        block_identifier: BlockIdentifier | None = None,
+    ) -> tuple[TxParams, TraceMode, BlockIdentifier]:
         if mode is None:
             mode = ["trace"]
         if "from" not in transaction and is_checksum_address(
@@ -108,7 +104,7 @@ class Tracing(Module):
 
     def trace_transactions_munger(
         self, raw_transaction: HexStr, mode: TraceMode = None
-    ) -> Tuple[HexStr, TraceMode]:
+    ) -> tuple[HexStr, TraceMode]:
         if mode is None:
             mode = ["trace"]
         return raw_transaction, mode

web3/types.py

@@ -3,14 +3,10 @@ from typing import (
     Any,
     Callable,
     Coroutine,
-    Dict,
-    List,
     Literal,
     NewType,
     Optional,
     Sequence,
-    Tuple,
-    Type,
     TypedDict,
     TypeVar,
     Union,
@@ -58,7 +54,7 @@ BlockParams = Literal["latest", "earliest", "pending", "safe", "finalized"]
 BlockIdentifier = Union[BlockParams, BlockNumber, Hash32, HexStr, HexBytes, int]
 LatestBlockParam = Literal["latest"]
 
-ABIElementIdentifier = Union[str, Type[FallbackFn], Type[ReceiveFn]]
+ABIElementIdentifier = Union[str, type[FallbackFn], type[ReceiveFn]]
 
 # bytes, hexbytes, or hexstr representing a 32 byte hash
 _Hash32 = Union[Hash32, HexBytes, HexStr]
@@ -82,7 +78,7 @@ RPCEndpoint = NewType("RPCEndpoint", str)
 Timestamp = NewType("Timestamp", int)
 Wei = NewType("Wei", int)
 Gwei = NewType("Gwei", int)
-Formatters = Dict[RPCEndpoint, Callable[..., Any]]
+Formatters = dict[RPCEndpoint, Callable[..., Any]]
 
 
 class AccessListEntry(TypedDict):
@@ -95,7 +91,7 @@ AccessList = NewType("AccessList", Sequence[AccessListEntry])
 
 class EventData(TypedDict):
     address: ChecksumAddress
-    args: Dict[str, Any]
+    args: dict[str, Any]
     blockHash: HexBytes
     blockNumber: int
     event: str
@@ -154,9 +150,9 @@ TxData = TypedDict(
 
 class SetCodeAuthorizationParams(TypedDict):
     chainId: int
-    address: Union[Address, ChecksumAddress, str]
+    address: Address | ChecksumAddress | str
     nonce: Nonce
-    yParity: int
+    y_parity: int
     r: int
     s: int
 
@@ -193,7 +189,7 @@ TxParams = TypedDict(
 
 class WithdrawalData(TypedDict):
     index: int
-    validatorIndex: int
+    validator_index: int
     address: ChecksumAddress
     amount: Gwei
 
@@ -217,7 +213,7 @@ class BlockData(TypedDict, total=False):
     stateRoot: HexBytes
     timestamp: Timestamp
     totalDifficulty: int
-    transactions: Union[Sequence[HexBytes], Sequence[TxData]]
+    transactions: Sequence[HexBytes] | Sequence[TxData]
     transactionsRoot: HexBytes
     uncles: Sequence[HexBytes]
     withdrawals: Sequence[WithdrawalData]
@@ -252,7 +248,7 @@ class BlockTypeSubscriptionResponse(SubscriptionResponse):
 
 
 class TransactionTypeSubscriptionResponse(SubscriptionResponse):
-    result: Union[HexBytes, TxData]
+    result: HexBytes | TxData
 
 
 class LogsSubscriptionResponse(SubscriptionResponse):
@@ -267,7 +263,7 @@ class SyncProgress(TypedDict):
 
 
 class SyncingSubscriptionResponse(SubscriptionResponse):
-    result: Union[Literal[False], SyncProgress]
+    result: Literal[False] | SyncProgress
 
 
 class GethSyncingStatus(TypedDict):
@@ -338,23 +334,23 @@ class CreateAccessListResponse(TypedDict):
 
 MakeRequestFn = Callable[[RPCEndpoint, Any], RPCResponse]
 MakeBatchRequestFn = Callable[
-    [List[Tuple[RPCEndpoint, Any]]], Union[List[RPCResponse], RPCResponse]
+    [list[tuple[RPCEndpoint, Any]]], Union[list[RPCResponse], RPCResponse]
 ]
 AsyncMakeRequestFn = Callable[[RPCEndpoint, Any], Coroutine[Any, Any, RPCResponse]]
 AsyncMakeBatchRequestFn = Callable[
-    [List[Tuple[RPCEndpoint, Any]]],
-    Coroutine[Any, Any, Union[List[RPCResponse], RPCResponse]],
+    [list[tuple[RPCEndpoint, Any]]],
+    Coroutine[Any, Any, Union[list[RPCResponse], RPCResponse]],
 ]
 
 
 class FormattersDict(TypedDict, total=False):
-    error_formatters: Optional[Formatters]
-    request_formatters: Optional[Formatters]
-    result_formatters: Optional[Formatters]
+    error_formatters: Formatters | None
+    request_formatters: Formatters | None
+    result_formatters: Formatters | None
 
 
 class FilterParams(TypedDict, total=False):
-    address: Union[Address, ChecksumAddress, List[Address], List[ChecksumAddress]]
+    address: Address | ChecksumAddress | list[Address] | list[ChecksumAddress]
     blockHash: HexBytes
     fromBlock: BlockIdentifier
     toBlock: BlockIdentifier
@@ -362,21 +358,21 @@ class FilterParams(TypedDict, total=False):
 
 
 class FeeHistory(TypedDict):
-    baseFeePerGas: List[Wei]
-    gasUsedRatio: List[float]
+    baseFeePerGas: list[Wei]
+    gasUsedRatio: list[float]
     oldestBlock: BlockNumber
-    reward: List[List[Wei]]
+    reward: list[list[Wei]]
 
 
 class StateOverrideParams(TypedDict, total=False):
-    balance: Optional[Wei]
-    nonce: Optional[int]
-    code: Optional[Union[bytes, HexStr]]
-    state: Optional[Dict[HexStr, HexStr]]
-    stateDiff: Optional[Dict[HexStr, HexStr]]
+    balance: Wei | None
+    nonce: int | None
+    code: bytes | HexStr | None
+    state: dict[HexStr, HexStr] | None
+    stateDiff: dict[HexStr, HexStr] | None
 
 
-StateOverride = Dict[Union[str, Address, ChecksumAddress], StateOverrideParams]
+StateOverride = dict[Union[str, Address, ChecksumAddress], StateOverrideParams]
 
 
 GasPriceStrategy = Union[
@@ -395,7 +391,7 @@ TxReceipt = TypedDict(
         "effectiveGasPrice": Wei,
         "gasUsed": int,
         "from": ChecksumAddress,
-        "logs": List[LogReceipt],
+        "logs": list[LogReceipt],
         "logsBloom": HexBytes,
         "root": HexStr,
         "status": int,
@@ -406,7 +402,7 @@ TxReceipt = TypedDict(
     },
 )
 
-BlockReceipts = List[TxReceipt]
+BlockReceipts = list[TxReceipt]
 
 
 class SignedTx(TypedDict, total=False):
@@ -443,16 +439,16 @@ class NodeInfo(TypedDict):
     ip: str
     listenAddr: str
     name: str
-    ports: Dict[str, int]
-    protocols: Dict[str, Protocol]
+    ports: dict[str, int]
+    protocols: dict[str, Protocol]
 
 
 class Peer(TypedDict, total=False):
     caps: Sequence[str]
     id: HexStr
     name: str
-    network: Dict[str, str]
-    protocols: Dict[str, Protocol]
+    network: dict[str, str]
+    protocols: dict[str, Protocol]
 
 
 class SyncStatus(TypedDict):
@@ -515,13 +511,13 @@ PendingTx = TypedDict(
 
 
 class TxPoolContent(TypedDict, total=False):
-    pending: Dict[ChecksumAddress, Dict[Nonce, List[PendingTx]]]
-    queued: Dict[ChecksumAddress, Dict[Nonce, List[PendingTx]]]
+    pending: dict[ChecksumAddress, dict[Nonce, list[PendingTx]]]
+    queued: dict[ChecksumAddress, dict[Nonce, list[PendingTx]]]
 
 
 class TxPoolInspect(TypedDict, total=False):
-    pending: Dict[ChecksumAddress, Dict[Nonce, str]]
-    queued: Dict[ChecksumAddress, Dict[Nonce, str]]
+    pending: dict[ChecksumAddress, dict[Nonce, str]]
+    queued: dict[ChecksumAddress, dict[Nonce, str]]
 
 
 class TxPoolStatus(TypedDict, total=False):
@@ -538,7 +534,7 @@ class TraceConfig(TypedDict, total=False):
     enableMemory: bool
     enableReturnData: bool
     tracer: str
-    tracerConfig: Dict[str, Any]
+    tracerConfig: dict[str, Any]
     timeout: int
 
 
@@ -574,21 +570,21 @@ class TraceData(TypedDict, total=False):
     balance: int
     nonce: int
     code: str
-    storage: Dict[str, str]
+    storage: dict[str, str]
 
 
 class DiffModeTrace(TypedDict):
-    post: Dict[ChecksumAddress, TraceData]
-    pre: Dict[ChecksumAddress, TraceData]
+    post: dict[ChecksumAddress, TraceData]
+    pre: dict[ChecksumAddress, TraceData]
 
 
-PrestateTrace = Dict[ChecksumAddress, TraceData]
+PrestateTrace = dict[ChecksumAddress, TraceData]
 
 
 # 4byte tracer returns something like:
 # { '0x27dc297e-128' : 1 }
 # which is: { 4byte signature - calldata size : # of occurrences of key }
-FourByteTrace = Dict[str, int]
+FourByteTrace = dict[str, int]
 
 
 class StructLog(TypedDict):
@@ -597,14 +593,14 @@ class StructLog(TypedDict):
     gas: int
     gasCost: int
     depth: int
-    stack: List[HexStr]
+    stack: list[HexStr]
 
 
 class OpcodeTrace(TypedDict, total=False):
     gas: int
     failed: bool
     returnValue: str
-    structLogs: List[StructLog]
+    structLogs: list[StructLog]
 
 
 class BlockStateCallV1(TypedDict):
@@ -637,7 +633,7 @@ class SimulateV1Result(BlockData):
 
 
 class GethWallet(TypedDict):
-    accounts: Sequence[Dict[str, str]]
+    accounts: Sequence[dict[str, str]]
     status: str
     url: str
 
@@ -649,17 +645,17 @@ TContractEvent = TypeVar("TContractEvent", bound="BaseContractEvent")
 
 
 # Tracing types
-BlockTrace = NewType("BlockTrace", Dict[str, Any])
-FilterTrace = NewType("FilterTrace", Dict[str, Any])
+BlockTrace = NewType("BlockTrace", dict[str, Any])
+FilterTrace = NewType("FilterTrace", dict[str, Any])
 TraceMode = Sequence[Literal["trace", "vmTrace", "stateDiff"]]
 
 
 class TraceFilterParams(TypedDict, total=False):
     after: int
     count: int
-    fromAddress: Sequence[Union[Address, ChecksumAddress, ENS]]
+    fromAddress: Sequence[Address | ChecksumAddress | ENS]
     fromBlock: BlockIdentifier
-    toAddress: Sequence[Union[Address, ChecksumAddress, ENS]]
+    toAddress: Sequence[Address | ChecksumAddress | ENS]
     toBlock: BlockIdentifier
 
 
@@ -674,10 +670,7 @@ SubscriptionType = Literal[
 
 
 class LogsSubscriptionArg(TypedDict, total=False):
-    address: Union[
-        Address,
-        ChecksumAddress,
-        ENS,
-        Sequence[Union[Address, ChecksumAddress, ENS]],
-    ]
+    address: (
+        Address | ChecksumAddress | ENS | Sequence[Address | ChecksumAddress | ENS]
+    )
     topics: Sequence[TopicFilter]