web3 7.0.0b7__tar.gz → 7.0.0b8__tar.gz

{web3-7.0.0b7/web3.egg-info → web3-7.0.0b8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b7
+Version: 7.0.0b8
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -80,7 +80,9 @@ Requires-Dist: pytest>=7.0.0; extra == "test"
 [![Python versions](https://img.shields.io/pypi/pyversions/web3.svg)](https://pypi.python.org/pypi/web3)
 [![Docs build](https://readthedocs.org/projects/web3py/badge/?version=latest)](https://web3py.readthedocs.io/en/latest/?badge=latest)
 
-A Python library for interacting with Ethereum.
+## A Python Library for Interacting with Ethereum
+
+web3.py allows you to interact with the Ethereum blockchain using Python, enabling you to build decentralized applications, interact with smart contracts, and much more.
 
 - Python 3.8+ support
 
@@ -95,7 +97,7 @@ ______________________________________________________________________
 
 For additional guides, examples, and APIs, see the [documentation](https://web3py.readthedocs.io/en/latest/).
 
-## Want to help?
+## Want to Help?
 
 Want to file a bug, contribute some code, or improve documentation? Excellent! Read up on our
 guidelines for [contributing](https://web3py.readthedocs.io/en/latest/contributing.html),
@@ -104,4 +106,6 @@ then check out issues that are labeled
 
 ______________________________________________________________________
 
-#### Questions on implementation or usage? Join the conversation on [discord](https://discord.gg/GHryRvPB84).
+## Questions on Implementation or Usage?
+
+Join the conversation in the Ethereum Python Community [Discord](https://discord.gg/GHryRvPB84).

{web3-7.0.0b7 → web3-7.0.0b8}/README.md

@@ -6,7 +6,9 @@
 [![Python versions](https://img.shields.io/pypi/pyversions/web3.svg)](https://pypi.python.org/pypi/web3)
 [![Docs build](https://readthedocs.org/projects/web3py/badge/?version=latest)](https://web3py.readthedocs.io/en/latest/?badge=latest)
 
-A Python library for interacting with Ethereum.
+## A Python Library for Interacting with Ethereum
+
+web3.py allows you to interact with the Ethereum blockchain using Python, enabling you to build decentralized applications, interact with smart contracts, and much more.
 
 - Python 3.8+ support
 
@@ -21,7 +23,7 @@ ______________________________________________________________________
 
 For additional guides, examples, and APIs, see the [documentation](https://web3py.readthedocs.io/en/latest/).
 
-## Want to help?
+## Want to Help?
 
 Want to file a bug, contribute some code, or improve documentation? Excellent! Read up on our
 guidelines for [contributing](https://web3py.readthedocs.io/en/latest/contributing.html),
@@ -30,4 +32,6 @@ then check out issues that are labeled
 
 ______________________________________________________________________
 
-#### Questions on implementation or usage? Join the conversation on [discord](https://discord.gg/GHryRvPB84).
+## Questions on Implementation or Usage?
+
+Join the conversation in the Ethereum Python Community [Discord](https://discord.gg/GHryRvPB84).

{web3-7.0.0b7 → web3-7.0.0b8}/setup.py

@@ -51,7 +51,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. Use `make bump`, as described in readme
-    version="7.0.0-beta.7",
+    version="7.0.0-beta.8",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.0.0b7 → web3-7.0.0b8}/tests/core/eth-module/test_transactions.py

@@ -318,12 +318,8 @@ def test_get_transaction_formatters(w3, request_mocker):
                     {
                         "address": checksummed_addr,
                         "storageKeys": [
-                            HexBytes(
-                                "0x0000000000000000000000000000000000000000000000000000000000000032"  # noqa: E501
-                            ),
-                            HexBytes(
-                                "0x0000000000000000000000000000000000000000000000000000000000000036"  # noqa: E501
-                            ),
+                            "0x0000000000000000000000000000000000000000000000000000000000000032",  # noqa: E501
+                            "0x0000000000000000000000000000000000000000000000000000000000000036",  # noqa: E501
                         ],
                     }
                 ),

{web3-7.0.0b7 → web3-7.0.0b8}/tests/core/providers/test_websocket_provider.py

@@ -12,6 +12,7 @@ from eth_utils import (
 )
 from websockets import (
     ConnectionClosed,
+    ConnectionClosedOK,
 )
 
 from web3 import (
@@ -365,3 +366,16 @@ async def test_async_iterator_pattern_exception_handling_for_subscriptions():
             pytest.fail("Expected `ConnectionClosed` exception.")
 
         assert iterations == 3
+
+
+@pytest.mark.asyncio
+async def test_connection_closed_ok_breaks_message_iteration():
+    with patch(
+        "web3.providers.persistent.websocket.connect",
+        new=lambda *_1, **_2: WebSocketMessageStreamMock(
+            raise_exception=ConnectionClosedOK(None, None)
+        ),
+    ):
+        w3 = await AsyncWeb3(WebSocketProvider("ws://mocked"))
+        async for _ in w3.socket.process_subscriptions():
+            pytest.fail("Should not reach this point.")

{web3-7.0.0b7 → web3-7.0.0b8}/tests/core/test_library_files.py

@@ -1,6 +1,6 @@
 import os
 
-WEB3_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "web3")
+WEB3_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../..", "web3")
 DEFAULT_EXCEPTIONS = (
     AssertionError,
     ValueError,

{web3-7.0.0b7 → web3-7.0.0b8}/tests/core/utilities/test_method_formatters.py

@@ -1,14 +1,20 @@
 import pytest
 
+from eth_typing import (
+    HexStr,
+)
+
 from web3._utils.method_formatters import (
     get_error_formatters,
     raise_contract_logic_error_on_revert,
+    storage_key_to_hexstr,
 )
 from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
     ContractLogicError,
+    Web3ValueError,
 )
 from web3.types import (
     RPCResponse,
@@ -192,3 +198,41 @@ def test_get_error_formatters() -> None:
     with pytest.raises(ContractLogicError):
         formatters(REVERT_WITHOUT_MSG)
     assert formatters(OTHER_ERROR) == OTHER_ERROR
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_output",
+    [
+        ("0x" + "a" * 64, HexStr("0x" + "a" * 64)),
+        ("a" * 64, HexStr("0x" + "a" * 64)),
+        ("0x" + "a" * 63, Web3ValueError),
+        ("a" * 63, Web3ValueError),
+        (b"a" * 32, HexStr("0x" + "61" * 32)),
+        (b"a" * 31, Web3ValueError),
+        (b"a" * 33, Web3ValueError),
+        (
+            7719472615821079694904732333912527190217998977709370935963838933860875309329,  # noqa: E501
+            HexStr("0x" + "1" * 64),
+        ),
+        (3567, Web3ValueError),
+        (3.14, Web3ValueError),
+    ],
+    ids=[
+        "valid-0x-hex-string",
+        "valid-no-0x-hex-string",
+        "invalid-0x-hex-string",
+        "invalid-no-0x-hex-string",
+        "valid-32-byte-value",
+        "invalid-31-byte-value",
+        "invalid-33-byte-value",
+        "valid-integer",
+        "invalid-integer",
+        "invalid-float",
+    ],
+)
+def test_storage_key_to_hexstr(input_value, expected_output):
+    if isinstance(expected_output, type) and issubclass(expected_output, Exception):
+        with pytest.raises(expected_output):
+            storage_key_to_hexstr(input_value)
+    else:
+        assert storage_key_to_hexstr(input_value) == expected_output

{web3-7.0.0b7 → web3-7.0.0b8}/tests/integration/conftest.py

@@ -64,3 +64,14 @@ def event_loop():
     loop = asyncio.get_event_loop_policy().new_event_loop()
     yield loop
     loop.close()
+
+
+@pytest.fixture(autouse=True)
+def _async_test_setup(request) -> None:
+    # Check if the 'async_w3' fixture is available in the current context
+    if "async_w3" in request.fixturenames:
+        async_w3 = request.getfixturevalue("async_w3")
+        if hasattr(async_w3.provider, "_request_processor"):
+            # Clear the request processor cache for persistent connection provider tests
+            async_w3.provider._request_processor.clear_caches()
+    yield

{web3-7.0.0b7 → web3-7.0.0b8}/web3/_utils/method_formatters.py

@@ -187,10 +187,28 @@ def apply_list_to_array_formatter(formatter: Any) -> Callable[..., Any]:
     return to_list(apply_formatter_to_array(formatter))
 
 
+def storage_key_to_hexstr(value: Union[bytes, int, str]) -> HexStr:
+    if not isinstance(value, (bytes, int, str)):
+        raise Web3ValueError(
+            f"Storage key must be one of bytes, int, str, got {type(value)}"
+        )
+    if isinstance(value, str):
+        if value.startswith("0x") and len(value) == 66:
+            return HexStr(value)
+        elif len(value) == 64:
+            return HexStr(f"0x{value}")
+    elif isinstance(value, bytes):
+        if len(value) == 32:
+            return HexBytes(value).to_0x_hex()
+    elif isinstance(value, int):
+        return storage_key_to_hexstr(hex(value))
+    raise Web3ValueError(f"Storage key must be a 32-byte value, got {value!r}")
+
+
 ACCESS_LIST_FORMATTER = type_aware_apply_formatters_to_dict(
     {
         "address": to_checksum_address,
-        "storageKeys": apply_list_to_array_formatter(to_hexbytes(64)),
+        "storageKeys": apply_list_to_array_formatter(storage_key_to_hexstr),
     }
 )
 

{web3-7.0.0b7 → web3-7.0.0b8}/web3/_utils/module_testing/eth_module.py

@@ -1210,7 +1210,7 @@ class AsyncEthModuleTest:
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict
@@ -2786,7 +2786,7 @@ class EthModuleTest:
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict

{web3-7.0.0b7 → web3-7.0.0b8}/web3/_utils/module_testing/module_testing_utils.py

@@ -1,6 +1,4 @@
-from collections import (
-    deque,
-)
+import asyncio
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -179,7 +177,9 @@ class WebSocketMessageStreamMock:
     def __init__(
         self, messages: Collection[bytes] = None, raise_exception: Exception = None
     ) -> None:
-        self.messages = deque(messages) if messages else deque()
+        self.queue = asyncio.Queue()  # type: ignore  # py38 issue
+        for msg in messages or []:
+            self.queue.put_nowait(msg)
         self.raise_exception = raise_exception
 
     def __await__(self) -> Generator[Any, Any, "Self"]:
@@ -192,13 +192,12 @@ class WebSocketMessageStreamMock:
         return self
 
     async def __anext__(self) -> bytes:
+        return await self.queue.get()
+
+    async def recv(self) -> bytes:
         if self.raise_exception:
             raise self.raise_exception
-
-        elif len(self.messages) == 0:
-            raise StopAsyncIteration
-
-        return self.messages.popleft()
+        return await self.queue.get()
 
     @staticmethod
     async def pong() -> Literal[False]:

{web3-7.0.0b7 → web3-7.0.0b8}/web3/_utils/module_testing/persistent_connection_provider.py

@@ -23,6 +23,7 @@ from web3.middleware import (
 )
 from web3.types import (
     FormattedEthSubscriptionResponse,
+    RPCEndpoint,
 )
 
 if TYPE_CHECKING:
@@ -31,6 +32,22 @@ if TYPE_CHECKING:
     )
 
 
+SOME_BLOCK_KEYS = [
+    "number",
+    "hash",
+    "parentHash",
+    "transactionsRoot",
+    "stateRoot",
+    "receiptsRoot",
+    "size",
+    "gasLimit",
+    "gasUsed",
+    "timestamp",
+    "transactions",
+    "baseFeePerGas",
+]
+
+
 class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     @pytest.mark.parametrize(
@@ -372,22 +389,8 @@ class PersistentConnectionProviderTest:
         assert isinstance(pending, AttributeDict)
 
         # assert block values
-        some_block_keys = [
-            "number",
-            "hash",
-            "parentHash",
-            "transactionsRoot",
-            "stateRoot",
-            "receiptsRoot",
-            "size",
-            "gasLimit",
-            "gasUsed",
-            "timestamp",
-            "transactions",
-            "baseFeePerGas",
-        ]
-        assert all(k in latest.keys() for k in some_block_keys)
-        assert all(k in pending.keys() for k in some_block_keys)
+        assert all(k in latest.keys() for k in SOME_BLOCK_KEYS)
+        assert all(k in pending.keys() for k in SOME_BLOCK_KEYS)
 
         assert isinstance(block_num, int)
         assert latest["number"] == block_num
@@ -395,3 +398,28 @@ class PersistentConnectionProviderTest:
         assert isinstance(chain_id, int)
         assert isinstance(chain_id2, int)
         assert isinstance(chain_id3, int)
+
+    @pytest.mark.asyncio
+    async def test_public_socket_api(self, async_w3: "AsyncWeb3") -> None:
+        # send a request over the socket
+        await async_w3.socket.send(
+            RPCEndpoint("eth_getBlockByNumber"), ["latest", True]
+        )
+
+        # recv and validate the unprocessed response
+        response = await async_w3.socket.recv()
+        assert "id" in response, "Expected 'id' key in response."
+        assert "jsonrpc" in response, "Expected 'jsonrpc' key in response."
+        assert "result" in response, "Expected 'result' key in response."
+        assert all(k in response["result"].keys() for k in SOME_BLOCK_KEYS)
+        assert not isinstance(response["result"]["number"], int)  # assert not processed
+
+        # make a request over the socket
+        response = await async_w3.socket.make_request(
+            RPCEndpoint("eth_getBlockByNumber"), ["latest", True]
+        )
+        assert "id" in response, "Expected 'id' key in response."
+        assert "jsonrpc" in response, "Expected 'jsonrpc' key in response."
+        assert "result" in response, "Expected 'result' key in response."
+        assert all(k in response["result"].keys() for k in SOME_BLOCK_KEYS)
+        assert not isinstance(response["result"]["number"], int)  # assert not processed

{web3-7.0.0b7 → web3-7.0.0b8}/web3/exceptions.py

@@ -327,6 +327,12 @@ class TaskNotRunning(Web3Exception):
         super().__init__(message)
 
 
+class PersistentConnectionClosedOK(Web3Exception):
+    """
+    Raised when a persistent connection is closed gracefully by the server.
+    """
+
+
 class Web3RPCError(Web3Exception):
     """
     Raised when a JSON-RPC response contains an error field.

{web3-7.0.0b7 → web3-7.0.0b8}/web3/manager.py

@@ -20,9 +20,6 @@ from eth_utils.toolz import (
 from hexbytes import (
     HexBytes,
 )
-from websockets.exceptions import (
-    ConnectionClosedOK,
-)
 
 from web3._utils.batching import (
     RequestBatcher,
@@ -472,22 +469,50 @@ class RequestManager:
 
     # -- persistent connection -- #
 
-    async def send(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+    async def socket_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         request_func = await provider.request_func(
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
         self.logger.debug(
-            "Making request to open socket connection: "
+            "Making request to open socket connection and waiting for response: "
             f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
         )
         response = await request_func(method, params)
         return await self._process_response(response)
 
+    async def send(self, method: RPCEndpoint, params: Any) -> None:
+        provider = cast(PersistentConnectionProvider, self._provider)
+        # run through the request processors of the middleware
+        for mw_class in self.middleware_onion.as_tuple_of_middleware():
+            mw = mw_class(self.w3)
+            method, params = mw.request_processor(method, params)
+
+        self.logger.debug(
+            "Sending request to open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
+        )
+        await provider.socket_send(provider.encode_rpc_request(method, params))
+
+    async def recv(self) -> RPCResponse:
+        provider = cast(PersistentConnectionProvider, self._provider)
+        self.logger.debug(
+            "Getting next response from open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}"
+        )
+        # pop from the queue since the listener task is responsible for reading
+        # directly from the socket
+        request_response_cache = self._request_processor._request_response_cache
+        _key, response = await request_response_cache.async_await_and_popitem(
+            last=False,
+            timeout=provider.request_timeout,
+        )
+        return await self._process_response(response)
+
     def _persistent_message_stream(self) -> "_AsyncPersistentMessageStream":
         return _AsyncPersistentMessageStream(self)
 
-    async def _get_next_message(self) -> Any:
+    async def _get_next_message(self) -> RPCResponse:
         return await self._message_stream().__anext__()
 
     async def _message_stream(self) -> AsyncGenerator[RPCResponse, None]:
@@ -515,12 +540,13 @@ class RequestManager:
                     # if response is an active subscription response, process it
                     yield await self._process_response(response)
             except TaskNotRunning:
+                await asyncio.sleep(0)
                 self._provider._handle_listener_task_exceptions()
                 self.logger.error(
                     "Message listener background task has stopped unexpectedly. "
                     "Stopping message stream."
                 )
-                raise StopAsyncIteration
+                return
 
     async def _process_response(self, response: RPCResponse) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
@@ -586,7 +612,4 @@ class _AsyncPersistentMessageStream:
         return self
 
     async def __anext__(self) -> RPCResponse:
-        try:
-            return await self.manager._get_next_message()
-        except ConnectionClosedOK:
-            raise StopAsyncIteration
+        return await self.manager._get_next_message()

{web3-7.0.0b7 → web3-7.0.0b8}/web3/module.py

@@ -138,7 +138,7 @@ def retrieve_async_method_call_fn(
 
             try:
                 method_str = cast(RPCEndpoint, method_str)
-                return await async_w3.manager.send(method_str, params)
+                return await async_w3.manager.socket_request(method_str, params)
             except Exception as e:
                 if (
                     cache_key is not None

{web3-7.0.0b7 → web3-7.0.0b8}/web3/providers/persistent/async_ipc.py

@@ -11,11 +11,9 @@ from pathlib import (
 import sys
 from typing import (
     Any,
-    List,
     Optional,
     Tuple,
     Union,
-    cast,
 )
 
 from eth_utils import (
@@ -23,20 +21,12 @@ from eth_utils import (
 )
 
 from web3.types import (
-    RPCEndpoint,
     RPCResponse,
 )
 
 from . import (
     PersistentConnectionProvider,
 )
-from ..._utils.batching import (
-    BATCH_REQUEST_ID,
-    sort_batch_response_by_response_ids,
-)
-from ..._utils.caching import (
-    async_handle_request_caching,
-)
 from ...exceptions import (
     ProviderConnectionError,
     Web3TypeError,
@@ -91,12 +81,7 @@ class AsyncIPCProvider(PersistentConnectionProvider):
             return False
 
         try:
-            request_data = self.encode_rpc_request(
-                RPCEndpoint("web3_clientVersions"), []
-            )
-            self._writer.write(request_data)
-            current_request_id = json.loads(request_data)["id"]
-            await self._get_response_for_request_id(current_request_id, timeout=2)
+            await self.make_request("web3_clientVersion", [])
             return True
         except (OSError, ProviderConnectionError) as e:
             if show_traceback:
@@ -105,55 +90,33 @@ class AsyncIPCProvider(PersistentConnectionProvider):
                 )
             return False
 
-    async def _provider_specific_connect(self) -> None:
-        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
-
-    async def _provider_specific_disconnect(self) -> None:
-        if self._writer and not self._writer.is_closing():
-            self._writer.close()
-            await self._writer.wait_closed()
-            self._writer = None
-        if self._reader:
-            self._reader = None
-
-    async def _reset_socket(self) -> None:
-        self._writer.close()
-        await self._writer.wait_closed()
-        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
-
-    @async_handle_request_caching
-    async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+    async def socket_send(self, request_data: bytes) -> None:
         if self._writer is None:
             raise ProviderConnectionError(
                 "Connection to ipc socket has not been initiated for the provider."
             )
 
-        request_data = self.encode_rpc_request(method, params)
-        try:
-            self._writer.write(request_data)
-            await self._writer.drain()
-        except OSError as e:
-            # Broken pipe
-            if e.errno == errno.EPIPE:
-                # one extra attempt, then give up
-                await self._reset_socket()
-                self._writer.write(request_data)
-                await self._writer.drain()
+        return await asyncio.wait_for(
+            self._socket_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:
+        while True:
+            # yield to the event loop to allow other tasks to run
+            await asyncio.sleep(0)
 
-        return response
+            try:
+                response, pos = self._decoder.raw_decode(self._raw_message)
+                self._raw_message = self._raw_message[pos:].lstrip()
+                return response
+            except JSONDecodeError:
+                # read more data from the socket if the current raw message is
+                # incomplete
+                self._raw_message += to_text(await self._reader.read(4096)).lstrip()
 
-    async def make_batch_request(
-        self, requests: List[Tuple[RPCEndpoint, Any]]
-    ) -> List[RPCResponse]:
-        if self._writer is None:
-            raise ProviderConnectionError(
-                "Connection to ipc socket has not been initiated for the provider."
-            )
+    # -- private methods -- #
 
-        request_data = self.encode_batch_rpc_request(requests)
+    async def _socket_send(self, request_data: bytes) -> None:
         try:
             self._writer.write(request_data)
             await self._writer.drain()
@@ -165,32 +128,24 @@ class AsyncIPCProvider(PersistentConnectionProvider):
                 self._writer.write(request_data)
                 await self._writer.drain()
 
-        response = cast(
-            List[RPCResponse], await self._get_response_for_request_id(BATCH_REQUEST_ID)
-        )
-        return response
-
-    async def _provider_specific_message_listener(self) -> None:
-        self._raw_message += to_text(await self._reader.read(4096)).lstrip()
+    async def _reset_socket(self) -> None:
+        self._writer.close()
+        await self._writer.wait_closed()
+        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
 
-        while self._raw_message:
-            try:
-                response, pos = self._decoder.raw_decode(self._raw_message)
-            except JSONDecodeError:
-                break
+    async def _provider_specific_connect(self) -> None:
+        self._reader, self._writer = await async_get_ipc_socket(self.ipc_path)
 
-            if isinstance(response, list):
-                response = sort_batch_response_by_response_ids(response)
+    async def _provider_specific_disconnect(self) -> None:
+        if self._writer and not self._writer.is_closing():
+            self._writer.close()
+            await self._writer.wait_closed()
+            self._writer = None
+        if self._reader:
+            self._reader = None
 
-            is_subscription = (
-                response.get("method") == "eth_subscription"
-                if not isinstance(response, list)
-                else False
-            )
-            await self._request_processor.cache_raw_response(
-                response, subscription=is_subscription
-            )
-            self._raw_message = self._raw_message[pos:].lstrip()
+    async def _provider_specific_socket_reader(self) -> RPCResponse:
+        return await self.socket_recv()
 
     def _error_log_listener_task_exception(self, e: Exception) -> None:
         super()._error_log_listener_task_exception(e)