web3 7.11.1__py3-none-any.whl → 7.12.0__py3-none-any.whl

web3/_utils/module_testing/eth_module.py

@@ -37,6 +37,7 @@ from eth_utils import (
 )
 from eth_utils.toolz import (
     assoc,
+    merge,
 )
 from hexbytes import (
     HexBytes,
@@ -717,7 +718,7 @@ class AsyncEthModuleTest:
         async_w3.middleware_onion.remove("signing")
 
     @pytest.mark.asyncio
-    async def test_async_sign_authorization_and_send_raw_set_code_transaction(
+    async def test_async_sign_authorization_send_raw_and_send_set_code_transactions(
         self,
         async_w3: "AsyncWeb3",
         keyfile_account_pkey: HexStr,
@@ -752,6 +753,7 @@ class AsyncEthModuleTest:
             "authorizationList": [signed_auth],
         }
 
+        # test eth_sendRawTransaction
         signed = keyfile_account.sign_transaction(txn)
         tx_hash = await async_w3.eth.send_raw_transaction(signed.raw_transaction)
         get_tx = await async_w3.eth.get_transaction(tx_hash)
@@ -790,14 +792,17 @@ class AsyncEthModuleTest:
             "nonce": nonce + 3,
         }
         signed_reset_auth = keyfile_account.sign_authorization(reset_auth)
-        new_txn = dict(txn)
-        new_txn["authorizationList"] = [signed_reset_auth]
-        new_txn["nonce"] = nonce + 2
-
-        signed_reset = keyfile_account.sign_transaction(new_txn)
-        reset_tx_hash = await async_w3.eth.send_raw_transaction(
-            signed_reset.raw_transaction
+        reset_code_txn = merge(
+            txn,
+            {
+                "from": keyfile_account.address,
+                "authorizationList": [signed_reset_auth],
+                "nonce": nonce + 2,
+            },
         )
+
+        # test eth_sendTransaction
+        reset_tx_hash = await async_w3.eth.send_transaction(reset_code_txn)
         reset_tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
             reset_tx_hash, timeout=10
         )
@@ -3867,7 +3872,7 @@ class EthModuleTest:
         # cleanup
         w3.middleware_onion.remove("signing")
 
-    def test_sign_authorization_and_send_raw_set_code_transaction(
+    def test_sign_authorization_send_raw_and_send_set_code_transactions(
         self, w3: "Web3", keyfile_account_pkey: HexStr, math_contract: "Contract"
     ) -> None:
         # TODO: remove blockNumber block_id from eth_call and eth_getCode calls once
@@ -3899,6 +3904,7 @@ class EthModuleTest:
             "authorizationList": [signed_auth],
         }
 
+        # test eth_sendRawTransaction
         signed = keyfile_account.sign_transaction(txn)
         tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
         get_tx = w3.eth.get_transaction(tx_hash)
@@ -3939,12 +3945,17 @@ class EthModuleTest:
             "nonce": nonce + 3,
         }
         signed_reset_auth = keyfile_account.sign_authorization(reset_auth)
-        new_txn = dict(txn)
-        new_txn["authorizationList"] = [signed_reset_auth]
-        new_txn["nonce"] = nonce + 2
+        reset_code_txn = merge(
+            txn,
+            {
+                "from": keyfile_account.address,
+                "authorizationList": [signed_reset_auth],
+                "nonce": nonce + 2,
+            },
+        )
 
-        signed_reset = keyfile_account.sign_transaction(new_txn)
-        reset_tx_hash = w3.eth.send_raw_transaction(signed_reset.raw_transaction)
+        # test eth_sendTransaction
+        reset_tx_hash = w3.eth.send_transaction(reset_code_txn)
         reset_tx_receipt = w3.eth.wait_for_transaction_receipt(
             reset_tx_hash, timeout=10
         )

web3/_utils/module_testing/web3_module.py

@@ -1,4 +1,7 @@
 import pytest
+import asyncio
+import threading
+import time
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -43,6 +46,9 @@ if TYPE_CHECKING:
     )
 
 
