web3 6.20.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/datastructures.py

@@ -28,6 +28,11 @@ from eth_utils import (
 from web3._utils.formatters import (
     recursive_map,
 )
+from web3.exceptions import (
+    Web3AssertionError,
+    Web3TypeError,
+    Web3ValueError,
+)
 
 # Hashable must be immutable:
 # "the implementation of hashable collections requires that a
@@ -85,7 +90,10 @@ class ReadableAttributeDict(Mapping[TKey, TValue]):
 
     @classmethod
     def recursive(cls, value: TValue) -> "ReadableAttributeDict[TKey, TValue]":
-        return recursive_map(cls._apply_if_mapping, value)
+        return cast(
+            "ReadableAttributeDict[TKey, TValue]",
+            recursive_map(cls._apply_if_mapping, value),
+        )
 
 
 class MutableAttributeDict(
@@ -100,19 +108,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 +153,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,11 +182,13 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         if name is None:
             name = cast(TKey, element)
 
+        name = self._repr_if_not_hashable(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"
                 )
 
@@ -193,7 +205,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)}, "
@@ -206,11 +218,14 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         if layer == 0:
             if name is None:
                 name = cast(TKey, element)
+
+            name = self._repr_if_not_hashable(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"
             )
 
@@ -218,49 +233,56 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         self._queue.clear()
 
     def replace(self, old: TKey, new: TKey) -> TValue:
-        if old not in self._queue:
-            raise ValueError(
+        old_name = self._repr_if_not_hashable(old)
+
+        if old_name not in self._queue:
+            raise Web3ValueError(
                 "You can't replace unless one already exists, use add instead"
             )
-        to_be_replaced = self._queue[old]
+
+        to_be_replaced = self._queue[old_name]
         if to_be_replaced is old:
             # re-insert with new name in old slot
             self._replace_with_new_name(old, new)
         else:
-            self._queue[old] = new
+            self._queue[old_name] = new
         return to_be_replaced
 
+    def _repr_if_not_hashable(self, value: TKey) -> TKey:
+        try:
+            value.__hash__()
+        except TypeError:
+            value = cast(TKey, repr(value))
+        return value
+
     def remove(self, old: TKey) -> None:
-        if old not in self._queue:
-            raise ValueError("You can only remove something that has been added")
-        del self._queue[old]
+        old_name = self._repr_if_not_hashable(old)
+        if old_name not in self._queue:
+            raise Web3ValueError("You can only remove something that has been added")
+        del self._queue[old_name]
 
     @property
-    def middlewares(self) -> Sequence[Any]:
+    def middleware(self) -> Sequence[Any]:
         """
-        Returns middlewares in the appropriate order to be imported into a new Web3
+        Returns middleware in the appropriate order to be imported into a new Web3
         instance (reversed _queue order) as a list of (middleware, name) tuples.
         """
         return [(val, key) for key, val in reversed(self._queue.items())]
 
     def _replace_with_new_name(self, old: TKey, new: TKey) -> None:
-        self._queue[new] = new
+        old_name = self._repr_if_not_hashable(old)
+        new_name = self._repr_if_not_hashable(new)
+
+        self._queue[new_name] = new
         found_old = False
         for key in list(self._queue.keys()):
             if not found_old:
-                if key == old:
+                if key == old_name:
                     found_old = True
                 continue
-            elif key != new:
+            elif key != new_name:
                 self._queue.move_to_end(key)
-        del self._queue[old]
-
-    def __iter__(self) -> Iterator[TKey]:
-        elements = self._queue.values()
-        if not isinstance(elements, Sequence):
-            # type ignored b/c elements is set as _OrderedDictValuesView[Any] on 210
-            elements = list(elements)  # type: ignore
-        return iter(reversed(elements))
+        del self._queue[old_name]
 
     def __add__(self, other: Any) -> "NamedElementOnion[TKey, TValue]":
         if not isinstance(other, NamedElementOnion):
@@ -271,10 +293,12 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         return NamedElementOnion(cast(List[Any], combined.items()))
 
     def __contains__(self, element: Any) -> bool:
-        return element in self._queue
+        element_name = self._repr_if_not_hashable(element)
+        return element_name in self._queue
 
     def __getitem__(self, element: TKey) -> TValue:
-        return self._queue[element]
+        element_name = self._repr_if_not_hashable(element)
+        return self._queue[element_name]
 
     def __len__(self) -> int:
         return len(self._queue)
@@ -284,3 +308,27 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         if not isinstance(elements, Sequence):
             elements = list(elements)
         return iter(elements)
+
+    # --- iter and tupleize methods --- #
+
+    def _reversed_middleware(self) -> Iterator[TValue]:
+        elements = self._queue.values()
+        if not isinstance(elements, Sequence):
+            # type ignored b/c elements is set as _OrderedDictValuesView[Any] on 210
+            elements = list(elements)  # type: ignore
+        return reversed(elements)
+
+    def as_tuple_of_middleware(self) -> Tuple[TValue, ...]:
+        """
+        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.
+        """
+        return tuple(self._reversed_middleware())
+
+    def __iter__(self) -> Iterator[TKey]:
+        # ``__iter__()`` for a ``Mapping``  returns ``Iterator[TKey]`` but this
+        # implementation returns ``Iterator[TValue]`` on reversed values (not keys).
+        # This leads to typing issues, so it's better to use
+        # ``as_tuple_of_middleware()`` to achieve the same result.
+        return iter(self._reversed_middleware())  # type: ignore

web3/eth/__init__.py

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

web3/eth/async_eth.py

@@ -35,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,
 )
