web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/providers/persistent/websocket.py

@@ -22,13 +22,12 @@ from websockets.client import (
     connect,
 )
 from websockets.exceptions import (
+    ConnectionClosedOK,
     WebSocketException,
 )
 
-from web3._utils.caching import (
-    async_handle_request_caching,
-)
 from web3.exceptions import (
+    PersistentConnectionClosedOK,
     ProviderConnectionError,
     Web3ValidationError,
 )
@@ -36,7 +35,6 @@ from web3.providers.persistent import (
     PersistentConnectionProvider,
 )
 from web3.types import (
-    RPCEndpoint,
     RPCResponse,
 )
 
@@ -61,9 +59,6 @@ class WebSocketProvider(PersistentConnectionProvider):
     logger = logging.getLogger("web3.providers.WebSocketProvider")
     is_async: bool = True
 
-    _max_connection_retries: int = 5
-    _ws: Optional[WebSocketClientProtocol] = None
-
     def __init__(
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
@@ -71,9 +66,12 @@ class WebSocketProvider(PersistentConnectionProvider):
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
-        self.endpoint_uri = URI(endpoint_uri)
-        if self.endpoint_uri is None:
-            self.endpoint_uri = get_default_endpoint()
+        # initialize the endpoint_uri before calling the super constructor
+        self.endpoint_uri = (
+            URI(endpoint_uri) if endpoint_uri is not None else get_default_endpoint()
+        )
+        super().__init__(**kwargs)
+        self._ws: Optional[WebSocketClientProtocol] = None
 
         if not any(
             self.endpoint_uri.startswith(prefix)
@@ -96,8 +94,6 @@ class WebSocketProvider(PersistentConnectionProvider):
 
         self.websocket_kwargs = merge(DEFAULT_WEBSOCKET_KWARGS, websocket_kwargs or {})
 
-        super().__init__(**kwargs)
-
     def __str__(self) -> str:
         return f"WebSocket connection: {self.endpoint_uri}"
 
@@ -116,52 +112,7 @@ class WebSocketProvider(PersistentConnectionProvider):
                 ) from e
             return False
 
-    async def connect(self) -> None:
-        _connection_attempts = 0
-        _backoff_rate_change = 1.75
-        _backoff_time = 1.75
-
-        while _connection_attempts != self._max_connection_retries:
-            try:
-                _connection_attempts += 1
-                self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
-                self._message_listener_task = asyncio.create_task(
-                    self._message_listener()
-                )
-                break
-            except WebSocketException as e:
-                if _connection_attempts == self._max_connection_retries:
-                    raise ProviderConnectionError(
-                        f"Could not connect to endpoint: {self.endpoint_uri}. "
-                        f"Retries exceeded max of {self._max_connection_retries}."
-                    ) from e
-                self.logger.info(
-                    f"Could not connect to endpoint: {self.endpoint_uri}. Retrying in "
-                    f"{round(_backoff_time, 1)} seconds.",
-                    exc_info=True,
-                )
-                await asyncio.sleep(_backoff_time)
-                _backoff_time *= _backoff_rate_change
-
-    async def disconnect(self) -> None:
-        if self._ws is not None and not self._ws.closed:
-            await self._ws.close()
-            self._ws = None
-            self.logger.debug(
-                f'Successfully disconnected from endpoint: "{self.endpoint_uri}'
-            )
-
-        try:
-            self._message_listener_task.cancel()
-            await self._message_listener_task
-        except (asyncio.CancelledError, StopAsyncIteration):
-            pass
-        self._request_processor.clear_caches()
-
-    @async_handle_request_caching
-    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        request_data = self.encode_rpc_request(method, params)
-
+    async def socket_send(self, request_data: bytes) -> None:
         if self._ws is None:
             raise ProviderConnectionError(
                 "Connection to websocket has not been initiated for the provider."
@@ -171,39 +122,25 @@ class WebSocketProvider(PersistentConnectionProvider):
             self._ws.send(request_data), timeout=self.request_timeout
         )
 
-        current_request_id = json.loads(request_data)["id"]
-        response = await self._get_response_for_request_id(current_request_id)
+    async def socket_recv(self) -> RPCResponse:
+        raw_response = await self._ws.recv()
+        return json.loads(raw_response)
 
-        return response
+    # -- private methods -- #
 
-    async def _message_listener(self) -> None:
-        self.logger.info(
-            "WebSocket listener background task started. Storing all messages in "
-            "appropriate request processor queues / caches to be processed."
-        )
-        while True:
-            # the use of sleep(0) seems to be the most efficient way to yield control
-            # back to the event loop to share the loop with other tasks.
-            await asyncio.sleep(0)
-
-            try:
-                async for raw_message in self._ws:
-                    await asyncio.sleep(0)
-
-                    response = json.loads(raw_message)
-                    subscription = response.get("method") == "eth_subscription"
-                    await self._request_processor.cache_raw_response(
-                        response, subscription=subscription
-                    )
-            except Exception as e:
-                if not self.silence_listener_task_exceptions:
-                    loop = asyncio.get_event_loop()
-                    for task in asyncio.all_tasks(loop=loop):
-                        task.cancel()
-                    raise e
-
-                self.logger.error(
-                    "Exception caught in listener, error logging and keeping "
-                    "listener background task alive."
-                    f"\n    error={e.__class__.__name__}: {e}"
-                )
+    async def _provider_specific_connect(self) -> None:
+        self._ws = await connect(self.endpoint_uri, **self.websocket_kwargs)
+
+    async def _provider_specific_disconnect(self) -> None:
+        # this should remain idempotent
+        if self._ws is not None and not self._ws.closed:
+            await self._ws.close()
+            self._ws = None
+
+    async def _provider_specific_socket_reader(self) -> RPCResponse:
+        try:
+            return await self.socket_recv()
+        except ConnectionClosedOK:
+            raise PersistentConnectionClosedOK(
+                user_message="WebSocket connection received `ConnectionClosedOK`."
+            )

web3/providers/rpc/__init__.py

@@ -4,3 +4,8 @@ from .async_rpc import (
 from .rpc import (
     HTTPProvider,
 )
+
+__all__ = [
+    "AsyncHTTPProvider",
+    "HTTPProvider",
+]

web3/providers/rpc/async_rpc.py

@@ -4,9 +4,11 @@ from typing import (
     Any,
     Dict,
     Iterable,
+    List,
     Optional,
     Tuple,
     Union,
+    cast,
 )
 
 from aiohttp import (
@@ -17,25 +19,31 @@ from eth_typing import (
     URI,
 )
 from eth_utils import (
+    combomethod,
     to_dict,
 )
 
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
 from web3._utils.http import (
     construct_user_agent,
 )
-from web3._utils.request import (
-    async_cache_and_return_session as _async_cache_and_return_session,
-    async_make_post_request,
-    get_default_http_endpoint,
-)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
 )
 
+from ..._utils.batching import (
+    sort_batch_response_by_response_ids,
+)
 from ..._utils.caching import (
     async_handle_request_caching,
 )
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
 from ..async_base import (
     AsyncJSONBaseProvider,
 )
@@ -55,36 +63,63 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
         exception_retry_configuration: Optional[
-            ExceptionRetryConfiguration
-        ] = ExceptionRetryConfiguration(errors=(ClientError, TimeoutError)),
+            Union[ExceptionRetryConfiguration, Empty]
+        ] = empty,
+        **kwargs: Any,
     ) -> None:
+        self._request_session_manager = HTTPSessionManager()
+
         if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
         else:
             self.endpoint_uri = URI(endpoint_uri)
 
         self._request_kwargs = request_kwargs or {}
-        self.exception_retry_configuration = exception_retry_configuration
+        self._exception_retry_configuration = exception_retry_configuration
 
-        super().__init__()
+        super().__init__(**kwargs)
 
     async def cache_async_session(self, session: ClientSession) -> ClientSession:
-        return await _async_cache_and_return_session(self.endpoint_uri, session)
+        return await self._request_session_manager.async_cache_and_return_session(
+            self.endpoint_uri, session
+        )
 
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
 
+    @property
+    def exception_retry_configuration(self) -> ExceptionRetryConfiguration:
+        if isinstance(self._exception_retry_configuration, Empty):
+            self._exception_retry_configuration = ExceptionRetryConfiguration(
+                errors=(ClientError, TimeoutError)
+            )
+        return self._exception_retry_configuration
+
+    @exception_retry_configuration.setter
+    def exception_retry_configuration(
+        self, value: Union[ExceptionRetryConfiguration, Empty]
+    ) -> None:
+        self._exception_retry_configuration = value
+
     @to_dict
     def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
         if "headers" not in self._request_kwargs:
             yield "headers", self.get_request_headers()
