web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/datastructures.py

@@ -15,7 +15,6 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
-    Type,
     TypeVar,
     Union,
     cast,
@@ -25,8 +24,10 @@ from eth_utils import (
     is_integer,
 )
 
-from web3._utils.formatters import (
-    recursive_map,
+from web3.exceptions import (
+    Web3AssertionError,
+    Web3TypeError,
+    Web3ValueError,
 )
 
 # Hashable must be immutable:
@@ -76,16 +77,18 @@ class ReadableAttributeDict(Mapping[TKey, TValue]):
         builder.text(")")
 
     @classmethod
-    def _apply_if_mapping(cls: Type[T], value: TValue) -> Union[T, TValue]:
+    def recursive(cls, value: TValue) -> Any:
+        """
+        Recursively convert mappings to ReadableAttributeDict instances and
+        process nested collections (e.g., lists, sets, and dictionaries).
+        """
         if isinstance(value, Mapping):
-            # error: Too many arguments for "object"
-            return cls(value)  # type: ignore
-        else:
-            return value
-
-    @classmethod
-    def recursive(cls, value: TValue) -> "ReadableAttributeDict[TKey, TValue]":
-        return recursive_map(cls._apply_if_mapping, value)
+            return cls({k: cls.recursive(v) for k, v in value.items()})
+        elif isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+            return type(value)([cls.recursive(v) for v in value])  # type: ignore
+        elif isinstance(value, set):
+            return {cls.recursive(v) for v in value}
+        return value
 
 
 class MutableAttributeDict(
@@ -100,19 +103,21 @@ class MutableAttributeDict(
 
 class AttributeDict(ReadableAttributeDict[TKey, TValue], Hashable):
     """
-    This provides superficial immutability, someone could hack around it
+    Provides superficial immutability, someone could hack around it
     """
 
     def __setattr__(self, attr: str, val: TValue) -> None:
         if attr == "__dict__":
             super().__setattr__(attr, val)
         else:
-            raise TypeError(
+            raise Web3TypeError(
                 "This data is immutable -- create a copy instead of modifying"
             )
 
     def __delattr__(self, key: str) -> None:
-        raise TypeError("This data is immutable -- create a copy instead of modifying")
+        raise Web3TypeError(
+            "This data is immutable -- create a copy instead of modifying"
+        )
 
     def __hash__(self) -> int:
         return hash(tuple(sorted(tupleize_lists_nested(self).items())))
@@ -143,7 +148,7 @@ def tupleize_lists_nested(d: Mapping[TKey, TValue]) -> AttributeDict[TKey, TValu
         elif isinstance(v, Mapping):
             ret[k] = tupleize_lists_nested(v)
         elif not isinstance(v, Hashable):
-            raise TypeError(f"Found unhashable type '{type(v).__name__}': {v}")
+            raise Web3TypeError(f"Found unhashable type '{type(v).__name__}': {v}")
         else:
             ret[k] = v
     return AttributeDict(ret)
@@ -172,13 +177,13 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         if name is None:
             name = cast(TKey, element)
 
-        name = self._repr_if_not_hashable(name)
+        name = self._build_name(name)
 
         if name in self._queue:
             if name is element:
-                raise ValueError("You can't add the same un-named instance twice")
+                raise Web3ValueError("You can't add the same un-named instance twice")
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "You can't add the same name again, use replace instead"
                 )
 
@@ -195,7 +200,7 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         to calling :meth:`add` .
         """
         if not is_integer(layer):
-            raise TypeError("The layer for insertion must be an int.")
+            raise Web3TypeError("The layer for insertion must be an int.")
         elif layer != 0 and layer != len(self._queue):
             raise NotImplementedError(
                 f"You can only insert to the beginning or end of a {type(self)}, "
@@ -209,13 +214,13 @@ class NamedElementOnion(Mapping[TKey, TValue]):
             if name is None:
                 name = cast(TKey, element)
 
-            name = self._repr_if_not_hashable(name)
+            name = self._build_name(name)
 
             self._queue.move_to_end(name, last=False)
         elif layer == len(self._queue):
             return
         else:
-            raise AssertionError(
+            raise Web3AssertionError(
                 "Impossible to reach: earlier validation raises an error"
             )
 
@@ -223,10 +228,10 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         self._queue.clear()
 
     def replace(self, old: TKey, new: TKey) -> TValue:
-        old_name = self._repr_if_not_hashable(old)
+        old_name = self._build_name(old)
 
         if old_name not in self._queue:
-            raise ValueError(
+            raise Web3ValueError(
                 "You can't replace unless one already exists, use add instead"
             )
 
@@ -238,17 +243,27 @@ class NamedElementOnion(Mapping[TKey, TValue]):
             self._queue[old_name] = new
         return to_be_replaced
 
-    def _repr_if_not_hashable(self, value: TKey) -> TKey:
+    @staticmethod
+    def _build_name(value: TKey) -> TKey:
         try:
             value.__hash__()
+            return value
         except TypeError:
-            value = cast(TKey, repr(value))
-        return value
+            # unhashable, unnamed elements
+            if not callable(value):
+                raise Web3TypeError(
+                    f"Expected a callable or hashable type, got {type(value)}"
+                )
+            # This will either be ``Web3Middleware`` class or the ``build`` method of a
+            # ``Web3MiddlewareBuilder``. Instantiate with empty ``Web3`` and use a
+            # unique identifier with the ``__hash__()`` as the name.
+            v = value(None)
+            return cast(TKey, f"{v.__class__}<{v.__hash__()}>")
 
     def remove(self, old: TKey) -> None:
-        old_name = self._repr_if_not_hashable(old)
+        old_name = self._build_name(old)
         if old_name not in self._queue:
-            raise ValueError("You can only remove something that has been added")
+            raise Web3ValueError("You can only remove something that has been added")
         del self._queue[old_name]
 
     @property
@@ -260,8 +275,8 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         return [(val, key) for key, val in reversed(self._queue.items())]
 
     def _replace_with_new_name(self, old: TKey, new: TKey) -> None:
-        old_name = self._repr_if_not_hashable(old)
-        new_name = self._repr_if_not_hashable(new)
+        old_name = self._build_name(old)
+        new_name = self._build_name(new)
 
         self._queue[new_name] = new
         found_old = False
@@ -283,11 +298,11 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         return NamedElementOnion(cast(List[Any], combined.items()))
 
     def __contains__(self, element: Any) -> bool:
-        element_name = self._repr_if_not_hashable(element)
+        element_name = self._build_name(element)
         return element_name in self._queue
 
     def __getitem__(self, element: TKey) -> TValue:
-        element_name = self._repr_if_not_hashable(element)
+        element_name = self._build_name(element)
         return self._queue[element_name]
 
     def __len__(self) -> int:
@@ -310,7 +325,7 @@ class NamedElementOnion(Mapping[TKey, TValue]):
 
     def as_tuple_of_middleware(self) -> Tuple[TValue, ...]:
         """
-        This helps with type hinting since we return `Iterator[TKey]` type, though it's
+        Helps with type hinting since we return `Iterator[TKey]` type, though it's
         actually a `Iterator[TValue]` type, for the `__iter__()` method. This is in
         order to satisfy the `Mapping` interface.
         """

web3/eth/__init__.py

@@ -8,3 +8,10 @@ from .eth import (
     Contract,
     Eth,
 )
+
+__all__ = [
+    "AsyncEth",
+    "BaseEth",
+    "Contract",
+    "Eth",
+]

web3/eth/async_eth.py

@@ -4,6 +4,7 @@ from typing import (
     Any,
     Awaitable,
     Callable,
+    Dict,
     List,
     Optional,
     Tuple,
@@ -34,6 +35,9 @@ from web3._utils.async_transactions import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     async_fee_history_priority_fee,
 )
@@ -56,12 +60,14 @@ from web3.eth.base_eth import (
     BaseEth,
 )
 from web3.exceptions import (
-    MethodUnavailable,
+    MethodNotSupported,
     OffchainLookup,
     TimeExhausted,
     TooManyRequests,
     TransactionIndexingInProgress,
     TransactionNotFound,
+    Web3RPCError,
+    Web3ValueError,
 )
 from web3.method import (
     Method,
@@ -75,6 +81,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -92,11 +99,16 @@ from web3.types import (
     _Hash32,
 )
 from web3.utils import (
+    EthSubscription,
     async_handle_offchain_lookup,
 )
+from web3.utils.subscriptions import (
+    EthSubscriptionHandler,
+)
 
 if TYPE_CHECKING:
     from web3 import AsyncWeb3  # noqa: F401
+    from web3.contract.async_contract import AsyncContractEvent  # noqa: F401
 
 
 class AsyncEth(BaseEth):
@@ -105,9 +117,9 @@ class AsyncEth(BaseEth):
 
     is_async = True
 
-    _default_contract_factory: Type[Union[AsyncContract, AsyncContractCaller]] = (
-        AsyncContract
-    )
+    _default_contract_factory: Type[
+        Union[AsyncContract, AsyncContractCaller]
+    ] = AsyncContract
 
     # eth_accounts
 
@@ -120,16 +132,16 @@ class AsyncEth(BaseEth):
     async def accounts(self) -> Tuple[ChecksumAddress]:
         return await self._accounts()
 
-    # eth_hashrate
+    # eth_blobBaseFee
 
-    _hashrate: Method[Callable[[], Awaitable[int]]] = Method(
-        RPC.eth_hashrate,
+    _eth_blobBaseFee: Method[Callable[[], Awaitable[Wei]]] = Method(
+        RPC.eth_blobBaseFee,
         is_property=True,
     )
 
     @property
-    async def hashrate(self) -> int:
-        return await self._hashrate()
+    async def blob_base_fee(self) -> Wei:
+        return await self._eth_blobBaseFee()
 
     # eth_blockNumber
 
@@ -153,17 +165,6 @@ class AsyncEth(BaseEth):
     async def chain_id(self) -> int:
         return await self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], Awaitable[ChecksumAddress]]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    async def coinbase(self) -> ChecksumAddress:
-        return await self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Awaitable[Wei]]] = Method(
@@ -191,24 +192,14 @@ class AsyncEth(BaseEth):
         """
         try:
             return await self._max_priority_fee()
-        except (ValueError, MethodUnavailable):
+        except Web3RPCError:
             warnings.warn(
                 "There was an issue with the method eth_maxPriorityFeePerGas. "
-                "Calculating using eth_feeHistory."
+                "Calculating using eth_feeHistory.",
+                stacklevel=2,
             )
             return await async_fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], Awaitable[bool]]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    async def mining(self) -> bool:
-        return await self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Awaitable[Union[SyncStatus, bool]]]] = Method(
@@ -281,7 +272,7 @@ class AsyncEth(BaseEth):
         max_redirects = self.w3.provider.ccip_read_max_redirects
 
         if not max_redirects or max_redirects < 4:
-            raise ValueError(
+            raise Web3ValueError(
                 "ccip_read_max_redirects property on provider must be at least 4."
             )
 
@@ -389,15 +380,15 @@ class AsyncEth(BaseEth):
     # eth_getBlockTransactionCountByHash
     # eth_getBlockTransactionCountByNumber
 
-    get_block_transaction_count: Method[Callable[[BlockIdentifier], Awaitable[int]]] = (
-        Method(
-            method_choice_depends_on_args=select_method_for_block_identifier(
-                if_predefined=RPC.eth_getBlockTransactionCountByNumber,
-                if_hash=RPC.eth_getBlockTransactionCountByHash,
-                if_number=RPC.eth_getBlockTransactionCountByNumber,
-            ),
-            mungers=[default_root_munger],
-        )
+    get_block_transaction_count: Method[
+        Callable[[BlockIdentifier], Awaitable[int]]
+    ] = Method(
+        method_choice_depends_on_args=select_method_for_block_identifier(
+            if_predefined=RPC.eth_getBlockTransactionCountByNumber,
+            if_hash=RPC.eth_getBlockTransactionCountByHash,
+            if_number=RPC.eth_getBlockTransactionCountByNumber,
+        ),
+        mungers=[default_root_munger],
     )
 
     # eth_sendTransaction
@@ -424,15 +415,15 @@ class AsyncEth(BaseEth):
     # eth_getBlockByHash
     # eth_getBlockByNumber
 
-    _get_block: Method[Callable[[BlockIdentifier, bool], Awaitable[BlockData]]] = (
-        Method(
-            method_choice_depends_on_args=select_method_for_block_identifier(
-                if_predefined=RPC.eth_getBlockByNumber,
-                if_hash=RPC.eth_getBlockByHash,
-                if_number=RPC.eth_getBlockByNumber,
-            ),
-            mungers=[BaseEth.get_block_munger],
-        )
+    _get_block: Method[
+        Callable[[BlockIdentifier, bool], Awaitable[BlockData]]
+    ] = Method(
+        method_choice_depends_on_args=select_method_for_block_identifier(
+            if_predefined=RPC.eth_getBlockByNumber,
+            if_hash=RPC.eth_getBlockByHash,
+            if_number=RPC.eth_getBlockByNumber,
+        ),
+        mungers=[BaseEth.get_block_munger],
     )
 
     async def get_block(
@@ -440,6 +431,20 @@ class AsyncEth(BaseEth):
     ) -> BlockData:
         return await self._get_block(block_identifier, full_transactions)
 
+    # eth_getBlockReceipts
+
+    _get_block_receipts: Method[
+        Callable[[BlockIdentifier], Awaitable[BlockReceipts]]
+    ] = Method(
+        RPC.eth_getBlockReceipts,
+        mungers=[default_root_munger],
+    )
+
+    async def get_block_receipts(
+        self, block_identifier: BlockIdentifier
+    ) -> BlockReceipts:
+        return await self._get_block_receipts(block_identifier)
+
     # eth_getBalance
 
     _get_balance: Method[
@@ -575,10 +580,8 @@ class AsyncEth(BaseEth):
             self.w3, current_transaction, new_transaction
         )
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     async def modify_transaction(
-        self, transaction_hash: _Hash32, **transaction_params: Any
+        self, transaction_hash: _Hash32, **transaction_params: Unpack[TxParams]
     ) -> HexBytes:
         assert_valid_transaction_params(cast(TxParams, transaction_params))
 
@@ -622,14 +625,16 @@ class AsyncEth(BaseEth):
     # eth_signTypedData
 
     _sign_typed_data: Method[
-        Callable[[Union[Address, ChecksumAddress, ENS], str], Awaitable[HexStr]]
+        Callable[
+            [Union[Address, ChecksumAddress, ENS], Dict[str, Any]], Awaitable[HexStr]
+        ]
     ] = Method(
         RPC.eth_signTypedData,
         mungers=[default_root_munger],
     )
 
     async def sign_typed_data(
-        self, account: Union[Address, ChecksumAddress, ENS], data: str
+        self, account: Union[Address, ChecksumAddress, ENS], data: Dict[str, Any]
     ) -> HexStr:
         return await self._sign_typed_data(account, data)
 
@@ -663,9 +668,9 @@ class AsyncEth(BaseEth):
 
     # eth_getFilterChanges, eth_getFilterLogs, eth_uninstallFilter
 
-    _get_filter_changes: Method[Callable[[HexStr], Awaitable[List[LogReceipt]]]] = (
-        Method(RPC.eth_getFilterChanges, mungers=[default_root_munger])
-    )
+    _get_filter_changes: Method[
+        Callable[[HexStr], Awaitable[List[LogReceipt]]]
+    ] = Method(RPC.eth_getFilterChanges, mungers=[default_root_munger])
 
     async def get_filter_changes(self, filter_id: HexStr) -> List[LogReceipt]:
         return await self._get_filter_changes(filter_id)
@@ -714,17 +719,23 @@ class AsyncEth(BaseEth):
                 bool,  # newPendingTransactions, full_transactions
             ]
         ] = None,
+        handler: Optional[EthSubscriptionHandler] = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+        label: Optional[str] = None,
     ) -> HexStr:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_subscribe is only supported with providers that support "
                 "persistent connections."
             )
 
