web3 7.7.0__py3-none-any.whl → 7.9.0__py3-none-any.whl

web3/_utils/module_testing/eth_module.py

@@ -1,7 +1,7 @@
+import pytest
 import asyncio
 import json
 import math
-import pytest
 from random import (
     randint,
 )
@@ -1690,6 +1690,52 @@ class AsyncEthModuleTest:
         with pytest.raises(TooManyRequests, match="Too many CCIP read redirects"):
             await async_offchain_lookup_contract.caller().continuousOffchainLookup()  # noqa: E501 type: ignore
 
+    @pytest.mark.asyncio
+    async def test_eth_simulate_v1(self, async_w3: "AsyncWeb3") -> None:
+        simulate_result = await async_w3.eth.simulate_v1(
+            {
+                "blockStateCalls": [
+                    {
+                        "blockOverrides": {
+                            "baseFeePerGas": Wei(10),
+                        },
+                        "stateOverrides": {
+                            "0xc100000000000000000000000000000000000000": {
+                                "balance": Wei(500000000),
+                            }
+                        },
+                        "calls": [
+                            {
+                                "from": "0xc100000000000000000000000000000000000000",
+                                "to": "0xc100000000000000000000000000000000000000",
+                                "maxFeePerGas": Wei(10),
+                                "maxPriorityFeePerGas": Wei(10),
+                            }
+                        ],
+                    }
+                ],
+                "validation": True,
+                "traceTransfers": True,
+            },
+            "latest",
+        )
+
+        assert len(simulate_result) == 1
+
+        result = simulate_result[0]
+        assert result.get("baseFeePerGas") == 10
+
+        calls_result = result.get("calls")
+        assert calls_result is not None
+        assert len(calls_result) == 1
+        call_entry = calls_result[0]
+
+        assert all(
+            key in call_entry for key in ("returnData", "logs", "gasUsed", "status")
+        )
+        assert call_entry["status"] == 1
+        assert call_entry["gasUsed"] == int("0x5208", 16)
+
     @pytest.mark.asyncio
     async def test_async_eth_chain_id(self, async_w3: "AsyncWeb3") -> None:
         chain_id = await async_w3.eth.chain_id
@@ -2283,6 +2329,9 @@ class AsyncEthModuleTest:
         async_w3: "AsyncWeb3",
         async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
