web3 7.6.1__py3-none-any.whl → 7.8.0__py3-none-any.whl

web3/providers/async_base.py

@@ -6,6 +6,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    Dict,
     List,
     Optional,
     Set,
@@ -43,6 +44,7 @@ from web3.middleware.base import (
 )
 from web3.types import (
     RPCEndpoint,
+    RPCRequest,
     RPCResponse,
 )
 from web3.utils import (
@@ -75,7 +77,8 @@ class AsyncBaseProvider:
 
     _is_batching: bool = False
     _batch_request_func_cache: Tuple[
-        Tuple[Middleware, ...], Callable[..., Coroutine[Any, Any, List[RPCResponse]]]
+        Tuple[Middleware, ...],
+        Callable[..., Coroutine[Any, Any, Union[List[RPCResponse], RPCResponse]]],
     ] = (None, None)
 
     is_async = True
@@ -83,10 +86,6 @@ class AsyncBaseProvider:
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
-    # request caching
-    _request_cache: SimpleCache
-    _request_cache_lock: asyncio.Lock = asyncio.Lock()
-
     def __init__(
         self,
         cache_allowed_requests: bool = False,
@@ -96,6 +95,8 @@ class AsyncBaseProvider:
         ] = empty,
     ) -> None:
         self._request_cache = SimpleCache(1000)
+        self._request_cache_lock: asyncio.Lock = asyncio.Lock()
+
         self.cache_allowed_requests = cache_allowed_requests
         self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
         self.request_cache_validation_threshold = request_cache_validation_threshold
@@ -119,7 +120,7 @@ class AsyncBaseProvider:
 
     async def batch_request_func(
         self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
-    ) -> Callable[..., Coroutine[Any, Any, List[RPCResponse]]]:
+    ) -> Callable[..., Coroutine[Any, Any, Union[List[RPCResponse], RPCResponse]]]:
         middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._batch_request_func_cache[0]
@@ -141,8 +142,8 @@ class AsyncBaseProvider:
 
     async def make_batch_request(
         self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
-        raise NotImplementedError("Only AsyncHTTPProvider supports this method")
+    ) -> Union[List[RPCResponse], RPCResponse]:
+        raise NotImplementedError("Providers must implement this method")
 
     async def is_connected(self, show_traceback: bool = False) -> bool:
         raise NotImplementedError("Providers must implement this method")
@@ -172,23 +173,31 @@ class AsyncBaseProvider:
 
 
 class AsyncJSONBaseProvider(AsyncBaseProvider):
-    logger = logging.getLogger("web3.providers.async_base.AsyncJSONBaseProvider")
-
     def __init__(self, **kwargs: Any) -> None:
-        self.request_counter = itertools.count()
         super().__init__(**kwargs)
+        self.request_counter = itertools.count()
 
-    def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
+    def form_request(self, method: RPCEndpoint, params: Any = None) -> RPCRequest:
         request_id = next(self.request_counter)
         rpc_dict = {
+            "id": request_id,
             "jsonrpc": "2.0",
             "method": method,
             "params": params or [],
-            "id": request_id,
         }
-        encoded = FriendlyJsonSerde().json_encode(rpc_dict, cls=Web3JsonEncoder)
+        return cast(RPCRequest, rpc_dict)
+
+    @staticmethod
+    def encode_rpc_dict(rpc_dict: RPCRequest) -> bytes:
+        encoded = FriendlyJsonSerde().json_encode(
+            cast(Dict[str, Any], rpc_dict), cls=Web3JsonEncoder
+        )
         return to_bytes(text=encoded)
 