-        for key, value in self._request_kwargs.items():
-            yield key, value
+        yield from self._request_kwargs.items()
+
+    @combomethod
+    def get_request_headers(cls) -> Dict[str, str]:
+        if isinstance(cls, AsyncHTTPProvider):
+            cls_name = cls.__class__.__name__
+        else:
+            cls_name = cls.__name__
+        module = cls.__module__
 
-    def get_request_headers(self) -> Dict[str, str]:
         return {
             "Content-Type": "application/json",
-            "User-Agent": construct_user_agent(type(self)),
+            "User-Agent": construct_user_agent(module, cls_name),
         }
 
     async def _make_request(self, method: RPCEndpoint, request_data: bytes) -> bytes:
@@ -100,20 +135,20 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         ):
             for i in range(self.exception_retry_configuration.retries):
                 try:
-                    return await async_make_post_request(
+                    return await self._request_session_manager.async_make_post_request(
                         self.endpoint_uri, request_data, **self.get_request_kwargs()
                     )
                 except tuple(self.exception_retry_configuration.errors):
                     if i < self.exception_retry_configuration.retries - 1:
                         await asyncio.sleep(
-                            self.exception_retry_configuration.backoff_factor
+                            self.exception_retry_configuration.backoff_factor * 2**i
                         )
                         continue
                     else:
                         raise
             return None
         else:
-            return await async_make_post_request(
+            return await self._request_session_manager.async_make_post_request(
                 self.endpoint_uri, request_data, **self.get_request_kwargs()
             )
 
@@ -130,3 +165,23 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
             f"Method: {method}, Response: {response}"
         )
         return response
+
+    async def make_batch_request(
+        self, batch_requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        self.logger.debug(f"Making batch request HTTP - uri: `{self.endpoint_uri}`")
+        request_data = self.encode_batch_rpc_request(batch_requests)
+        raw_response = await self._request_session_manager.async_make_post_request(
+            self.endpoint_uri, request_data, **self.get_request_kwargs()
+        )
+        self.logger.debug("Received batch response HTTP.")
+        responses_list = cast(List[RPCResponse], self.decode_rpc_response(raw_response))
+        return sort_batch_response_by_response_ids(responses_list)
+
+    async def disconnect(self) -> None:
+        cache = self._request_session_manager.session_cache
+        for _, session in cache.items():
+            await session.close()
+        cache.clear()
+
+        self.logger.info(f"Successfully disconnected from: {self.endpoint_uri}")

web3/providers/rpc/rpc.py

@@ -5,35 +5,43 @@ from typing import (
     Any,
     Dict,
     Iterable,
+    List,
     Optional,
     Tuple,
     Union,
+    cast,
 )
 
 from eth_typing import (
     URI,
 )
 from eth_utils import (
+    combomethod,
     to_dict,
 )
 import requests
 
+from web3._utils.empty import (
+    Empty,
+    empty,
+)
 from web3._utils.http import (
     construct_user_agent,
 )
-from web3._utils.request import (
-    cache_and_return_session,
-    get_default_http_endpoint,
-    make_post_request,
-)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
 )
 
+from ..._utils.batching import (
+    sort_batch_response_by_response_ids,
+)
 from ..._utils.caching import (
     handle_request_caching,
 )
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
 from ..base import (
     JSONBaseProvider,
 )
@@ -51,54 +59,75 @@ if TYPE_CHECKING:
 class HTTPProvider(JSONBaseProvider):
     logger = logging.getLogger("web3.providers.HTTPProvider")
     endpoint_uri = None
-
-    _request_args = None
     _request_kwargs = None
 
-    exception_retry_configuration: Optional[ExceptionRetryConfiguration] = None
-
     def __init__(
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
         session: Optional[Any] = None,
-        exception_retry_configuration: Optional[ExceptionRetryConfiguration] = (
-            ExceptionRetryConfiguration(
-                errors=(
-                    ConnectionError,
-                    requests.HTTPError,
-                    requests.Timeout,
-                )
-            )
-        ),
+        exception_retry_configuration: Optional[
+            Union[ExceptionRetryConfiguration, Empty]
+        ] = empty,
+        **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
+        self._request_session_manager = HTTPSessionManager()
+
         if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
         else:
             self.endpoint_uri = URI(endpoint_uri)
 
         self._request_kwargs = request_kwargs or {}
-        self.exception_retry_configuration = exception_retry_configuration
+        self._exception_retry_configuration = exception_retry_configuration
 
         if session:
-            cache_and_return_session(self.endpoint_uri, session)
-
-        super().__init__()
+            self._request_session_manager.cache_and_return_session(
+                self.endpoint_uri, session
+            )
 
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
 
+    @property
+    def exception_retry_configuration(self) -> ExceptionRetryConfiguration:
+        if isinstance(self._exception_retry_configuration, Empty):
+            self._exception_retry_configuration = ExceptionRetryConfiguration(
+                errors=(
+                    ConnectionError,
+                    requests.HTTPError,
+                    requests.Timeout,
+                )
+            )
+        return self._exception_retry_configuration
+
+    @exception_retry_configuration.setter
+    def exception_retry_configuration(
+        self, value: Union[ExceptionRetryConfiguration, Empty]
+    ) -> None:
+        self._exception_retry_configuration = value
+
     @to_dict
     def get_request_kwargs(self) -> Iterable[Tuple[str, Any]]:
         if "headers" not in self._request_kwargs:
             yield "headers", self.get_request_headers()
-        for key, value in self._request_kwargs.items():
-            yield key, value
+        yield from self._request_kwargs.items()
+
+    @combomethod
+    def get_request_headers(cls) -> Dict[str, str]:
+        if isinstance(cls, HTTPProvider):
+            cls_name = cls.__class__.__name__
+        else:
+            cls_name = cls.__name__
+
+        module = cls.__module__
 
-    def get_request_headers(self) -> Dict[str, str]:
         return {
             "Content-Type": "application/json",
-            "User-Agent": construct_user_agent(type(self)),
+            "User-Agent": construct_user_agent(module, cls_name),
         }
 
     def _make_request(self, method: RPCEndpoint, request_data: bytes) -> bytes:
@@ -114,18 +143,20 @@ class HTTPProvider(JSONBaseProvider):
         ):
             for i in range(self.exception_retry_configuration.retries):
                 try:
-                    return make_post_request(
+                    return self._request_session_manager.make_post_request(
                         self.endpoint_uri, request_data, **self.get_request_kwargs()
                     )
                 except tuple(self.exception_retry_configuration.errors) as e:
                     if i < self.exception_retry_configuration.retries - 1:
-                        time.sleep(self.exception_retry_configuration.backoff_factor)
+                        time.sleep(
+                            self.exception_retry_configuration.backoff_factor * 2**i
+                        )
                         continue
                     else:
                         raise e
             return None
         else:
-            return make_post_request(
+            return self._request_session_manager.make_post_request(
                 self.endpoint_uri, request_data, **self.get_request_kwargs()
             )
 
@@ -142,3 +173,15 @@ class HTTPProvider(JSONBaseProvider):
             f"Method: {method}, Response: {response}"
         )
         return response
+
+    def make_batch_request(
+        self, batch_requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        self.logger.debug(f"Making batch request HTTP, uri: `{self.endpoint_uri}`")
+        request_data = self.encode_batch_rpc_request(batch_requests)
+        raw_response = self._request_session_manager.make_post_request(
+            self.endpoint_uri, request_data, **self.get_request_kwargs()
+        )
+        self.logger.debug("Received batch response HTTP.")
+        responses_list = cast(List[RPCResponse], self.decode_rpc_response(raw_response))
+        return sort_batch_response_by_response_ids(responses_list)

web3/providers/rpc/utils.py

@@ -19,9 +19,6 @@ REQUEST_RETRY_ALLOWLIST = [
     "evm",
     "eth_protocolVersion",
     "eth_syncing",
-    "eth_coinbase",
-    "eth_mining",
-    "eth_hashrate",
     "eth_chainId",
     "eth_gasPrice",
     "eth_accounts",
@@ -58,15 +55,6 @@ REQUEST_RETRY_ALLOWLIST = [
     "eth_sign",
     "eth_signTypedData",
     "eth_sendRawTransaction",
-    "personal_importRawKey",
-    "personal_newAccount",
-    "personal_listAccounts",
-    "personal_listWallets",
-    "personal_lockAccount",
-    "personal_unlockAccount",
-    "personal_ecRecover",
-    "personal_sign",
-    "personal_signTypedData",
 ]
 
 
@@ -93,7 +81,7 @@ class ExceptionRetryConfiguration(BaseModel):
         self,
         errors: Sequence[Type[BaseException]] = None,
         retries: int = 5,
-        backoff_factor: float = 0.5,
+        backoff_factor: float = 0.125,
         method_allowlist: Sequence[str] = None,
     ):
         super().__init__(

web3/scripts/install_pre_releases.py

@@ -0,0 +1,33 @@
+"""
+The goal of this script is to install the latest versions, including pre-releases, for
+libraries that we maintain (and therefore control the release process) during our CI
+runs. This helps us test pre-releases before they cause any issues once stable versions
+are released.
+"""
+
+import subprocess
+import sys
+
+ETHEREUM_LIBRARIES = [
+    "eth-account",
+    "eth-abi",
+    "eth-account",
+    "eth-hash[pycryptodome]",
+    "eth-typing",
+    "eth-utils",
+    "hexbytes",
+    "eth-tester[py-evm]",
+    "py-geth",
+]
+
+
+def install_eth_pre_releases() -> None:
+    for lib in ETHEREUM_LIBRARIES:
+        print(f"Installing {lib} with `--pre` and `-U`")
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "--pre", "-U", lib]
+        )
+
+
+if __name__ == "__main__":
+    install_eth_pre_releases()

web3/scripts/parse_pygeth_version.py

@@ -0,0 +1,16 @@
+import re
+
+
+def get_pygeth_version() -> str:
+    with open("setup.py") as f:
+        setup_contents = f.read()
+    version_match = re.search(r"py-geth\s*([><=~!]+)\s*([\d.]+)", setup_contents)
+    if version_match:
+        return "".join(version_match.group(1, 2))
+    else:
+        raise ValueError("py-geth not found in setup.py")
+
+
+if __name__ == "__main__":
+    version = get_pygeth_version()
+    print(version)

web3/testing.py

@@ -12,21 +12,21 @@ from web3.module import (
 
 class Testing(Module):
     def timeTravel(self, timestamp: int) -> None:
-        return self.w3.manager.request_blocking(RPC.testing_timeTravel, [timestamp])
+        self.w3.manager.request_blocking(RPC.testing_timeTravel, [timestamp])
 
     def mine(self, num_blocks: int = 1) -> None:
-        return self.w3.manager.request_blocking(RPC.evm_mine, [num_blocks])
+        self.w3.manager.request_blocking(RPC.evm_mine, [num_blocks])
 
     def snapshot(self) -> int:
         self.last_snapshot_idx = self.w3.manager.request_blocking(RPC.evm_snapshot, [])
         return self.last_snapshot_idx
 
     def reset(self) -> None:
-        return self.w3.manager.request_blocking(RPC.evm_reset, [])
+        self.w3.manager.request_blocking(RPC.evm_reset, [])
 
     def revert(self, snapshot_idx: Optional[int] = None) -> None:
         if snapshot_idx is None:
             revert_target = self.last_snapshot_idx
         else:
             revert_target = snapshot_idx
-        return self.w3.manager.request_blocking(RPC.evm_revert, [revert_target])
+        self.w3.manager.request_blocking(RPC.evm_revert, [revert_target])

web3/tracing.py

@@ -53,10 +53,10 @@ class Tracing(Module):
         self._default_block = value
 
     def trace_replay_transaction_munger(
-        self,
-        block_identifier: Union[_Hash32, BlockIdentifier],
-        mode: TraceMode = ["trace"],
+        self, block_identifier: Union[_Hash32, BlockIdentifier], mode: TraceMode = None
     ) -> Tuple[Union[BlockIdentifier, _Hash32], TraceMode]:
+        if mode is None:
+            mode = ["trace"]
         return (block_identifier, mode)
 
     trace_replay_transaction: Method[Callable[..., BlockTrace]] = Method(
@@ -86,9 +86,11 @@ class Tracing(Module):
     def trace_call_munger(
         self,
         transaction: TxParams,
-        mode: TraceMode = ["trace"],
+        mode: TraceMode = None,
         block_identifier: Optional[BlockIdentifier] = None,
     ) -> Tuple[TxParams, TraceMode, BlockIdentifier]:
+        if mode is None:
+            mode = ["trace"]
         if "from" not in transaction and is_checksum_address(
             self.w3.eth.default_account
         ):
@@ -105,8 +107,10 @@ class Tracing(Module):
     )
 
     def trace_transactions_munger(
-        self, raw_transaction: HexStr, mode: TraceMode = ["trace"]
+        self, raw_transaction: HexStr, mode: TraceMode = None
     ) -> Tuple[HexStr, TraceMode]:
+        if mode is None:
+            mode = ["trace"]
         return raw_transaction, mode
 
     trace_raw_transaction: Method[Callable[..., BlockTrace]] = Method(