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

web3/eth/async_eth.py

@@ -4,13 +4,7 @@ from typing import (
     Any,
     Awaitable,
     Callable,
-    Dict,
-    List,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
-    Union,
     cast,
     overload,
 )
@@ -123,19 +117,17 @@ class AsyncEth(BaseEth):
 
     is_async = True
 
-    _default_contract_factory: Type[
-        Union[AsyncContract, AsyncContractCaller]
-    ] = AsyncContract
+    _default_contract_factory: type[AsyncContract | AsyncContractCaller] = AsyncContract
 
     # eth_accounts
 
-    _accounts: Method[Callable[[], Awaitable[Tuple[ChecksumAddress]]]] = Method(
+    _accounts: Method[Callable[[], Awaitable[tuple[ChecksumAddress]]]] = Method(
         RPC.eth_accounts,
         is_property=True,
     )
 
     @property
-    async def accounts(self) -> Tuple[ChecksumAddress]:
+    async def accounts(self) -> tuple[ChecksumAddress]:
         return await self._accounts()
 
     # eth_blobBaseFee
@@ -208,20 +200,20 @@ class AsyncEth(BaseEth):
 
     # eth_syncing
 
-    _syncing: Method[Callable[[], Awaitable[Union[SyncStatus, bool]]]] = Method(
+    _syncing: Method[Callable[[], Awaitable[SyncStatus | bool]]] = Method(
         RPC.eth_syncing,
         is_property=True,
     )
 
     @property
-    async def syncing(self) -> Union[SyncStatus, bool]:
+    async def syncing(self) -> SyncStatus | bool:
         return await self._syncing()
 
     # eth_feeHistory
 
     _fee_history: Method[
         Callable[
-            [int, Union[BlockParams, BlockNumber], Optional[List[float]]],
+            [int, BlockParams | BlockNumber, list[float] | None],
             Awaitable[FeeHistory],
         ]
     ] = Method(RPC.eth_feeHistory, mungers=[default_root_munger])
@@ -229,8 +221,8 @@ class AsyncEth(BaseEth):
     async def fee_history(
         self,
         block_count: int,
-        newest_block: Union[BlockParams, BlockNumber],
-        reward_percentiles: Optional[List[float]] = None,
+        newest_block: BlockParams | BlockNumber,
+        reward_percentiles: list[float] | None = None,
     ) -> FeeHistory:
         reward_percentiles = reward_percentiles or []
         return await self._fee_history(block_count, newest_block, reward_percentiles)
@@ -241,8 +233,8 @@ class AsyncEth(BaseEth):
         Callable[
             [
                 TxParams,
-                Optional[BlockIdentifier],
-                Optional[StateOverride],
+                BlockIdentifier | None,
+                StateOverride | None,
             ],
             Awaitable[HexBytes],
         ]
@@ -251,9 +243,9 @@ class AsyncEth(BaseEth):
     async def call(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[StateOverride] = None,
-        ccip_read_enabled: Optional[bool] = None,
+        block_identifier: BlockIdentifier | None = None,
+        state_override: StateOverride | None = None,
+        ccip_read_enabled: bool | None = None,
     ) -> HexBytes:
         ccip_read_enabled_on_provider = self.w3.provider.global_ccip_read_enabled
         if (
@@ -272,8 +264,8 @@ class AsyncEth(BaseEth):
     async def _durin_call(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[StateOverride] = None,
+        block_identifier: BlockIdentifier | None = None,
+        state_override: StateOverride | None = None,
     ) -> HexBytes:
         max_redirects = self.w3.provider.ccip_read_max_redirects
 
@@ -314,7 +306,7 @@ class AsyncEth(BaseEth):
 
     _create_access_list: Method[
         Callable[
-            [TxParams, Optional[BlockIdentifier]],
+            [TxParams, BlockIdentifier | None],
             Awaitable[CreateAccessListResponse],
         ]
     ] = Method(RPC.eth_createAccessList, mungers=[BaseEth.create_access_list_munger])
@@ -322,7 +314,7 @@ class AsyncEth(BaseEth):
     async def create_access_list(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
+        block_identifier: BlockIdentifier | None = None,
     ) -> CreateAccessListResponse:
         return await self._create_access_list(transaction, block_identifier)
 
@@ -330,7 +322,7 @@ class AsyncEth(BaseEth):
 
     _estimate_gas: Method[
         Callable[
-            [TxParams, Optional[BlockIdentifier], Optional[StateOverride]],
+            [TxParams, BlockIdentifier | None, StateOverride | None],
             Awaitable[int],
         ]
     ] = Method(RPC.eth_estimateGas, mungers=[BaseEth.estimate_gas_munger])
@@ -338,8 +330,8 @@ class AsyncEth(BaseEth):
     async def estimate_gas(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[StateOverride] = None,
+        block_identifier: BlockIdentifier | None = None,
+        state_override: StateOverride | None = None,
     ) -> int:
         return await self._estimate_gas(transaction, block_identifier, state_override)
 
@@ -425,13 +417,13 @@ class AsyncEth(BaseEth):
     # eth_sendRawTransaction
 
     _send_raw_transaction: Method[
-        Callable[[Union[HexStr, bytes]], Awaitable[HexBytes]]
+        Callable[[HexStr | bytes], Awaitable[HexBytes]]
     ] = Method(
         RPC.eth_sendRawTransaction,
         mungers=[default_root_munger],
     )
 
-    async def send_raw_transaction(self, transaction: Union[HexStr, bytes]) -> HexBytes:
+    async def send_raw_transaction(self, transaction: HexStr | bytes) -> HexBytes:
         return await self._send_raw_transaction(transaction)
 
     # eth_getBlockByHash
@@ -449,7 +441,9 @@ class AsyncEth(BaseEth):
     )
 
     async def get_block(
-        self, block_identifier: BlockIdentifier, full_transactions: bool = False
+        self,
+        block_identifier: BlockIdentifier,
+        full_transactions: bool = False,
     ) -> BlockData:
         return await self._get_block(block_identifier, full_transactions)
 
@@ -471,7 +465,7 @@ class AsyncEth(BaseEth):
 
     _get_balance: Method[
         Callable[
-            [Union[Address, ChecksumAddress, ENS], Optional[BlockIdentifier]],
+            [Address | ChecksumAddress | ENS, BlockIdentifier | None],
             Awaitable[Wei],
         ]
     ] = Method(
@@ -481,8 +475,8 @@ class AsyncEth(BaseEth):
 
     async def get_balance(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
-        block_identifier: Optional[BlockIdentifier] = None,
+        account: Address | ChecksumAddress | ENS,
+        block_identifier: BlockIdentifier | None = None,
     ) -> Wei:
         return await self._get_balance(account, block_identifier)
 
@@ -490,35 +484,35 @@ class AsyncEth(BaseEth):
 
     _get_code: Method[
         Callable[
-            [Union[Address, ChecksumAddress, ENS], Optional[BlockIdentifier]],
+            [Address | ChecksumAddress | ENS, BlockIdentifier | None],
             Awaitable[HexBytes],
         ]
     ] = Method(RPC.eth_getCode, mungers=[BaseEth.block_id_munger])
 
     async def get_code(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
-        block_identifier: Optional[BlockIdentifier] = None,
+        account: Address | ChecksumAddress | ENS,
+        block_identifier: BlockIdentifier | None = None,
     ) -> HexBytes:
         return await self._get_code(account, block_identifier)
 
     # eth_getLogs
 
-    _get_logs: Method[Callable[[FilterParams], Awaitable[List[LogReceipt]]]] = Method(
+    _get_logs: Method[Callable[[FilterParams], Awaitable[list[LogReceipt]]]] = Method(
         RPC.eth_getLogs, mungers=[default_root_munger]
     )
 
     async def get_logs(
         self,
         filter_params: FilterParams,
-    ) -> List[LogReceipt]:
+    ) -> list[LogReceipt]:
         return await self._get_logs(filter_params)
 
     # eth_getTransactionCount
 
     _get_transaction_count: Method[
         Callable[
-            [Union[Address, ChecksumAddress, ENS], Optional[BlockIdentifier]],
+            [Address | ChecksumAddress | ENS, BlockIdentifier | None],
             Awaitable[Nonce],
         ]
     ] = Method(
@@ -528,8 +522,8 @@ class AsyncEth(BaseEth):
 
     async def get_transaction_count(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
-        block_identifier: Optional[BlockIdentifier] = None,
+        account: Address | ChecksumAddress | ENS,
+        block_identifier: BlockIdentifier | None = None,
     ) -> Nonce:
         return await self._get_transaction_count(account, block_identifier)
 
@@ -545,7 +539,7 @@ class AsyncEth(BaseEth):
     async def wait_for_transaction_receipt(
         self,
         transaction_hash: _Hash32,
-        timeout: Optional[float] = 120,
+        timeout: float | None = 120,
         poll_latency: float = 0.1,
     ) -> TxReceipt:
         async def _wait_for_tx_receipt_with_timeout(
@@ -576,7 +570,7 @@ class AsyncEth(BaseEth):
 
     _get_storage_at: Method[
         Callable[
-            [Union[Address, ChecksumAddress, ENS], int, Optional[BlockIdentifier]],
+            [Address | ChecksumAddress | ENS, int, BlockIdentifier | None],
             Awaitable[HexBytes],
         ]
     ] = Method(
@@ -586,9 +580,9 @@ class AsyncEth(BaseEth):
 
     async def get_storage_at(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
+        account: Address | ChecksumAddress | ENS,
         position: int,
-        block_identifier: Optional[BlockIdentifier] = None,
+        block_identifier: BlockIdentifier | None = None,
     ) -> HexBytes:
         return await self._get_storage_at(account, position, block_identifier)
 
@@ -627,8 +621,8 @@ class AsyncEth(BaseEth):
 
     async def sign(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
-        data: Union[int, bytes] = None,
+        account: Address | ChecksumAddress | ENS,
+        data: int | bytes = None,
         hexstr: HexStr = None,
         text: str = None,
     ) -> HexStr:
@@ -648,7 +642,8 @@ class AsyncEth(BaseEth):
 
     _sign_typed_data: Method[
         Callable[
-            [Union[Address, ChecksumAddress, ENS], Dict[str, Any]], Awaitable[HexStr]
+            [Address | ChecksumAddress | ENS, dict[str, Any]],
+            Awaitable[HexStr],
         ]
     ] = Method(
         RPC.eth_signTypedData,
@@ -656,7 +651,7 @@ class AsyncEth(BaseEth):
     )
 
     async def sign_typed_data(
-        self, account: Union[Address, ChecksumAddress, ENS], data: Dict[str, Any]
+        self, account: Address | ChecksumAddress | ENS, data: dict[str, Any]
     ) -> HexStr:
         return await self._sign_typed_data(account, data)
 
@@ -679,7 +674,7 @@ class AsyncEth(BaseEth):
     # eth_newFilter, eth_newBlockFilter, eth_newPendingTransactionFilter
 
     filter: Method[
-        Callable[[Optional[Union[str, FilterParams, HexStr]]], Awaitable[AsyncFilter]]
+        Callable[[str | FilterParams | HexStr | None], Awaitable[AsyncFilter]]
     ] = Method(
         method_choice_depends_on_args=select_filter_method(
             if_new_block_filter=RPC.eth_newBlockFilter,
@@ -692,17 +687,17 @@ class AsyncEth(BaseEth):
     # eth_getFilterChanges, eth_getFilterLogs, eth_uninstallFilter
 
     _get_filter_changes: Method[
-        Callable[[HexStr], Awaitable[List[LogReceipt]]]
+        Callable[[HexStr], Awaitable[list[LogReceipt]]]
     ] = Method(RPC.eth_getFilterChanges, mungers=[default_root_munger])
 
-    async def get_filter_changes(self, filter_id: HexStr) -> List[LogReceipt]:
+    async def get_filter_changes(self, filter_id: HexStr) -> list[LogReceipt]:
         return await self._get_filter_changes(filter_id)
 
-    _get_filter_logs: Method[Callable[[HexStr], Awaitable[List[LogReceipt]]]] = Method(
+    _get_filter_logs: Method[Callable[[HexStr], Awaitable[list[LogReceipt]]]] = Method(
         RPC.eth_getFilterLogs, mungers=[default_root_munger]
     )
 
-    async def get_filter_logs(self, filter_id: HexStr) -> List[LogReceipt]:
+    async def get_filter_logs(self, filter_id: HexStr) -> list[LogReceipt]:
         return await self._get_filter_logs(filter_id)
 
     _uninstall_filter: Method[Callable[[HexStr], Awaitable[bool]]] = Method(
@@ -723,16 +718,15 @@ class AsyncEth(BaseEth):
     async def subscribe(
         self,
         subscription_type: SubscriptionType,
-        subscription_arg: Optional[
-            Union[
-                LogsSubscriptionArg,  # logs, optional filter params
-                bool,  # newPendingTransactions, full_transactions
-            ]
-        ] = None,
-        handler: Optional[EthSubscriptionHandler] = None,
-        handler_context: Optional[Dict[str, Any]] = None,
-        label: Optional[str] = None,
-        parallelize: Optional[bool] = None,
+        subscription_arg: None
+        | (
+            LogsSubscriptionArg  # logs, optional filter params
+            | bool  # newPendingTransactions, full_transactions
+        ) = None,
+        handler: EthSubscriptionHandler | None = None,
+        handler_context: dict[str, Any] | None = None,
+        label: str | None = None,
+        parallelize: bool | None = None,
     ) -> HexStr:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
             raise MethodNotSupported(
@@ -773,20 +767,20 @@ class AsyncEth(BaseEth):
     # -- contract methods -- #
 
     @overload
-    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:
+    def contract(self, address: None = None, **kwargs: Any) -> type[AsyncContract]:
         ...
 
     @overload
     def contract(
-        self, address: Union[Address, ChecksumAddress, ENS], **kwargs: Any
+        self, address: Address | ChecksumAddress | ENS, **kwargs: Any
     ) -> AsyncContract:
         ...
 
     def contract(
         self,
-        address: Optional[Union[Address, ChecksumAddress, ENS]] = None,
+        address: Address | ChecksumAddress | ENS | None = None,
         **kwargs: Any,
-    ) -> Union[Type[AsyncContract], AsyncContract]:
+    ) -> type[AsyncContract] | AsyncContract:
         ContractFactoryClass = kwargs.pop(
             "ContractFactoryClass", self._default_contract_factory
         )
@@ -800,6 +794,6 @@ class AsyncEth(BaseEth):
 
     def set_contract_factory(
         self,
-        contract_factory: Type[Union[AsyncContract, AsyncContractCaller]],
+        contract_factory: type[AsyncContract | AsyncContractCaller],
     ) -> None:
         self._default_contract_factory = contract_factory

web3/eth/base_eth.py

@@ -1,10 +1,6 @@
 from typing import (
     Any,
-    List,
     NoReturn,
-    Optional,
-    Tuple,
-    Union,
 )
 
 from eth_account import (
@@ -49,7 +45,7 @@ from web3.types import (
 
 
 class BaseEth(Module):
-    _default_account: Union[ChecksumAddress, Empty] = empty
+    _default_account: ChecksumAddress | Empty = empty
     _default_block: BlockIdentifier = "latest"
     _default_contract_factory: Any = None
     _gas_price_strategy = None
@@ -72,40 +68,40 @@ class BaseEth(Module):
         self._default_block = value
 
     @property
-    def default_account(self) -> Union[ChecksumAddress, Empty]:
+    def default_account(self) -> ChecksumAddress | Empty:
         return self._default_account
 
     @default_account.setter
-    def default_account(self, account: Union[ChecksumAddress, Empty]) -> None:
+    def default_account(self, account: ChecksumAddress | Empty) -> None:
         self._default_account = account
 
-    def send_transaction_munger(self, transaction: TxParams) -> Tuple[TxParams]:
+    def send_transaction_munger(self, transaction: TxParams) -> tuple[TxParams]:
         if "from" not in transaction and is_checksum_address(self.default_account):
             transaction = assoc(transaction, "from", self.default_account)
 
         return (transaction,)
 
     def generate_gas_price(
-        self, transaction_params: Optional[TxParams] = None
-    ) -> Optional[Wei]:
+        self, transaction_params: TxParams | None = None
+    ) -> Wei | None:
         if self._gas_price_strategy:
             return self._gas_price_strategy(self.w3, transaction_params)
         return None
 
     def set_gas_price_strategy(
-        self, gas_price_strategy: Optional[GasPriceStrategy]
+        self, gas_price_strategy: GasPriceStrategy | None
     ) -> None:
         self._gas_price_strategy = gas_price_strategy
 
     def _eth_call_and_estimate_gas_munger(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[StateOverride] = None,
-    ) -> Union[
-        Tuple[TxParams, BlockIdentifier],
-        Tuple[TxParams, BlockIdentifier, StateOverride],
-    ]:
+        block_identifier: BlockIdentifier | None = None,
+        state_override: StateOverride | None = None,
+    ) -> (
+        tuple[TxParams, BlockIdentifier]
+        | tuple[TxParams, BlockIdentifier, StateOverride]
+    ):
         # TODO: move to middleware
         if "from" not in transaction and is_checksum_address(self.default_account):
             transaction = assoc(transaction, "from", self.default_account)
@@ -122,36 +118,36 @@ class BaseEth(Module):
     def estimate_gas_munger(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[StateOverride] = None,
-    ) -> Union[
-        Tuple[TxParams, BlockIdentifier],
-        Tuple[TxParams, BlockIdentifier, StateOverride],
-    ]:
+        block_identifier: BlockIdentifier | None = None,
+        state_override: StateOverride | None = None,
+    ) -> (
+        tuple[TxParams, BlockIdentifier]
+        | tuple[TxParams, BlockIdentifier, StateOverride]
+    ):
         return self._eth_call_and_estimate_gas_munger(
             transaction, block_identifier, state_override
         )
 
     def get_block_munger(
         self, block_identifier: BlockIdentifier, full_transactions: bool = False
-    ) -> Tuple[BlockIdentifier, bool]:
+    ) -> tuple[BlockIdentifier, bool]:
         return (block_identifier, full_transactions)
 
     def block_id_munger(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
-        block_identifier: Optional[BlockIdentifier] = None,
-    ) -> Tuple[Union[Address, ChecksumAddress, ENS], BlockIdentifier]:
+        account: Address | ChecksumAddress | ENS,
+        block_identifier: BlockIdentifier | None = None,
+    ) -> tuple[Address | ChecksumAddress | ENS, BlockIdentifier]:
         if block_identifier is None:
             block_identifier = self.default_block
         return (account, block_identifier)
 
     def get_storage_at_munger(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
+        account: Address | ChecksumAddress | ENS,
         position: int,
-        block_identifier: Optional[BlockIdentifier] = None,
-    ) -> Tuple[Union[Address, ChecksumAddress, ENS], int, BlockIdentifier]:
+        block_identifier: BlockIdentifier | None = None,
+    ) -> tuple[Address | ChecksumAddress | ENS, int, BlockIdentifier]:
         if block_identifier is None:
             block_identifier = self.default_block
         return (account, position, block_identifier)
@@ -159,19 +155,19 @@ class BaseEth(Module):
     def call_munger(
         self,
         transaction: TxParams,
-        block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[StateOverride] = None,
-    ) -> Union[
-        Tuple[TxParams, BlockIdentifier],
-        Tuple[TxParams, BlockIdentifier, StateOverride],
-    ]:
+        block_identifier: BlockIdentifier | None = None,
+        state_override: StateOverride | None = None,
+    ) -> (
+        tuple[TxParams, BlockIdentifier]
+        | tuple[TxParams, BlockIdentifier, StateOverride]
+    ):
         return self._eth_call_and_estimate_gas_munger(
             transaction, block_identifier, state_override
         )
 
     def create_access_list_munger(
-        self, transaction: TxParams, block_identifier: Optional[BlockIdentifier] = None
-    ) -> Tuple[TxParams, BlockIdentifier]:
+        self, transaction: TxParams, block_identifier: BlockIdentifier | None = None
+    ) -> tuple[TxParams, BlockIdentifier]:
         # TODO: move to middleware
         if "from" not in transaction and is_checksum_address(self.default_account):
             transaction = assoc(transaction, "from", self.default_account)
@@ -184,19 +180,19 @@ class BaseEth(Module):
 
     def sign_munger(
         self,
-        account: Union[Address, ChecksumAddress, ENS],
-        data: Union[int, bytes] = None,
+        account: Address | ChecksumAddress | ENS,
+        data: int | bytes = None,
         hexstr: HexStr = None,
         text: str = None,
-    ) -> Tuple[Union[Address, ChecksumAddress, ENS], HexStr]:
+    ) -> tuple[Address | ChecksumAddress | ENS, HexStr]:
         message_hex = to_hex(data, hexstr=hexstr, text=text)
         return (account, message_hex)
 
     def filter_munger(
         self,
-        filter_params: Optional[Union[str, FilterParams]] = None,
-        filter_id: Optional[HexStr] = None,
-    ) -> Union[List[FilterParams], List[HexStr], List[str]]:
+        filter_params: str | FilterParams | None = None,
+        filter_id: HexStr | None = None,
+    ) -> list[FilterParams] | list[HexStr] | list[str]:
         if filter_id and filter_params:
             raise Web3TypeError(
                 "Ambiguous invocation: provide either a `filter_params` or a "