+    def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
+        rpc_dict = self.form_request(method, params)
+        return self.encode_rpc_dict(rpc_dict)
+
     @staticmethod
     def decode_rpc_response(raw_response: bytes) -> RPCResponse:
         text_response = str(

web3/providers/base.py

@@ -66,10 +66,6 @@ class BaseProvider:
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
-    # request caching
-    _request_cache: SimpleCache
-    _request_cache_lock: threading.Lock = threading.Lock()
-
     def __init__(
         self,
         cache_allowed_requests: bool = False,
@@ -79,6 +75,8 @@ class BaseProvider:
         ] = empty,
     ) -> None:
         self._request_cache = SimpleCache(1000)
+        self._request_cache_lock: threading.Lock = threading.Lock()
+
         self.cache_allowed_requests = cache_allowed_requests
         self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
         self.request_cache_validation_threshold = request_cache_validation_threshold
@@ -120,12 +118,12 @@ class JSONBaseProvider(BaseProvider):
 
     _is_batching: bool = False
     _batch_request_func_cache: Tuple[
-        Tuple[Middleware, ...], Callable[..., List[RPCResponse]]
+        Tuple[Middleware, ...], Callable[..., Union[List[RPCResponse], RPCResponse]]
     ] = (None, None)
 
     def __init__(self, **kwargs: Any) -> None:
-        self.request_counter = itertools.count()
         super().__init__(**kwargs)
+        self.request_counter = itertools.count()
 
     def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
         rpc_dict = {
@@ -170,7 +168,7 @@ class JSONBaseProvider(BaseProvider):
 
     def batch_request_func(
         self, w3: "Web3", middleware_onion: MiddlewareOnion
-    ) -> Callable[..., List[RPCResponse]]:
+    ) -> Callable[..., Union[List[RPCResponse], RPCResponse]]:
         middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._batch_request_func_cache[0]
@@ -201,5 +199,5 @@ class JSONBaseProvider(BaseProvider):
 
     def make_batch_request(
         self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
+    ) -> Union[List[RPCResponse], RPCResponse]:
         raise NotImplementedError("Providers must implement this method")

web3/providers/ipc.py

@@ -116,14 +116,15 @@ def get_default_ipc_path() -> str:
 
 
 def get_dev_ipc_path() -> str:
-    if os.environ.get("WEB3_PROVIDER_URI", ""):
-        return os.environ.get("WEB3_PROVIDER_URI")
+    web3_provider_uri = os.environ.get("WEB3_PROVIDER_URI", "")
+    if web3_provider_uri and "geth.ipc" in web3_provider_uri:
+        return web3_provider_uri
 
-    elif sys.platform == "darwin":
-        tmpdir = os.environ.get("TMPDIR", "")
+    elif sys.platform == "darwin" or sys.platform.startswith("linux"):
+        tmpdir = os.environ.get("TMPDIR", "/tmp")
         return os.path.expanduser(os.path.join(tmpdir, "geth.ipc"))
 
-    elif sys.platform.startswith("linux") or sys.platform.startswith("freebsd"):
+    elif sys.platform.endswith("freebsd"):
         return os.path.expanduser(os.path.join("/tmp", "geth.ipc"))
 
     elif sys.platform == "win32":
@@ -146,6 +147,7 @@ class IPCProvider(JSONBaseProvider):
         timeout: int = 30,
         **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
         if ipc_path is None:
             self.ipc_path = get_default_ipc_path()
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
@@ -156,7 +158,6 @@ class IPCProvider(JSONBaseProvider):
         self.timeout = timeout
         self._lock = threading.Lock()
         self._socket = PersistantSocket(self.ipc_path)
-        super().__init__(**kwargs)
 
     def __str__(self) -> str:
         return f"<{self.__class__.__name__} {self.ipc_path}>"

web3/providers/legacy_websocket.py

@@ -102,6 +102,7 @@ class LegacyWebSocketProvider(JSONBaseProvider):
         websocket_timeout: int = DEFAULT_WEBSOCKET_TIMEOUT,
         **kwargs: Any,
     ) -> None:
+        super().__init__(**kwargs)
         self.endpoint_uri = URI(endpoint_uri)
         self.websocket_timeout = websocket_timeout
         if self.endpoint_uri is None:
