web3 7.11.1__py3-none-any.whl → 7.12.1__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,14 +718,12 @@ 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,
         async_math_contract: "AsyncContract",
     ) -> None:
-        # TODO: remove blockNumber block_id from eth_call and eth_getCode calls once
-        #  geth behavior for "latest" seems stable again.
         keyfile_account = async_w3.eth.account.from_key(keyfile_account_pkey)
 
         chain_id = await async_w3.eth.chain_id
@@ -752,16 +751,13 @@ 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)
-        tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
-            tx_hash, timeout=10
-        )
+        await async_w3.eth.wait_for_transaction_receipt(tx_hash)
 
-        code = await async_w3.eth.get_code(
-            keyfile_account.address, block_identifier=tx_receipt["blockNumber"]
-        )
+        code = await async_w3.eth.get_code(keyfile_account.address)
         assert code.to_0x_hex() == f"0xef0100{async_math_contract.address[2:].lower()}"
         delegated = async_w3.eth.contract(
             address=keyfile_account.address, abi=async_math_contract.abi
@@ -770,7 +766,7 @@ class AsyncEthModuleTest:
         # assert the math counter is increased by 1337 only in delegated acct
         assert await async_math_contract.functions.counter().call() == math_counter
         delegated_call = await delegated.functions.counter().call(
-            block_identifier=tx_receipt["blockNumber"]
+            block_identifier="latest"
         )
         assert delegated_call == math_counter + 1337
 
@@ -790,21 +786,20 @@ 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_tx_receipt = await async_w3.eth.wait_for_transaction_receipt(
-            reset_tx_hash, timeout=10
+        reset_code_txn = merge(
+            txn,
+            {
+                "from": keyfile_account.address,
+                "authorizationList": [signed_reset_auth],
+                "nonce": nonce + 2,
+            },
         )
 
-        reset_code = await async_w3.eth.get_code(
-            keyfile_account.address, reset_tx_receipt["blockNumber"]
-        )
+        # test eth_sendTransaction
+        reset_tx_hash = await async_w3.eth.send_transaction(reset_code_txn)
+        await async_w3.eth.wait_for_transaction_receipt(reset_tx_hash, timeout=10)
+
+        reset_code = await async_w3.eth.get_code(keyfile_account.address)
         assert reset_code == HexBytes("0x")
 
     @pytest.mark.asyncio
@@ -3867,11 +3862,9 @@ 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
-        #  geth behavior for "latest" seems stable again.
         keyfile_account = w3.eth.account.from_key(keyfile_account_pkey)
 
         chain_id = w3.eth.chain_id
@@ -3899,29 +3892,20 @@ 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)
-        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=10)
+        w3.eth.send_raw_transaction(signed.raw_transaction)
+        get_tx = w3.eth.get_transaction(signed.hash)
+        w3.eth.wait_for_transaction_receipt(signed.hash)
 
-        code = w3.eth.get_code(
-            keyfile_account.address, block_identifier=receipt["blockNumber"]
-        )
+        code = w3.eth.get_code(keyfile_account.address)
         assert code.to_0x_hex() == f"0xef0100{math_contract.address[2:].lower()}"
         delegated = w3.eth.contract(
             address=keyfile_account.address, abi=math_contract.abi
         )
         # assert the math counter is increased by 1337 only in delegated acct
-        assert (
-            math_contract.functions.counter().call(
-                block_identifier=receipt["blockNumber"]
-            )
-            == math_counter
-        )
-        assert (
-            delegated.functions.counter().call(block_identifier=receipt["blockNumber"])
-            == math_counter + 1337
-        )
+        assert math_contract.functions.counter().call() == math_counter
+        assert delegated.functions.counter().call() == math_counter + 1337
 
         assert len(get_tx["authorizationList"]) == 1
         get_auth = get_tx["authorizationList"][0]
@@ -3932,26 +3916,27 @@ class EthModuleTest:
         assert isinstance(get_auth["r"], HexBytes)
         assert isinstance(get_auth["s"], HexBytes)
 
-        # reset storage value and code
+        # reset code
         reset_auth = {
             "chainId": chain_id,
             "address": "0x" + ("00" * 20),
             "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 = w3.eth.send_raw_transaction(signed_reset.raw_transaction)
-        reset_tx_receipt = w3.eth.wait_for_transaction_receipt(
-            reset_tx_hash, timeout=10
+        reset_code_txn = merge(
+            txn,
+            {
+                "from": keyfile_account.address,
+                "authorizationList": [signed_reset_auth],
+                "nonce": nonce + 2,
+            },
         )
 
-        reset_code = w3.eth.get_code(
-            keyfile_account.address, block_identifier=reset_tx_receipt["blockNumber"]
-        )
+        # test eth_sendTransaction
+        reset_tx_hash = w3.eth.send_transaction(reset_code_txn)
+        w3.eth.wait_for_transaction_receipt(reset_tx_hash)
+
+        reset_code = w3.eth.get_code(keyfile_account.address)
         assert reset_code == HexBytes("0x")
 
     def test_eth_call(self, w3: "Web3", math_contract: "Contract") -> None:

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)
 
     #
@@ -254,14 +254,14 @@ class RequestManager:
         """
         Context manager for making batch requests
         """
-        if isinstance(self.provider, AutoProvider):
-            self.provider = self.provider._get_active_provider(use_cache=True)
-        if not isinstance(self.provider, (AsyncJSONBaseProvider, JSONBaseProvider)):
+        if not isinstance(
+            self.provider, (AsyncJSONBaseProvider, JSONBaseProvider, AutoProvider)
+        ):
             raise Web3TypeError("Batch requests are not supported by this provider.")
         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"
         )