+        # Note: `underpriced transaction` error is only consistent with
+        # ``txpool.nolocals`` flag as of Geth ``v1.15.4``.
+        # https://github.com/ethereum/web3.py/pull/3636
         txn_params: TxParams = {
             "from": async_keyfile_account_address_dual_type,
             "to": async_keyfile_account_address_dual_type,
@@ -2388,6 +2437,7 @@ class AsyncEthModuleTest:
         with pytest.raises(Web3ValueError):
             await async_w3.eth.replace_transaction(txn_hash, txn_params)
 
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_minimum(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -2411,6 +2461,7 @@ class AsyncEthModuleTest:
             gas_price * 1.125
         )  # minimum gas price
 
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_higher(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -2439,6 +2490,7 @@ class AsyncEthModuleTest:
         )  # Strategy provides higher gas price
         async_w3.eth.set_gas_price_strategy(None)  # reset strategy
 
+    @flaky_geth_dev_mining
     @pytest.mark.asyncio
     async def test_async_eth_replace_transaction_gas_price_defaulting_strategy_lower(
         self, async_w3: "AsyncWeb3", async_keyfile_account_address: ChecksumAddress
@@ -3479,6 +3531,9 @@ class EthModuleTest:
     def test_eth_replace_transaction_underpriced(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
+        # Note: `underpriced transaction` error is only consistent with
+        # ``txpool.nolocals`` flag as of Geth ``v1.15.4``.
+        # https://github.com/ethereum/web3.py/pull/3636
         txn_params: TxParams = {
             "from": keyfile_account_address_dual_type,
             "to": keyfile_account_address_dual_type,
@@ -3818,7 +3873,7 @@ class EthModuleTest:
         math_contract: "Contract",
         params: StateOverrideParams,
     ) -> None:
-        txn_params: TxParams = {"from": w3.eth.accounts[0]}
+        txn_params: TxParams = {"from": w3.eth.accounts[0], "to": math_contract.address}
 
         # assert does not raise
         w3.eth.call(txn_params, "latest", {math_contract.address: params})
@@ -3911,6 +3966,51 @@ class EthModuleTest:
             w3.eth.call(txn_params)
         assert excinfo.value.data == data
 
+    def test_eth_simulate_v1(self, w3: "Web3") -> None:
+        simulate_result = w3.eth.simulate_v1(
+            {
+                "blockStateCalls": [
+                    {
+                        "blockOverrides": {
+                            "baseFeePerGas": Wei(10),
+                        },
+                        "stateOverrides": {
+                            "0xc100000000000000000000000000000000000000": {
+                                "balance": Wei(500000000),
+                            }
+                        },
+                        "calls": [
+                            {
+                                "from": "0xc100000000000000000000000000000000000000",
+                                "to": "0xc100000000000000000000000000000000000000",
+                                "maxFeePerGas": Wei(10),
+                                "maxPriorityFeePerGas": Wei(10),
+                            }
+                        ],
+                    }
+                ],
+                "validation": True,
+                "traceTransfers": True,
+            },
+            "latest",
+        )
+
+        assert len(simulate_result) == 1
+
+        result = simulate_result[0]
+        assert result.get("baseFeePerGas") == 10
+
+        calls_result = result.get("calls")
+        assert calls_result is not None
+        assert len(calls_result) == 1
+        call_entry = calls_result[0]
+
+        assert all(
+            key in call_entry for key in ("returnData", "logs", "gasUsed", "status")
+        )
+        assert call_entry["status"] == 1
+        assert call_entry["gasUsed"] == int("0x5208", 16)
+
     @pytest.mark.parametrize(
         "panic_error,params",
         (

web3/_utils/module_testing/module_testing_utils.py

@@ -1,17 +1,12 @@
 import asyncio
-import functools
-import pytest
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Collection,
     Dict,
     Generator,
     Literal,
     Sequence,
-    Tuple,
-    Type,
     Union,
 )
 
@@ -63,43 +58,6 @@ due to timing of the test running as a block is mined.
 flaky_geth_dev_mining = flaky(max_runs=3, min_passes=1)
 
 
-def flaky_with_xfail_on_exception(
-    reason: str,
-    exception: Union[Type[Exception], Tuple[Type[Exception], ...]],
-    max_runs: int = 3,
-    min_passes: int = 1,
-) -> Callable[[Any], Any]:
-    """
-    Some tests inconsistently fail hard with a particular exception and retrying
-    these tests often times does not get them "unstuck". If we've exhausted all flaky
-    retries and this expected exception is raised, `xfail` the test with the given
-    reason.
-    """
-    runs = max_runs
-
-    def decorator(func: Any) -> Any:
-        @flaky(max_runs=max_runs, min_passes=min_passes)
-        @functools.wraps(func)
-        async def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any:
-            nonlocal runs
-            try:
-                return await func(self, *args, **kwargs)
-            except exception:
-                # xfail the test only if the exception is raised and we have exhausted
-                # all flaky retries
-                if runs == 1:
-                    pytest.xfail(reason)
-                runs -= 1
-                pytest.fail(f"xfailed but {runs} run(s) remaining with flaky...")
-            except Exception as e:
-                # let flaky handle it
-                raise e
-
-        return wrapper
-
-    return decorator
-
-
 def assert_contains_log(
     result: Sequence[LogReceipt],
     block_with_txn_with_log: BlockData,

web3/_utils/module_testing/persistent_connection_provider.py

@@ -1,8 +1,8 @@
+import pytest
 import asyncio
 from dataclasses import (
     dataclass,
 )
-import pytest
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -876,3 +876,41 @@ class PersistentConnectionProviderTest:
 
         assert_no_subscriptions_left(sub_manager._subscription_container)
         await clean_up_task(unsubscribe_task)
+
+    @pytest.mark.asyncio
+    async def test_run_forever_starts_with_0_subs_and_runs_until_task_cancelled(
+        self, async_w3: AsyncWeb3
+    ) -> None:
+        sub_manager = async_w3.subscription_manager
+        assert_no_subscriptions_left(sub_manager._subscription_container)
+
+        run_forever_task = asyncio.create_task(
+            sub_manager.handle_subscriptions(run_forever=True)
+        )
+
+        await asyncio.sleep(0.1)
+        assert run_forever_task.done() is False
+        assert sub_manager.subscriptions == []
+
+        # subscribe to newHeads and validate it
+        new_heads_handler_test = SubscriptionHandlerTest()
+        sub1 = NewHeadsSubscription(
+            label="foo",
+            handler=new_heads_handler,
+            handler_context={"new_heads_handler_test": new_heads_handler_test},
+        )
+        sub_id = await sub_manager.subscribe(sub1)
+        assert is_hexstr(sub_id)
+        assert len(sub_manager.subscriptions) == 1
+        assert sub_manager.subscriptions[0] == sub1
+
+        # wait for the handler to unsubscribe
+        while sub_manager.subscriptions:
+            await asyncio.sleep(0.1)
+
+        assert new_heads_handler_test.passed
+        assert run_forever_task.done() is False
+        assert run_forever_task.cancelled() is False
+
+        # cleanup
+        await clean_up_task(run_forever_task)

web3/_utils/rpc_abi.py

@@ -51,6 +51,7 @@ class RPC:
     eth_blobBaseFee = RPCEndpoint("eth_blobBaseFee")
     eth_blockNumber = RPCEndpoint("eth_blockNumber")
     eth_call = RPCEndpoint("eth_call")
+    eth_simulateV1 = RPCEndpoint("eth_simulateV1")
     eth_createAccessList = RPCEndpoint("eth_createAccessList")
     eth_chainId = RPCEndpoint("eth_chainId")
     eth_estimateGas = RPCEndpoint("eth_estimateGas")

web3/_utils/validation.py

@@ -1,7 +1,11 @@
 import itertools
+import logging
 from typing import (
     Any,
+    Callable,
     Dict,
+    NoReturn,
+    Optional,
 )
 
 from eth_typing import (
@@ -53,11 +57,22 @@ from web3._utils.abi import (
     length_of_array_type,
     sub_type_of_array_type,
 )
+from web3._utils.formatters import (
+    apply_error_formatters,
+)
 from web3.exceptions import (
+    BadResponseFormat,
     InvalidAddress,
+    MethodUnavailable,
+    RequestTimedOut,
+    TransactionNotFound,
+    Web3RPCError,
     Web3TypeError,
     Web3ValueError,
 )
+from web3.types import (
+    RPCResponse,
+)
 
 
 def _prepare_selector_collision_msg(duplicates: Dict[HexStr, ABIFunction]) -> str:
@@ -211,3 +226,179 @@ def assert_one_val(*args: Any, **kwargs: Any) -> None:
             "Exactly one of the passed values can be specified. "
             f"Instead, values were: {args!r}, {kwargs!r}"
         )
+
+
+# -- RPC Response Validation -- #
+
+KNOWN_REQUEST_TIMEOUT_MESSAGING = {
+    # Note: It's important to be very explicit here and not too broad. We don't want
+    # to accidentally catch a message that is not for a request timeout. In the worst
+    # case, we raise something more generic like `Web3RPCError`. JSON-RPC unfortunately
+    # has not standardized error codes for request timeouts.
+    "request timed out",  # go-ethereum
+}
+METHOD_NOT_FOUND = -32601
+
+
+def _validate_subscription_fields(response: RPCResponse) -> None:
+    params = response["params"]
+    subscription = params["subscription"]
+    if not isinstance(subscription, str) and not len(subscription) == 34:
+        _raise_bad_response_format(
+            response, "eth_subscription 'params' must include a 'subscription' field."
+        )
+
+
+def _raise_bad_response_format(response: RPCResponse, error: str = "") -> None:
+    message = "The response was in an unexpected format and unable to be parsed."
+    raw_response = f"The raw response is: {response}"
+
+    if error is not None and error != "":
+        error = error[:-1] if error.endswith(".") else error
+        message = f"{message} {error}. {raw_response}"
+    else:
+        message = f"{message} {raw_response}"
+
+    raise BadResponseFormat(message)
+
+
+def raise_error_for_batch_response(
+    response: RPCResponse,
+    logger: Optional[logging.Logger] = None,
+) -> NoReturn:
+    error = response.get("error")
+    if error is None:
+        _raise_bad_response_format(
+            response,
+            "Batch response must be formatted as a list of responses or "
+            "as a single JSON-RPC error response.",
+        )
+    validate_rpc_response_and_raise_if_error(
+        response,
+        None,
+        is_subscription_response=False,
+        logger=logger,
+        params=[],
+    )
+    # This should not be reached, but if it is, raise a generic `BadResponseFormat`
+    raise BadResponseFormat(
+        "Batch response was in an unexpected format and unable to be parsed."
+    )
+
+
+def validate_rpc_response_and_raise_if_error(
+    response: RPCResponse,
+    error_formatters: Optional[Callable[..., Any]],
+    is_subscription_response: bool = False,
+    logger: Optional[logging.Logger] = None,
+    params: Optional[Any] = None,
+) -> None:
+    if "jsonrpc" not in response or response["jsonrpc"] != "2.0":
+        _raise_bad_response_format(
+            response, 'The "jsonrpc" field must be present with a value of "2.0".'
+        )
+
+    response_id = response.get("id")
+    if "id" in response:
+        int_error_msg = (
+            '"id" must be an integer or a string representation of an integer.'
+        )
+        if response_id is None and "error" in response:
+            # errors can sometimes have null `id`, according to the JSON-RPC spec
+            pass
+        elif not isinstance(response_id, (str, int)):
+            _raise_bad_response_format(response, int_error_msg)
+        elif isinstance(response_id, str):
+            try:
+                int(response_id)
+            except ValueError:
+                _raise_bad_response_format(response, int_error_msg)
+    elif is_subscription_response:
+        # if `id` is not present, this must be a subscription response
+        _validate_subscription_fields(response)
+    else:
+        _raise_bad_response_format(
+            response,
+            'Response must include an "id" field or be formatted as an '
+            "`eth_subscription` response.",
+        )
+
+    if all(key in response for key in {"error", "result"}):
+        _raise_bad_response_format(
+            response, 'Response cannot include both "error" and "result".'
+        )
+    elif (
+        not any(key in response for key in {"error", "result"})
+        and not is_subscription_response
+    ):
+        _raise_bad_response_format(
+            response, 'Response must include either "error" or "result".'
+        )
+    elif "error" in response:
+        web3_rpc_error: Optional[Web3RPCError] = None
+        error = response["error"]
+
+        # raise the error when the value is a string
+        if error is None or not isinstance(error, dict):
+            _raise_bad_response_format(
+                response,
+                'response["error"] must be a valid object as defined by the '
+                "JSON-RPC 2.0 specification.",
+            )
+
+        # errors must include a message
+        error_message = error.get("message")
+        if not isinstance(error_message, str):
+            _raise_bad_response_format(
+                response, 'error["message"] is required and must be a string value.'
+            )
+        elif error_message == "transaction not found":
+            transaction_hash = params[0]
+            web3_rpc_error = TransactionNotFound(
+                repr(error),
+                rpc_response=response,
+                user_message=(f"Transaction with hash {transaction_hash!r} not found."),
+            )
+
+        # errors must include an integer code
+        code = error.get("code")
+        if not isinstance(code, int):
+            _raise_bad_response_format(
+                response, 'error["code"] is required and must be an integer value.'
+            )
+        elif code == METHOD_NOT_FOUND:
+            web3_rpc_error = MethodUnavailable(
+                repr(error),
+                rpc_response=response,
+                user_message=(
+                    "This method is not available. Check your node provider or your "
+                    "client's API docs to see what methods are supported and / or "
+                    "currently enabled."
+                ),
+            )
+        elif any(
+            # parse specific timeout messages
+            timeout_str in error_message.lower()
+            for timeout_str in KNOWN_REQUEST_TIMEOUT_MESSAGING
+        ):
+            web3_rpc_error = RequestTimedOut(
+                repr(error),
+                rpc_response=response,
+                user_message=(
+                    "The request timed out. Check the connection to your node and "
+                    "try again."
+                ),
+            )
+
+        if web3_rpc_error is None:
+            # if no condition was met above, raise a more generic `Web3RPCError`
+            web3_rpc_error = Web3RPCError(repr(error), rpc_response=response)
+
+        response = apply_error_formatters(error_formatters, response)
+        if logger is not None:
+            logger.debug(f"RPC error response: {response}")
+
+        raise web3_rpc_error
+
+    elif "result" not in response and not is_subscription_response:
+        _raise_bad_response_format(response)

web3/beacon/api_endpoints.py

@@ -59,6 +59,16 @@ GET_BEACON_HEADS = "/eth/v1/debug/beacon/heads"
 GET_NODE_IDENTITY = "/eth/v1/node/identity"
 GET_PEERS = "/eth/v1/node/peers"
 GET_PEER = "/eth/v1/node/peers/{0}"
+GET_PEER_COUNT = "/eth/v1/node/peer_count"
 GET_HEALTH = "/eth/v1/node/health"
 GET_VERSION = "/eth/v1/node/version"
 GET_SYNCING = "/eth/v1/node/syncing"
+
+# [ VALIDATOR endpoints ]
+
+GET_ATTESTER_DUTIES = "/eth/v1/validator/duties/attester/{0}"
+GET_BLOCK_PROPOSERS_DUTIES = "/eth/v1/validator/duties/proposer/{0}"
+GET_SYNC_COMMITTEE_DUTIES = "/eth/v1/validator/duties/sync/{0}"
+
+# [ REWARDS endpoints ]
+GET_ATTESTATIONS_REWARDS = "/eth/v1/beacon/rewards/attestations/{0}"

web3/beacon/async_beacon.py

@@ -3,6 +3,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Union,
 )
 
 from aiohttp import (
@@ -18,6 +19,8 @@ from web3._utils.http_session_manager import (
 )
 from web3.beacon.api_endpoints import (
     GET_ATTESTATIONS,
+    GET_ATTESTATIONS_REWARDS,
+    GET_ATTESTER_DUTIES,
     GET_ATTESTER_SLASHINGS,
     GET_BEACON_HEADS,
     GET_BEACON_STATE,
@@ -27,6 +30,7 @@ from web3.beacon.api_endpoints import (
     GET_BLOCK_ATTESTATIONS,
     GET_BLOCK_HEADER,
     GET_BLOCK_HEADERS,
+    GET_BLOCK_PROPOSERS_DUTIES,
     GET_BLOCK_ROOT,
     GET_BLS_TO_EXECUTION_CHANGES,
     GET_DEPOSIT_CONTRACT,
@@ -45,10 +49,12 @@ from web3.beacon.api_endpoints import (
     GET_LIGHT_CLIENT_UPDATES,
     GET_NODE_IDENTITY,
     GET_PEER,
+    GET_PEER_COUNT,
     GET_PEERS,
     GET_PROPOSER_SLASHINGS,
     GET_REWARDS,
     GET_SPEC,
+    GET_SYNC_COMMITTEE_DUTIES,
     GET_SYNCING,
     GET_VALIDATOR,
     GET_VALIDATOR_BALANCES,
@@ -78,6 +84,14 @@ class AsyncBeacon:
             uri, params=params, timeout=ClientTimeout(self.request_timeout)
         )
 
+    async def _async_make_post_request(
+        self, endpoint_uri: str, body: Union[List[str], Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        uri = URI(self.base_url + endpoint_uri)
+        return await self._request_session_manager.async_json_make_post_request(
+            uri, json=body, timeout=self.request_timeout
+        )
+
     # [ BEACON endpoints ]
 
     # states
@@ -216,6 +230,9 @@ class AsyncBeacon:
     async def get_peer(self, peer_id: str) -> Dict[str, Any]:
         return await self._async_make_get_request(GET_PEER.format(peer_id))
 
+    async def get_peer_count(self) -> Dict[str, Any]:
+        return await self._async_make_get_request(GET_PEER_COUNT)
+
     async def get_health(self) -> int:
         url = URI(self.base_url + GET_HEALTH)
         response = (
@@ -239,3 +256,33 @@ class AsyncBeacon:
             GET_BLOB_SIDECARS.format(block_id),
             params=indices_param,
         )
+
+    # [ VALIDATOR endpoints ]
+
+    async def get_attester_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return await self._async_make_post_request(
+            GET_ATTESTER_DUTIES.format(epoch), validator_indices
+        )
+
+    async def get_block_proposer_duties(self, epoch: str) -> Dict[str, Any]:
+        return await self._async_make_get_request(
+            GET_BLOCK_PROPOSERS_DUTIES.format(epoch)
+        )
+
+    async def get_sync_committee_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return await self._async_make_post_request(
+            GET_SYNC_COMMITTEE_DUTIES.format(epoch), validator_indices
+        )
+
+    # [ REWARDS endpoints ]
+
+    async def get_attestations_rewards(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return await self._async_make_post_request(
+            GET_ATTESTATIONS_REWARDS.format(epoch), validator_indices
+        )