@@ -120,7 +121,6 @@ class LegacyWebSocketProvider(JSONBaseProvider):
                     f"in websocket_kwargs, found: {found_restricted_keys}"
                 )
         self.conn = PersistentWebSocket(self.endpoint_uri, websocket_kwargs)
-        super().__init__(**kwargs)
 
     def __str__(self) -> str:
         return f"WS connection {self.endpoint_uri}"

web3/providers/persistent/async_ipc.py

@@ -14,6 +14,7 @@ from typing import (
 )
 
 from web3.types import (
+    RPCEndpoint,
     RPCResponse,
 )
 
@@ -59,15 +60,15 @@ class AsyncIPCProvider(PersistentConnectionProvider):
         # `PersistentConnectionProvider` kwargs can be passed through
         **kwargs: Any,
     ) -> None:
+        # initialize the ipc_path before calling the super constructor
         if ipc_path is None:
             self.ipc_path = get_default_ipc_path()
         elif isinstance(ipc_path, str) or isinstance(ipc_path, Path):
             self.ipc_path = str(Path(ipc_path).expanduser().resolve())
         else:
             raise Web3TypeError("ipc_path must be of type string or pathlib.Path")
-
-        self.read_buffer_limit = read_buffer_limit
         super().__init__(**kwargs)
+        self.read_buffer_limit = read_buffer_limit
 
     def __str__(self) -> str:
         return f"<{self.__class__.__name__} {self.ipc_path}>"
@@ -77,7 +78,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             return False
 
         try:
-            await self.make_request("web3_clientVersion", [])
+            await self.make_request(RPCEndpoint("web3_clientVersion"), [])
             return True
         except (OSError, ProviderConnectionError) as e:
             if show_traceback:
@@ -139,6 +140,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
         )
 
     async def _provider_specific_disconnect(self) -> None:
+        # this should remain idempotent
         if self._writer and not self._writer.is_closing():
             self._writer.close()
             await self._writer.wait_closed()

web3/providers/persistent/persistent.py

@@ -3,10 +3,13 @@ from abc import (
     abstractmethod,
 )
 import asyncio
-import json
 import logging