-        if subscription_arg is None:
-            return await self._subscribe(subscription_type)
-
-        return await self._subscribe_with_args(subscription_type, subscription_arg)
+        sub = EthSubscription._create_type_aware_subscription(
+            subscription_params=(subscription_type, subscription_arg),
+            handler=handler,
+            handler_context=handler_context or {},
+            label=label,
+        )
+        return await self.w3.subscription_manager.subscribe(sub)
 
     _unsubscribe: Method[Callable[[HexStr], Awaitable[bool]]] = Method(
         RPC.eth_unsubscribe,
@@ -733,22 +744,31 @@ class AsyncEth(BaseEth):
 
     async def unsubscribe(self, subscription_id: HexStr) -> bool:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_unsubscribe is only supported with providers that support "
                 "persistent connections."
             )
 
-        return await self._unsubscribe(subscription_id)
+        for sub in self.w3.subscription_manager.subscriptions:
+            if sub._id == subscription_id:
+                return await sub.unsubscribe()
+
+        raise Web3ValueError(
+            f"Cannot unsubscribe subscription with id `{subscription_id}`. "
+            "Subscription not found."
+        )
 
     # -- 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
-    ) -> AsyncContract: ...
+    ) -> AsyncContract:
+        ...
 
     def contract(
         self,

web3/eth/base_eth.py

@@ -30,6 +30,10 @@ from web3._utils.empty import (
 from web3._utils.encoding import (
     to_hex,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from web3.module import (
     Module,
 )
@@ -194,7 +198,7 @@ class BaseEth(Module):
         filter_id: Optional[HexStr] = None,
     ) -> Union[List[FilterParams], List[HexStr], List[str]]:
         if filter_id and filter_params:
-            raise TypeError(
+            raise Web3TypeError(
                 "Ambiguous invocation: provide either a `filter_params` or a "
                 "`filter_id` argument. Both were supplied."
             )
@@ -204,14 +208,14 @@ class BaseEth(Module):
             if filter_params in {"latest", "pending"}:
                 return [filter_params]
             else:
-                raise ValueError(
+                raise Web3ValueError(
                     "The filter API only accepts the values of `pending` or "
                     "`latest` for string based filters"
                 )
         elif filter_id and not filter_params:
             return [filter_id]
         else:
-            raise TypeError(
+            raise Web3TypeError(
                 "Must provide either filter_params as a string or "
                 "a valid filter object, or a filter_id as a string "
                 "or hex."