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

ens/async_ens.py

@@ -152,12 +152,12 @@ class AsyncENS(BaseENS):
         :param int coin_type: if provided, look up the address for this coin type
         :raises InvalidName: if `name` has invalid syntax
         """
-        r = await self.resolver(name)
         if coin_type is None:
             # don't validate `addr(bytes32)` interface id since extended resolvers
             # can implement a "resolve" function as of ENSIP-10
             return cast(ChecksumAddress, await self._resolve(name, "addr"))
         else:
+            r = await self.resolver(name)
             await _async_validate_resolver_and_interface_id(
                 name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
             )

ens/ens.py

@@ -154,12 +154,12 @@ class ENS(BaseENS):
         :raises UnsupportedFunction: if the resolver does not support the ``addr()``
                 function
         """
-        r = self.resolver(name)
         if coin_type is None:
             # don't validate `addr(bytes32)` interface id since extended resolvers
             # can implement a "resolve" function as of ENSIP-10
             return cast(ChecksumAddress, self._resolve(name, "addr"))
         else:
+            r = self.resolver(name)
             _validate_resolver_and_interface_id(
                 name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
             )

web3/_utils/events.py

@@ -325,7 +325,7 @@ normalize_topic_list = compose(
 
 
 def is_indexed(arg: Any) -> bool:
-    if isinstance(arg, TopicArgumentFilter) is True:
+    if isinstance(arg, TopicArgumentFilter):
         return True
     return False
 

web3/_utils/http_session_manager.py

@@ -120,11 +120,19 @@ class HTTPSessionManager:
     def get_response_from_post_request(
         self, endpoint_uri: URI, *args: Any, **kwargs: Any
     ) -> requests.Response:
+        kwargs.setdefault("timeout", DEFAULT_HTTP_TIMEOUT)
         session = self.cache_and_return_session(
             endpoint_uri, request_timeout=kwargs["timeout"]
         )
         return session.post(endpoint_uri, *args, **kwargs)
 
+    def json_make_post_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        response = self.get_response_from_post_request(endpoint_uri, *args, **kwargs)
+        response.raise_for_status()
+        return response.json()
+
     def make_post_request(
         self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
     ) -> bytes:
@@ -143,8 +151,9 @@ class HTTPSessionManager:
             else:
                 return response.content
 
+    @staticmethod
     def _handle_streaming_response(
-        self, response: requests.Response, start: float, timeout: float
+        response: requests.Response, start: float, timeout: float
     ) -> bytes:
         response_body = b""
         for data in response.iter_content():
@@ -289,6 +298,15 @@ class HTTPSessionManager:
         response = await session.post(endpoint_uri, *args, **kwargs)
         return response
 
+    async def async_json_make_post_request(
+        self, endpoint_uri: URI, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        response = await self.async_get_response_from_post_request(
+            endpoint_uri, *args, **kwargs
+        )
+        response.raise_for_status()
+        return await response.json()
+
     async def async_make_post_request(
         self, endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
     ) -> bytes:

web3/_utils/module_testing/eth_module.py

@@ -2388,6 +2388,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 +2412,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 +2441,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

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

@@ -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/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
+        )

web3/beacon/beacon.py

@@ -3,6 +3,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Union,
 )
 
 from eth_typing import (
@@ -15,6 +16,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,
@@ -24,6 +27,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,
@@ -42,10 +46,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,
@@ -73,6 +79,14 @@ class Beacon:
             uri, params=params, timeout=self.request_timeout
         )
 
+    def _make_post_request(
+        self, endpoint_url: str, body: Union[List[str], Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        uri = URI(self.base_url + endpoint_url)
+        return self._request_session_manager.json_make_post_request(
+            uri, json=body, timeout=self.request_timeout
+        )
+
     # [ BEACON endpoints ]
 
     # states
@@ -201,6 +215,9 @@ class Beacon:
     def get_peer(self, peer_id: str) -> Dict[str, Any]:
         return self._make_get_request(GET_PEER.format(peer_id))
 
+    def get_peer_count(self) -> Dict[str, Any]:
+        return self._make_get_request(GET_PEER_COUNT)
+
     def get_health(self) -> int:
         url = URI(self.base_url + GET_HEALTH)
         response = self._request_session_manager.get_response_from_get_request(url)
@@ -222,3 +239,31 @@ class Beacon:
             GET_BLOB_SIDECARS.format(block_id),
             params=indices_param,
         )
+
+    # [ VALIDATOR endpoints ]
+
+    def get_attester_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return self._make_post_request(
+            GET_ATTESTER_DUTIES.format(epoch), validator_indices
+        )
+
+    def get_block_proposer_duties(self, epoch: str) -> Dict[str, Any]:
+        return self._make_get_request(GET_BLOCK_PROPOSERS_DUTIES.format(epoch))
+
+    def get_sync_committee_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return self._make_post_request(
+            GET_SYNC_COMMITTEE_DUTIES.format(epoch), validator_indices
+        )
+
+    # [ REWARDS endpoints ]
+
+    def get_attestations_rewards(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return self._make_post_request(
+            GET_ATTESTATIONS_REWARDS.format(epoch), validator_indices
+        )