+import signal
 from typing import (
+    TYPE_CHECKING,
     Any,
+    Callable,
+    Coroutine,
     List,
     Optional,
     Tuple,
@@ -24,9 +27,12 @@ from web3._utils.batching import (
     sort_batch_response_by_response_ids,
 )
 from web3._utils.caching import (
-    async_handle_request_caching,
     generate_cache_key,
 )
+from web3._utils.caching.caching_utils import (
+    async_handle_recv_caching,
+    async_handle_send_caching,
+)
 from web3.exceptions import (
     PersistentConnectionClosedOK,
     ProviderConnectionError,
@@ -43,9 +49,15 @@ from web3.providers.persistent.request_processor import (
 from web3.types import (
     RPCEndpoint,
     RPCId,
+    RPCRequest,
     RPCResponse,
 )
 
+if TYPE_CHECKING:
+    from web3 import AsyncWeb3  # noqa: F401
+    from web3.middleware.base import MiddlewareOnion  # noqa: F401
+
+
 DEFAULT_PERSISTENT_CONNECTION_TIMEOUT = 30.0
 
 
@@ -53,11 +65,14 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
     logger = logging.getLogger("web3.providers.PersistentConnectionProvider")
     has_persistent_connection = True
 
-    _request_processor: RequestProcessor
-    _message_listener_task: Optional["asyncio.Task[None]"] = None
-    _listen_event: asyncio.Event = asyncio.Event()
-
-    _batch_request_counter: Optional[int] = None
+    _send_func_cache: Tuple[int, Callable[..., Coroutine[Any, Any, RPCRequest]]] = (
+        None,
+        None,
+    )
+    _recv_func_cache: Tuple[int, Callable[..., Coroutine[Any, Any, RPCResponse]]] = (
+        None,
+        None,
+    )
 
     def __init__(
         self,
@@ -72,9 +87,63 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             self,
             subscription_response_queue_size=subscription_response_queue_size,
         )
+        self._message_listener_task: Optional["asyncio.Task[None]"] = None
+        self._batch_request_counter: Optional[int] = None
+        self._listen_event: asyncio.Event = asyncio.Event()
+        self._max_connection_retries = max_connection_retries
+
         self.request_timeout = request_timeout
         self.silence_listener_task_exceptions = silence_listener_task_exceptions
-        self._max_connection_retries = max_connection_retries
+
+    async def send_func(
+        self, async_w3: "AsyncWeb3", middleware_onion: "MiddlewareOnion"
+    ) -> Callable[..., Coroutine[Any, Any, RPCRequest]]:
+        """
+        Cache the middleware chain for `send`.
+        """
+        middleware = middleware_onion.as_tuple_of_middleware()
+        cache_key = hash(tuple(id(mw) for mw in middleware))
+
+        if cache_key != self._send_func_cache[0]:
+
+            async def send_function(method: RPCEndpoint, params: Any) -> RPCRequest:
+                for mw in middleware:
+                    initialized = mw(async_w3)
+                    method, params = await initialized.async_request_processor(
+                        method, params
+                    )
+
+                return await self.send_request(method, params)
+
+            self._send_func_cache = (cache_key, send_function)
+
+        return self._send_func_cache[1]
+
+    async def recv_func(
+        self, async_w3: "AsyncWeb3", middleware_onion: "MiddlewareOnion"
+    ) -> Any:
+        """
+        Cache and compose the middleware stack for `recv`.
+        """
+        middleware = middleware_onion.as_tuple_of_middleware()
+        cache_key = hash(tuple(id(mw) for mw in middleware))
+
+        if cache_key != self._recv_func_cache[0]:
+
+            async def recv_function(rpc_request: RPCRequest) -> RPCResponse:
+                # first, retrieve the response
+                response = await self.recv_for_request(rpc_request)
+                method = rpc_request["method"]
+                for mw in reversed(middleware):
+                    initialized = mw(async_w3)
+                    response = await initialized.async_response_processor(
+                        method, response
+                    )
+                return response
+
+            self._recv_func_cache = (cache_key, recv_function)
+
+        return self._recv_func_cache[1]
 
     def get_endpoint_uri_or_ipc_path(self) -> str:
         if hasattr(self, "endpoint_uri"):
@@ -124,6 +193,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
                 _backoff_time *= _backoff_rate_change
 
     async def disconnect(self) -> None:
+        # this should remain idempotent
         try:
             if self._message_listener_task:
                 self._message_listener_task.cancel()
@@ -140,15 +210,23 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
             f"Successfully disconnected from: {self.get_endpoint_uri_or_ipc_path()}"
         )
 
-    @async_handle_request_caching
-    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        request_data = self.encode_rpc_request(method, params)
-        await self.socket_send(request_data)
+    @async_handle_send_caching
+    async def send_request(self, method: RPCEndpoint, params: Any) -> RPCRequest:
+        request_dict = self.form_request(method, params)
+        await self.socket_send(self.encode_rpc_dict(request_dict))
+        return request_dict
 
-        current_request_id = json.loads(request_data)["id"]
-        response = await self._get_response_for_request_id(current_request_id)
+    @async_handle_recv_caching
+    async def recv_for_request(self, rpc_request: RPCRequest) -> RPCResponse:
+        return await self._get_response_for_request_id(rpc_request["id"])
 
-        return response
+    async def make_request(
+        self,
+        method: RPCEndpoint,
+        params: Any,
+    ) -> RPCResponse:
+        rpc_request = await self.send_request(method, params)
+        return await self.recv_for_request(rpc_request)
 
     async def make_batch_request(
         self, requests: List[Tuple[RPCEndpoint, Any]]
@@ -184,19 +262,45 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
         raise NotImplementedError("Must be implemented by subclasses")
 
     async def _provider_specific_disconnect(self) -> None:
+        # this method should be idempotent
         raise NotImplementedError("Must be implemented by subclasses")
 
     async def _provider_specific_socket_reader(self) -> RPCResponse:
         raise NotImplementedError("Must be implemented by subclasses")
 
+    def _set_signal_handlers(self) -> None:
+        def extended_handler(sig: int, frame: Any, existing_handler: Any) -> None:
+            loop = asyncio.get_event_loop()
+
+            # invoke the existing handler, if callable
+            if callable(existing_handler):
+                existing_handler(sig, frame)
+            loop.create_task(self.disconnect())
+
+        existing_sigint_handler = signal.getsignal(signal.SIGINT)
+        existing_sigterm_handler = signal.getsignal(signal.SIGTERM)
+
+        # extend the existing signal handlers to include the disconnect method
+        signal.signal(
+            signal.SIGINT,
+            lambda sig, frame: extended_handler(sig, frame, existing_sigint_handler),
+        )
+        signal.signal(
+            signal.SIGTERM,
+            lambda sig, frame: extended_handler(sig, frame, existing_sigterm_handler),
+        )
+
     def _message_listener_callback(
         self, message_listener_task: "asyncio.Task[None]"
     ) -> None:
-        # Puts a `TaskNotRunning` in the queue to signal the end of the listener task
-        # to any running subscription streams that are awaiting a response.
+        # Puts a `TaskNotRunning` in appropriate queues to signal the end of the
+        # listener task to any listeners relying on the queues.
         self._request_processor._subscription_response_queue.put_nowait(
             TaskNotRunning(message_listener_task)
         )
+        self._request_processor._handler_subscription_queue.put_nowait(
+            TaskNotRunning(message_listener_task)
+        )
 
     async def _message_listener(self) -> None:
         self.logger.info(

web3/providers/persistent/persistent_connection.py

@@ -2,9 +2,12 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Dict,
+    Union,
+    cast,
 )
 
 from web3.types import (
+    FormattedEthSubscriptionResponse,
     RPCEndpoint,
     RPCResponse,
 )
@@ -16,6 +19,9 @@ if TYPE_CHECKING:
     from web3.manager import (  # noqa: F401
         _AsyncPersistentMessageStream,
     )
+    from web3.providers.persistent import (  # noqa: F401
+        PersistentConnectionProvider,
+    )
 
 
 class PersistentConnection:
@@ -26,6 +32,7 @@ class PersistentConnection:
 
     def __init__(self, w3: "AsyncWeb3"):
         self._manager = w3.manager
+        self.provider = cast("PersistentConnectionProvider", self._manager.provider)
 
     @property
     def subscriptions(self) -> Dict[str, Any]:
@@ -47,10 +54,10 @@ class PersistentConnection:
         :param method: The RPC method, e.g. `eth_getBlockByNumber`.
         :param params: The RPC method parameters, e.g. `["0x1337", False]`.
 
-        :return: The processed response from the persistent connection.
+        :return: The unprocessed response from the persistent connection.
         :rtype: RPCResponse
         """
-        return await self._manager.socket_request(method, params)
+        return await self.provider.make_request(method, params)
 
     async def send(self, method: RPCEndpoint, params: Any) -> None:
         """
@@ -63,14 +70,14 @@ class PersistentConnection:
         """
         await self._manager.send(method, params)
 
-    async def recv(self) -> RPCResponse:
+    async def recv(self) -> Union[RPCResponse, FormattedEthSubscriptionResponse]:
         """
         Receive the next unprocessed response for a request from the persistent
         connection.
 
         :return: The next unprocessed response for a request from the persistent
                  connection.
-        :rtype: RPCResponse
+        :rtype: Union[RPCResponse, FormattedEthSubscriptionResponse]
         """
         return await self._manager.recv()