@@ -57,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,
@@ -76,7 +81,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
-    CallOverride,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -84,6 +89,7 @@ from web3.types import (
     LogsSubscriptionArg,
     Nonce,
     SignedTx,
+    StateOverride,
     SubscriptionType,
     SyncStatus,
     TxData,
@@ -121,17 +127,6 @@ class AsyncEth(BaseEth):
     async def accounts(self) -> Tuple[ChecksumAddress]:
         return await self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], Awaitable[int]]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    async def hashrate(self) -> int:
-        return await self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], Awaitable[BlockNumber]]] = Method(
@@ -154,17 +149,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(
@@ -192,24 +176,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(
@@ -246,7 +220,7 @@ class AsyncEth(BaseEth):
             [
                 TxParams,
                 Optional[BlockIdentifier],
-                Optional[CallOverride],
+                Optional[StateOverride],
             ],
             Awaitable[HexBytes],
         ]
@@ -256,7 +230,7 @@ class AsyncEth(BaseEth):
         self,
         transaction: TxParams,
         block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[CallOverride] = None,
+        state_override: Optional[StateOverride] = None,
         ccip_read_enabled: Optional[bool] = None,
     ) -> HexBytes:
         ccip_read_enabled_on_provider = self.w3.provider.global_ccip_read_enabled
@@ -277,12 +251,12 @@ class AsyncEth(BaseEth):
         self,
         transaction: TxParams,
         block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[CallOverride] = None,
+        state_override: Optional[StateOverride] = None,
     ) -> HexBytes:
         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."
             )
 
@@ -318,7 +292,7 @@ class AsyncEth(BaseEth):
 
     _estimate_gas: Method[
         Callable[
-            [TxParams, Optional[BlockIdentifier], Optional[CallOverride]],
+            [TxParams, Optional[BlockIdentifier], Optional[StateOverride]],
             Awaitable[int],
         ]
     ] = Method(RPC.eth_estimateGas, mungers=[BaseEth.estimate_gas_munger])
@@ -327,7 +301,7 @@ class AsyncEth(BaseEth):
         self,
         transaction: TxParams,
         block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[CallOverride] = None,
+        state_override: Optional[StateOverride] = None,
     ) -> int:
         return await self._estimate_gas(transaction, block_identifier, state_override)
 
@@ -441,6 +415,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[
@@ -517,7 +505,10 @@ class AsyncEth(BaseEth):
         return await self._transaction_receipt(transaction_hash)
 
     async def wait_for_transaction_receipt(
-        self, transaction_hash: _Hash32, timeout: float = 120, poll_latency: float = 0.1
+        self,
+        transaction_hash: _Hash32,
+        timeout: Optional[float] = 120,
+        poll_latency: float = 0.1,
     ) -> TxReceipt:
         async def _wait_for_tx_receipt_with_timeout(
             _tx_hash: _Hash32, _poll_latency: float
@@ -573,10 +564,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))
 
@@ -716,7 +705,7 @@ class AsyncEth(BaseEth):
         ] = None,
     ) -> HexStr:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_subscribe is only supported with providers that support "
                 "persistent connections."
             )
@@ -733,7 +722,7 @@ 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."
             )
@@ -743,8 +732,7 @@ class AsyncEth(BaseEth):
     # -- contract methods -- #
 
     @overload
-    # type ignored because error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
-    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[misc]  # noqa: E501
+    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:
         ...
 
     @overload

web3/eth/base_eth.py

@@ -30,15 +30,19 @@ from web3._utils.empty import (
 from web3._utils.encoding import (
     to_hex,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from web3.module import (
     Module,
 )
 from web3.types import (
     ENS,
     BlockIdentifier,
-    CallOverride,
     FilterParams,
     GasPriceStrategy,
+    StateOverride,
     TxParams,
     Wei,
 )
@@ -97,9 +101,10 @@ class BaseEth(Module):
         self,
         transaction: TxParams,
         block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[CallOverride] = None,
+        state_override: Optional[StateOverride] = None,
     ) -> Union[
-        Tuple[TxParams, BlockIdentifier], Tuple[TxParams, BlockIdentifier, CallOverride]
+        Tuple[TxParams, BlockIdentifier],
+        Tuple[TxParams, BlockIdentifier, StateOverride],
     ]:
         # TODO: move to middleware
         if "from" not in transaction and is_checksum_address(self.default_account):
@@ -118,9 +123,10 @@ class BaseEth(Module):
         self,
         transaction: TxParams,
         block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[CallOverride] = None,
+        state_override: Optional[StateOverride] = None,
     ) -> Union[
-        Tuple[TxParams, BlockIdentifier], Tuple[TxParams, BlockIdentifier, CallOverride]
+        Tuple[TxParams, BlockIdentifier],
+        Tuple[TxParams, BlockIdentifier, StateOverride],
     ]:
         return self._eth_call_and_estimate_gas_munger(
             transaction, block_identifier, state_override
@@ -154,9 +160,10 @@ class BaseEth(Module):
         self,
         transaction: TxParams,
         block_identifier: Optional[BlockIdentifier] = None,
-        state_override: Optional[CallOverride] = None,
+        state_override: Optional[StateOverride] = None,
     ) -> Union[
-        Tuple[TxParams, BlockIdentifier], Tuple[TxParams, BlockIdentifier, CallOverride]
+        Tuple[TxParams, BlockIdentifier],
+        Tuple[TxParams, BlockIdentifier, StateOverride],
     ]:
         return self._eth_call_and_estimate_gas_munger(
             transaction, block_identifier, state_override
@@ -191,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."
             )
@@ -201,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."