web3 7.14.1__py3-none-any.whl → 8.0.0b1__py3-none-any.whl

web3/beacon/async_beacon.py

@@ -1,9 +1,5 @@
 from typing import (
     Any,
-    Dict,
-    List,
-    Optional,
-    Union,
 )
 
 from aiohttp import (
@@ -77,16 +73,16 @@ class AsyncBeacon:
         self._request_session_manager = HTTPSessionManager()
 
     async def _async_make_get_request(
-        self, endpoint_uri: str, params: Optional[Dict[str, str]] = None
-    ) -> Dict[str, Any]:
+        self, endpoint_uri: str, params: dict[str, str] | None = None
+    ) -> dict[str, Any]:
         uri = URI(self.base_url + endpoint_uri)
         return await self._request_session_manager.async_json_make_get_request(
             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]:
+        self, endpoint_uri: str, body: 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=ClientTimeout(self.request_timeout)
@@ -96,141 +92,141 @@ class AsyncBeacon:
 
     # states
 
-    async def get_genesis(self) -> Dict[str, Any]:
+    async def get_genesis(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_GENESIS)
 
-    async def get_hash_root(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_hash_root(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(GET_HASH_ROOT.format(state_id))
 
-    async def get_fork_data(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_fork_data(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(GET_FORK_DATA.format(state_id))
 
-    async def get_finality_checkpoint(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_finality_checkpoint(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(
             GET_FINALITY_CHECKPOINT.format(state_id)
         )
 
-    async def get_validators(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_validators(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(GET_VALIDATORS.format(state_id))
 
     async def get_validator(
         self, validator_id: str, state_id: str = "head"
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return await self._async_make_get_request(
             GET_VALIDATOR.format(state_id, validator_id)
         )
 
-    async def get_validator_balances(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_validator_balances(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(
             GET_VALIDATOR_BALANCES.format(state_id)
         )
 
-    async def get_epoch_committees(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_epoch_committees(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(GET_EPOCH_COMMITTEES.format(state_id))
 
-    async def get_epoch_sync_committees(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_epoch_sync_committees(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(
             GET_EPOCH_SYNC_COMMITTEES.format(state_id)
         )
 
-    async def get_epoch_randao(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_epoch_randao(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(GET_EPOCH_RANDAO.format(state_id))
 
     # headers
 
-    async def get_block_headers(self) -> Dict[str, Any]:
+    async def get_block_headers(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BLOCK_HEADERS)
 
-    async def get_block_header(self, block_id: str) -> Dict[str, Any]:
+    async def get_block_header(self, block_id: str) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BLOCK_HEADER.format(block_id))
 
     # block
 
-    async def get_block(self, block_id: str) -> Dict[str, Any]:
+    async def get_block(self, block_id: str) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BLOCK.format(block_id))
 
-    async def get_block_root(self, block_id: str) -> Dict[str, Any]:
+    async def get_block_root(self, block_id: str) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BLOCK_ROOT.format(block_id))
 
-    async def get_block_attestations(self, block_id: str) -> Dict[str, Any]:
+    async def get_block_attestations(self, block_id: str) -> dict[str, Any]:
         return await self._async_make_get_request(
             GET_BLOCK_ATTESTATIONS.format(block_id)
         )
 
-    async def get_blinded_blocks(self, block_id: str) -> Dict[str, Any]:
+    async def get_blinded_blocks(self, block_id: str) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BLINDED_BLOCKS.format(block_id))
 
     # rewards
 
-    async def get_rewards(self, block_id: str) -> Dict[str, Any]:
+    async def get_rewards(self, block_id: str) -> dict[str, Any]:
         return await self._async_make_get_request(GET_REWARDS.format(block_id))
 
     # light client (untested but follows spec)
 
     async def get_light_client_bootstrap_structure(
         self, block_root: HexStr
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return await self._async_make_get_request(
             GET_LIGHT_CLIENT_BOOTSTRAP_STRUCTURE.format(block_root)
         )
 
-    async def get_light_client_updates(self) -> Dict[str, Any]:
+    async def get_light_client_updates(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_LIGHT_CLIENT_UPDATES)
 
-    async def get_light_client_finality_update(self) -> Dict[str, Any]:
+    async def get_light_client_finality_update(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_LIGHT_CLIENT_FINALITY_UPDATE)
 
-    async def get_light_client_optimistic_update(self) -> Dict[str, Any]:
+    async def get_light_client_optimistic_update(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_LIGHT_CLIENT_OPTIMISTIC_UPDATE)
 
     # pool
 
-    async def get_attestations(self) -> Dict[str, Any]:
+    async def get_attestations(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_ATTESTATIONS)
 
-    async def get_attester_slashings(self) -> Dict[str, Any]:
+    async def get_attester_slashings(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_ATTESTER_SLASHINGS)
 
-    async def get_proposer_slashings(self) -> Dict[str, Any]:
+    async def get_proposer_slashings(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_PROPOSER_SLASHINGS)
 
-    async def get_voluntary_exits(self) -> Dict[str, Any]:
+    async def get_voluntary_exits(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_VOLUNTARY_EXITS)
 
-    async def get_bls_to_execution_changes(self) -> Dict[str, Any]:
+    async def get_bls_to_execution_changes(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BLS_TO_EXECUTION_CHANGES)
 
     # [ CONFIG endpoints ]
 
-    async def get_fork_schedule(self) -> Dict[str, Any]:
+    async def get_fork_schedule(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_FORK_SCHEDULE)
 
-    async def get_spec(self) -> Dict[str, Any]:
+    async def get_spec(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_SPEC)
 
-    async def get_deposit_contract(self) -> Dict[str, Any]:
+    async def get_deposit_contract(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_DEPOSIT_CONTRACT)
 
     # [ DEBUG endpoints ]
 
-    async def get_beacon_state(self, state_id: str = "head") -> Dict[str, Any]:
+    async def get_beacon_state(self, state_id: str = "head") -> dict[str, Any]:
         return await self._async_make_get_request(GET_BEACON_STATE.format(state_id))
 
-    async def get_beacon_heads(self) -> Dict[str, Any]:
+    async def get_beacon_heads(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_BEACON_HEADS)
 
     # [ NODE endpoints ]
 
-    async def get_node_identity(self) -> Dict[str, Any]:
+    async def get_node_identity(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_NODE_IDENTITY)
 
-    async def get_peers(self) -> Dict[str, Any]:
+    async def get_peers(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_PEERS)
 
-    async def get_peer(self, peer_id: str) -> Dict[str, Any]:
+    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]:
+    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:
@@ -240,17 +236,17 @@ class AsyncBeacon:
         )
         return response.status
 
-    async def get_version(self) -> Dict[str, Any]:
+    async def get_version(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_VERSION)
 
-    async def get_syncing(self) -> Dict[str, Any]:
+    async def get_syncing(self) -> dict[str, Any]:
         return await self._async_make_get_request(GET_SYNCING)
 
     # [ BLOB endpoints ]
 
     async def get_blob_sidecars(
-        self, block_id: str, indices: Optional[List[int]] = None
-    ) -> Dict[str, Any]:
+        self, block_id: str, indices: list[int] | None = None
+    ) -> dict[str, Any]:
         indices_param = {"indices": ",".join(map(str, indices))} if indices else None
         return await self._async_make_get_request(
             GET_BLOB_SIDECARS.format(block_id),
@@ -260,20 +256,20 @@ class AsyncBeacon:
     # [ VALIDATOR endpoints ]
 
     async def get_attester_duties(
-        self, epoch: str, validator_indices: List[str]
-    ) -> Dict[str, Any]:
+        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]:
+    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]:
+        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
         )
@@ -281,8 +277,8 @@ class AsyncBeacon:
     # [ REWARDS endpoints ]
 
     async def get_attestations_rewards(
-        self, epoch: str, validator_indices: List[str]
-    ) -> Dict[str, Any]:
+        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

@@ -1,9 +1,5 @@
 from typing import (
     Any,
-    Dict,
-    List,
-    Optional,
-    Union,
 )
 
 from eth_typing import (
@@ -72,16 +68,16 @@ class Beacon:
         self._request_session_manager = HTTPSessionManager()
 
     def _make_get_request(
-        self, endpoint_url: str, params: Optional[Dict[str, str]] = None
-    ) -> Dict[str, Any]:
+        self, endpoint_url: str, params: dict[str, str] | None = None
+    ) -> dict[str, Any]:
         uri = URI(self.base_url + endpoint_url)
         return self._request_session_manager.json_make_get_request(
             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]:
+        self, endpoint_url: str, body: 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
@@ -91,131 +87,131 @@ class Beacon:
 
     # states
 
-    def get_genesis(self) -> Dict[str, Any]:
+    def get_genesis(self) -> dict[str, Any]:
         return self._make_get_request(GET_GENESIS)
 
-    def get_hash_root(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_hash_root(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_HASH_ROOT.format(state_id))
 
-    def get_fork_data(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_fork_data(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_FORK_DATA.format(state_id))
 
-    def get_finality_checkpoint(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_finality_checkpoint(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_FINALITY_CHECKPOINT.format(state_id))
 
-    def get_validators(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_validators(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_VALIDATORS.format(state_id))
 
     def get_validator(
         self, validator_id: str, state_id: str = "head"
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return self._make_get_request(GET_VALIDATOR.format(state_id, validator_id))
 
-    def get_validator_balances(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_validator_balances(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_VALIDATOR_BALANCES.format(state_id))
 
-    def get_epoch_committees(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_epoch_committees(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_EPOCH_COMMITTEES.format(state_id))
 
-    def get_epoch_sync_committees(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_epoch_sync_committees(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_EPOCH_SYNC_COMMITTEES.format(state_id))
 
-    def get_epoch_randao(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_epoch_randao(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_EPOCH_RANDAO.format(state_id))
 
     # headers
 
-    def get_block_headers(self) -> Dict[str, Any]:
+    def get_block_headers(self) -> dict[str, Any]:
         return self._make_get_request(GET_BLOCK_HEADERS)
 
-    def get_block_header(self, block_id: str) -> Dict[str, Any]:
+    def get_block_header(self, block_id: str) -> dict[str, Any]:
         return self._make_get_request(GET_BLOCK_HEADER.format(block_id))
 
     # blocks
 
-    def get_block(self, block_id: str) -> Dict[str, Any]:
+    def get_block(self, block_id: str) -> dict[str, Any]:
         return self._make_get_request(GET_BLOCK.format(block_id))
 
-    def get_block_root(self, block_id: str) -> Dict[str, Any]:
+    def get_block_root(self, block_id: str) -> dict[str, Any]:
         return self._make_get_request(GET_BLOCK_ROOT.format(block_id))
 
-    def get_block_attestations(self, block_id: str) -> Dict[str, Any]:
+    def get_block_attestations(self, block_id: str) -> dict[str, Any]:
         return self._make_get_request(GET_BLOCK_ATTESTATIONS.format(block_id))
 
-    def get_blinded_blocks(self, block_id: str) -> Dict[str, Any]:
+    def get_blinded_blocks(self, block_id: str) -> dict[str, Any]:
         return self._make_get_request(GET_BLINDED_BLOCKS.format(block_id))
 
     # rewards
 
-    def get_rewards(self, block_id: str) -> Dict[str, Any]:
+    def get_rewards(self, block_id: str) -> dict[str, Any]:
         return self._make_get_request(GET_REWARDS.format(block_id))
 
     # light client (untested but follows spec)
 
     def get_light_client_bootstrap_structure(
         self, block_root: HexStr
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         return self._make_get_request(
             GET_LIGHT_CLIENT_BOOTSTRAP_STRUCTURE.format(block_root)
         )
 
-    def get_light_client_updates(self) -> Dict[str, Any]:
+    def get_light_client_updates(self) -> dict[str, Any]:
         return self._make_get_request(GET_LIGHT_CLIENT_UPDATES)
 
-    def get_light_client_finality_update(self) -> Dict[str, Any]:
+    def get_light_client_finality_update(self) -> dict[str, Any]:
         return self._make_get_request(GET_LIGHT_CLIENT_FINALITY_UPDATE)
 
-    def get_light_client_optimistic_update(self) -> Dict[str, Any]:
+    def get_light_client_optimistic_update(self) -> dict[str, Any]:
         return self._make_get_request(GET_LIGHT_CLIENT_OPTIMISTIC_UPDATE)
 
     # pool
 
-    def get_attestations(self) -> Dict[str, Any]:
+    def get_attestations(self) -> dict[str, Any]:
         return self._make_get_request(GET_ATTESTATIONS)
 
-    def get_attester_slashings(self) -> Dict[str, Any]:
+    def get_attester_slashings(self) -> dict[str, Any]:
         return self._make_get_request(GET_ATTESTER_SLASHINGS)
 
-    def get_proposer_slashings(self) -> Dict[str, Any]:
+    def get_proposer_slashings(self) -> dict[str, Any]:
         return self._make_get_request(GET_PROPOSER_SLASHINGS)
 
-    def get_voluntary_exits(self) -> Dict[str, Any]:
+    def get_voluntary_exits(self) -> dict[str, Any]:
         return self._make_get_request(GET_VOLUNTARY_EXITS)
 
-    def get_bls_to_execution_changes(self) -> Dict[str, Any]:
+    def get_bls_to_execution_changes(self) -> dict[str, Any]:
         return self._make_get_request(GET_BLS_TO_EXECUTION_CHANGES)
 
     # [ CONFIG endpoints ]
 
-    def get_fork_schedule(self) -> Dict[str, Any]:
+    def get_fork_schedule(self) -> dict[str, Any]:
         return self._make_get_request(GET_FORK_SCHEDULE)
 
-    def get_spec(self) -> Dict[str, Any]:
+    def get_spec(self) -> dict[str, Any]:
         return self._make_get_request(GET_SPEC)
 
-    def get_deposit_contract(self) -> Dict[str, Any]:
+    def get_deposit_contract(self) -> dict[str, Any]:
         return self._make_get_request(GET_DEPOSIT_CONTRACT)
 
     # [ DEBUG endpoints ]
 
-    def get_beacon_state(self, state_id: str = "head") -> Dict[str, Any]:
+    def get_beacon_state(self, state_id: str = "head") -> dict[str, Any]:
         return self._make_get_request(GET_BEACON_STATE.format(state_id))
 
-    def get_beacon_heads(self) -> Dict[str, Any]:
+    def get_beacon_heads(self) -> dict[str, Any]:
         return self._make_get_request(GET_BEACON_HEADS)
 
     # [ NODE endpoints ]
 
-    def get_node_identity(self) -> Dict[str, Any]:
+    def get_node_identity(self) -> dict[str, Any]:
         return self._make_get_request(GET_NODE_IDENTITY)
 
-    def get_peers(self) -> Dict[str, Any]:
+    def get_peers(self) -> dict[str, Any]:
         return self._make_get_request(GET_PEERS)
 
-    def get_peer(self, peer_id: str) -> Dict[str, Any]:
+    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]:
+    def get_peer_count(self) -> dict[str, Any]:
         return self._make_get_request(GET_PEER_COUNT)
 
     def get_health(self) -> int:
@@ -223,17 +219,17 @@ class Beacon:
         response = self._request_session_manager.get_response_from_get_request(url)
         return response.status_code
 
-    def get_version(self) -> Dict[str, Any]:
+    def get_version(self) -> dict[str, Any]:
         return self._make_get_request(GET_VERSION)
 
-    def get_syncing(self) -> Dict[str, Any]:
+    def get_syncing(self) -> dict[str, Any]:
         return self._make_get_request(GET_SYNCING)
 
     # [ BLOB endpoints ]
 
     def get_blob_sidecars(
-        self, block_id: str, indices: Optional[List[int]] = None
-    ) -> Dict[str, Any]:
+        self, block_id: str, indices: list[int] | None = None
+    ) -> dict[str, Any]:
         indices_param = {"indices": ",".join(map(str, indices))} if indices else None
         return self._make_get_request(
             GET_BLOB_SIDECARS.format(block_id),
@@ -243,18 +239,18 @@ class Beacon:
     # [ VALIDATOR endpoints ]
 
     def get_attester_duties(
-        self, epoch: str, validator_indices: List[str]
-    ) -> Dict[str, Any]:
+        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]:
+    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]:
+        self, epoch: str, validator_indices: list[str]
+    ) -> dict[str, Any]:
         return self._make_post_request(
             GET_SYNC_COMMITTEE_DUTIES.format(epoch), validator_indices
         )
@@ -262,8 +258,8 @@ class Beacon:
     # [ REWARDS endpoints ]
 
     def get_attestations_rewards(
-        self, epoch: str, validator_indices: List[str]
-    ) -> Dict[str, Any]:
+        self, epoch: str, validator_indices: list[str]
+    ) -> dict[str, Any]:
         return self._make_post_request(
             GET_ATTESTATIONS_REWARDS.format(epoch), validator_indices
         )