+SOME_BLOCK_KEYS = {"number", "hash", "parentHash", "stateRoot", "transactions"}
+
+
 class Web3ModuleTest:
     def test_web3_client_version(self, w3: Web3) -> None:
         client_version = w3.client_version
@@ -336,7 +342,7 @@ class Web3ModuleTest:
 
             # assert proper batch cleanup after execution
             assert batch._requests_info == []
-            assert not batch._provider._is_batching
+            assert not w3.provider._is_batching
 
             # assert batch cannot be added to after execution
             with pytest.raises(
@@ -395,7 +401,7 @@ class Web3ModuleTest:
 
         # assert proper batch cleanup after execution
         assert batch._requests_info == []
-        assert not batch._provider._is_batching
+        assert not w3.provider._is_batching
 
         # assert batch cannot be added to after execution
         with pytest.raises(
@@ -513,6 +519,43 @@ class Web3ModuleTest:
                 batch.add(w3.eth.sign(Address(b"\x00" * 20)))
                 batch.execute()
 
+    def test_batch_requests_concurrently_with_regular_requests(
+        self, w3: "Web3"
+    ) -> None:
+        num_requests = 40
+        responses = []
+        batch_response = []
+
+        def make_regular_requests() -> None:
+            for _ in range(num_requests):
+                responses.append(w3.eth.get_block(0))
+                time.sleep(0.01)
+
+        def make_batch_request() -> None:
+            with w3.batch_requests() as batch:
+                for _ in range(num_requests):
+                    batch.add(w3.eth.get_block(0))
+                    time.sleep(0.01)
+                batch_response.extend(batch.execute())
+
+        # split into threads
+        regular_thread = threading.Thread(target=make_regular_requests)
+        batch_thread = threading.Thread(target=make_batch_request)
+
+        regular_thread.start()
+        batch_thread.start()
+
+        # wait for threads to finish
+        regular_thread.join()
+        batch_thread.join()
+        assert not regular_thread.is_alive()
+        assert not batch_thread.is_alive()
+
+        assert len(responses) == num_requests
+        assert len(batch_response) == num_requests
+        assert all(SOME_BLOCK_KEYS.issubset(response.keys()) for response in responses)
+        assert set(responses) == set(batch_response)
+
 
 # -- async -- #
 
@@ -551,7 +594,7 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
 
             # assert proper batch cleanup after execution
             assert batch._async_requests_info == []
-            assert not batch._provider._is_batching
+            assert not async_w3.provider._is_batching
 
             # assert batch cannot be added to after execution
             with pytest.raises(
@@ -614,7 +657,7 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
 
         # assert proper batch cleanup after execution
         assert batch._async_requests_info == []
-        assert not batch._provider._is_batching
+        assert not async_w3.provider._is_batching
 
         # assert batch cannot be added to after execution
         with pytest.raises(
@@ -734,3 +777,34 @@ class AsyncWeb3ModuleTest(Web3ModuleTest):
             with pytest.raises(MethodNotSupported, match="eth_sign"):
                 batch.add(async_w3.eth.sign(Address(b"\x00" * 20)))
                 await batch.async_execute()
+
+    @pytest.mark.asyncio
+    async def test_batch_requests_concurrently_with_regular_requests(  # type: ignore[override]  # noqa: E501
+        self, async_w3: AsyncWeb3  # type: ignore[override]
+    ) -> None:
+        responses = []
+        batch_response = []
+
+        num_blocks = await async_w3.eth.block_number
+
+        async def make_regular_requests() -> None:
+            for i in range(num_blocks):
+                responses.append(await async_w3.eth.get_block(i))
+                await asyncio.sleep(0.01)
+
+        async def make_batch_request() -> None:
+            async with async_w3.batch_requests() as batch:
+                for i in range(num_blocks):
+                    batch.add(async_w3.eth.get_block(i))
+                    await asyncio.sleep(0.01)
+                batch_response.extend(await batch.async_execute())
+
+        await asyncio.gather(
+            make_regular_requests(),
+            make_batch_request(),
+        )
+
+        assert len(responses) == num_blocks
+        assert len(batch_response) == num_blocks
+        assert all(SOME_BLOCK_KEYS.issubset(response.keys()) for response in responses)
+        assert set(responses) == set(batch_response)

web3/_utils/validation.py

@@ -396,7 +396,7 @@ def validate_rpc_response_and_raise_if_error(
 
         response = apply_error_formatters(error_formatters, response)
         if logger is not None:
-            logger.debug(f"RPC error response: {response}")
+            logger.debug("RPC error response: %s", response)
 
         raise web3_rpc_error
 

web3/contract/utils.py

@@ -43,8 +43,8 @@ from web3._utils.abi import (
 from web3._utils.async_transactions import (
     async_fill_transaction_defaults,
 )
-from web3._utils.compat import (
-    TypeAlias,
+from web3._utils.batching import (
+    BatchRequestInformation,
 )
 from web3._utils.contracts import (
     prepare_transaction,
@@ -62,7 +62,6 @@ from web3.exceptions import (
 from web3.types import (
     ABIElementIdentifier,
     BlockIdentifier,
-    RPCEndpoint,
     StateOverride,
     TContractEvent,
     TContractFn,
@@ -175,10 +174,8 @@ def call_contract_function(
     if abi_callable["type"] == "function":
         output_types = get_abi_output_types(abi_callable)
 
-    provider = w3.provider
-    if hasattr(provider, "_is_batching") and provider._is_batching:
-        BatchingReturnData: TypeAlias = Tuple[Tuple[RPCEndpoint, Any], Tuple[Any, ...]]
-        request_information = tuple(cast(BatchingReturnData, return_data))
+    if w3.provider._is_batching:
+        request_information = tuple(cast(BatchRequestInformation, return_data))
         method_and_params = request_information[0]
 
         # append return data formatting to result formatters
@@ -483,35 +480,23 @@ async def async_call_contract_function(
             normalizers,
             output_types,
         )
-        if async_w3.provider.has_persistent_connection:
-            # get the current request id
-            provider = cast("PersistentConnectionProvider", async_w3.provider)
-            current_request_id = provider._batch_request_counter - 1
-            provider._request_processor.append_result_formatter_for_request(
-                current_request_id, contract_call_return_data_formatter
-            )
-        else:
-            BatchingReturnData: TypeAlias = Tuple[
-                Tuple[RPCEndpoint, Any], Tuple[Any, ...]
-            ]
-            request_information = tuple(cast(BatchingReturnData, return_data))
-            method_and_params = request_information[0]
-
-            # append return data formatter to result formatters
-            current_response_formatters = request_information[1]
-            current_result_formatters = current_response_formatters[0]
-            updated_result_formatters = compose(
-                contract_call_return_data_formatter,
-                current_result_formatters,
-            )
-            response_formatters = (
-                updated_result_formatters,  # result formatters
-                current_response_formatters[1],  # error formatters
-                current_response_formatters[2],  # null result formatters
-            )
-            return (method_and_params, response_formatters)
 
-        return return_data
+        request_information = tuple(cast(BatchRequestInformation, return_data))
+        method_and_params = request_information[0]
+
+        # append return data formatter to result formatters
+        current_response_formatters = request_information[1]
+        current_result_formatters = current_response_formatters[0]
+        updated_result_formatters = compose(
+            contract_call_return_data_formatter,
+            current_result_formatters,
+        )
+        response_formatters = (
+            updated_result_formatters,  # result formatters
+            current_response_formatters[1],  # error formatters
+            current_response_formatters[2],  # null result formatters
+        )
+        return (method_and_params, response_formatters)
 
     try:
         output_data = async_w3.codec.decode(output_types, return_data)

web3/manager.py

@@ -159,7 +159,7 @@ class RequestManager:
         request_func = provider.request_func(
             cast("Web3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
-        self.logger.debug(f"Making request. Method: {method}")
+        self.logger.debug("Making request. Method: %s", method)
         return request_func(method, params)
 
     async def _coro_make_request(
@@ -169,7 +169,7 @@ class RequestManager:
         request_func = await provider.request_func(
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
-        self.logger.debug(f"Making request. Method: {method}")
+        self.logger.debug("Making request. Method: %s", method)
         return await request_func(method, params)
 
     #
@@ -261,7 +261,7 @@ class RequestManager:
         return RequestBatcher(self.w3)
 
     def _make_batch_request(
-        self, requests_info: List[Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]]
+        self, requests_info: List[Tuple[Tuple["RPCEndpoint", Any], Tuple[Any, ...]]]
     ) -> List[RPCResponse]:
         """
         Make a batch request using the provider
@@ -291,7 +291,7 @@ class RequestManager:
     async def _async_make_batch_request(
         self,
         requests_info: List[
-            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]]
+            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Tuple[Any]]]
         ],
     ) -> List[RPCResponse]:
         """
@@ -315,13 +315,6 @@ class RequestManager:
         if isinstance(response, list):
             # expected format
             response = cast(List[RPCResponse], response)
-            if isinstance(self.provider, PersistentConnectionProvider):
-                # call _process_response for each response in the batch
-                return [
-                    cast(RPCResponse, await self._process_response(resp))
-                    for resp in response
-                ]
-
             formatted_responses = [
                 self._format_batched_response(info, resp)
                 for info, resp in zip(unpacked_requests_info, response)
@@ -331,6 +324,86 @@ class RequestManager:
             # expect a single response with an error
             raise_error_for_batch_response(response, self.logger)
 
+    async def _async_send_batch(
+        self, requests: List[Tuple["RPCEndpoint", Any]]
+    ) -> List[RPCRequest]:
+        """
+        Send a batch request via socket.
+        """
+        if not isinstance(self._provider, PersistentConnectionProvider):
+            raise Web3TypeError(
+                "Only providers that maintain an open, persistent connection "
+                "can send batch requests."
+            )
+        send_func = await self._provider.send_batch_func(
+            cast("AsyncWeb3", self.w3),
+            cast("MiddlewareOnion", self.middleware_onion),
+        )
+        self.logger.debug(
+            "Sending batch request to open socket connection: %s",
+            self._provider.get_endpoint_uri_or_ipc_path(),
+        )
+        return await send_func(requests)
+
+    async def _async_recv_batch(self, requests: List[RPCRequest]) -> List[RPCResponse]:
+        """
+        Receive a batch request via socket.
+        """
+        if not isinstance(self._provider, PersistentConnectionProvider):
+            raise Web3TypeError(
+                "Only providers that maintain an open, persistent connection "
+                "can receive batch requests."
+            )
+        recv_func = await self._provider.recv_batch_func(
+            cast("AsyncWeb3", self.w3),
+            cast("MiddlewareOnion", self.middleware_onion),
+        )
+        self.logger.debug(
+            "Receiving batch request from open socket connection: %s",
+            self._provider.get_endpoint_uri_or_ipc_path(),
+        )
+        return await recv_func(requests)
+
+    async def _async_make_socket_batch_request(
+        self,
+        requests_info: List[
+            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Tuple[Any, ...]]]
+        ],
+    ) -> List[RPCResponse]:
+        """
+        Send and receive a batch request via a socket.
+        """
+        if not isinstance(self._provider, PersistentConnectionProvider):
+            raise Web3TypeError(
+                "Only providers that maintain an open, persistent connection "
+                "can send and receive batch requests."
+            )
+
+        unpacked_requests_info = await asyncio.gather(*requests_info)
+        reqs = [req for req, _ in unpacked_requests_info]
+        response_formatters = [resp_f for _, resp_f in unpacked_requests_info]
+
+        requests = await self._async_send_batch(reqs)
+
+        for i, request in enumerate(requests):
+            self._provider._request_processor.cache_request_information(
+                request["id"],
+                request["method"],
+                request["params"],
+                response_formatters=response_formatters[i],
+            )
+
+        responses = await self._async_recv_batch(requests)
+        if isinstance(responses, list):
+            # expected format
+            return [
+                cast(RPCResponse, await self._process_response(resp))
+                for resp in responses
+            ]
+        else:
+            # expect a single response with an error
+            raise_error_for_batch_response(responses, self.logger)
+
     def _format_batched_response(
         self,
         requests_info: Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]],
@@ -366,9 +439,12 @@ class RequestManager:
     ) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)
         self.logger.debug(
-            "Making request to open socket connection and waiting for response: "
-            f"{provider.get_endpoint_uri_or_ipc_path()},\n    method: {method},\n"
-            f"    params: {params}"
+            "Making request to open socket connection and waiting for response: %s,\n"
+            "    method: %s,\n"
+            "    params: %s",
+            provider.get_endpoint_uri_or_ipc_path(),
+            method,
+            params,
         )
         rpc_request = await self.send(method, params)
         provider._request_processor.cache_request_information(
@@ -388,9 +464,12 @@ class RequestManager:
             middleware_onion,
         )
         self.logger.debug(
-            "Sending request to open socket connection: "
-            f"{provider.get_endpoint_uri_or_ipc_path()},\n    method: {method},\n"
-            f"    params: {params}"
+            "Sending request to open socket connection: %s,\n"
+            "    method: %s,\n"
+            "    params: %s",
+            provider.get_endpoint_uri_or_ipc_path(),
+            method,
+            params,
         )
         return await send_func(method, params)
 
@@ -404,7 +483,8 @@ class RequestManager:
         )
         self.logger.debug(
             "Getting response for request from open socket connection:\n"
-            f"    request: {rpc_request}"
+            "    request: %s",
+            rpc_request,
         )
         response = await recv_func(rpc_request)
         try:
@@ -417,8 +497,8 @@ class RequestManager:
     async def recv(self) -> Union[RPCResponse, FormattedEthSubscriptionResponse]:
         provider = cast(PersistentConnectionProvider, self._provider)
         self.logger.debug(
-            "Getting next response from open socket connection: "
-            f"{provider.get_endpoint_uri_or_ipc_path()}"
+            "Getting next response from open socket connection: %s",
+            provider.get_endpoint_uri_or_ipc_path(),
         )
         # pop from the queue since the listener task is responsible for reading
         # directly from the socket
@@ -501,9 +581,11 @@ class RequestManager:
                     # subscription as it comes in
                     request_info.subscription_id = subscription_id
                     provider.logger.debug(
-                        "Caching eth_subscription info:\n    "
-                        f"cache_key={cache_key},\n    "
-                        f"request_info={request_info.__dict__}"
+                        "Caching eth_subscription info:\n"
+                        "    cache_key=%s,\n"
+                        "    request_info=%s",
+                        cache_key,
+                        request_info.__dict__,
                     )
                     self._request_processor._request_information_cache.cache(
                         cache_key, request_info

web3/method.py

@@ -165,8 +165,7 @@ class Method(Generic[TFunc]):
                 "usually attached to a web3 instance."
             )
 
-        provider = module.w3.provider
-        if hasattr(provider, "_is_batching") and provider._is_batching:
+        if module.w3.provider._is_batching:
             if self.json_rpc_method in RPC_METHODS_UNSUPPORTED_DURING_BATCH:
                 raise MethodNotSupported(
                     f"Method `{self.json_rpc_method}` is not supported within a batch "
@@ -182,12 +181,13 @@ class Method(Generic[TFunc]):
     @property
     def method_selector_fn(
         self,
-    ) -> Callable[..., Union[RPCEndpoint, Callable[..., RPCEndpoint]]]:
+    ) -> Callable[[], RPCEndpoint]:
         """Gets the method selector from the config."""
-        if callable(self.json_rpc_method):
-            return self.json_rpc_method
-        elif isinstance(self.json_rpc_method, (str,)):
-            return lambda *_: self.json_rpc_method
+        method = self.json_rpc_method
+        if callable(method):
+            return method
+        elif isinstance(method, str):
+            return lambda: method
         raise Web3ValueError(
             "``json_rpc_method`` config invalid.  May be a string or function"
         )

web3/providers/async_base.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextvars
 import itertools
 import logging
 from typing import (
@@ -61,6 +62,9 @@ if TYPE_CHECKING:
         AsyncWeb3,
         WebSocketProvider,
     )
+    from web3._utils.batching import (  # noqa: F401
+        RequestBatcher,
+    )
     from web3.providers.persistent import (  # noqa: F401
         RequestProcessor,
     )
@@ -94,12 +98,19 @@ class AsyncBaseProvider:
         self.cache_allowed_requests = cache_allowed_requests
         self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
         self.request_cache_validation_threshold = request_cache_validation_threshold
-        self._is_batching: bool = False
+
+        self._batching_context: contextvars.ContextVar[
+            Optional["RequestBatcher[Any]"]
+        ] = contextvars.ContextVar("batching_context", default=None)
         self._batch_request_func_cache: Tuple[
             Tuple[Middleware, ...],
             Callable[..., Coroutine[Any, Any, Union[List[RPCResponse], RPCResponse]]],
         ] = (None, None)
 
+    @property
+    def _is_batching(self) -> bool:
+        return self._batching_context.get() is not None
+
     async def request_func(
         self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
@@ -240,3 +251,6 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
             )
             + b"]"
         )
+
+    def encode_batch_request_dicts(self, request_dicts: List[RPCRequest]) -> bytes:
+        return b"[" + b",".join(self.encode_rpc_dict(d) for d in request_dicts) + b"]"

web3/providers/base.py

@@ -1,3 +1,4 @@
+import contextvars
 import itertools
 import logging
 import threading
@@ -50,6 +51,9 @@ from web3.utils import (
 
 if TYPE_CHECKING:
     from web3 import Web3  # noqa: F401
+    from web3._utils.batching import (
+        RequestBatcher,
+    )
 
 
 class BaseProvider:
@@ -81,6 +85,20 @@ class BaseProvider:
         self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
         self.request_cache_validation_threshold = request_cache_validation_threshold
 
+        self._batching_context: contextvars.ContextVar[
+            Optional["RequestBatcher[Any]"]
+        ] = contextvars.ContextVar("batching_context", default=None)
+        self._batch_request_func_cache: Tuple[
+            Tuple[Middleware, ...], Callable[..., Union[List[RPCResponse], RPCResponse]]
+        ] = (None, None)
+
+    @property
+    def _is_batching(self) -> bool:
+        """
+        Check if the provider is currently batching requests.
+        """
+        return self._batching_context.get() is not None
+
     def request_func(
         self, w3: "Web3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., RPCResponse]:
@@ -120,11 +138,6 @@ class JSONBaseProvider(BaseProvider):
         super().__init__(**kwargs)
         self.request_counter = itertools.count()
 
-        self._is_batching: bool = False
-        self._batch_request_func_cache: Tuple[
-            Tuple[Middleware, ...], Callable[..., Union[List[RPCResponse], RPCResponse]]
-        ] = (None, None)
-
     def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
         rpc_dict = {
             "jsonrpc": "2.0",

web3/providers/ipc.py

@@ -30,7 +30,6 @@ from web3.types import (
 )
 
 from .._utils.batching import (
-    batching_context,
     sort_batch_response_by_response_ids,
 )
 from .._utils.caching import (
@@ -197,16 +196,15 @@ class IPCProvider(JSONBaseProvider):
     @handle_request_caching
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         self.logger.debug(
-            f"Making request IPC. Path: {self.ipc_path}, Method: {method}"
+            "Making request IPC. Path: %s, Method: %s", self.ipc_path, method
         )
         request = self.encode_rpc_request(method, params)
         return self._make_request(request)
 
-    @batching_context
     def make_batch_request(
         self, requests: List[Tuple[RPCEndpoint, Any]]
     ) -> List[RPCResponse]:
-        self.logger.debug(f"Making batch request IPC. Path: {self.ipc_path}")
+        self.logger.debug("Making batch request IPC. Path: %s", self.ipc_path)
         request_data = self.encode_batch_rpc_request(requests)
         response = cast(List[RPCResponse], self._make_request(request_data))
         return sort_batch_response_by_response_ids(response)