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

web3/eth/eth.py

@@ -2,6 +2,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Sequence,
@@ -29,6 +30,9 @@ from hexbytes import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     fee_history_priority_fee,
 )
@@ -56,12 +60,13 @@ from web3.eth.base_eth import (
     BaseEth,
 )
 from web3.exceptions import (
-    MethodUnavailable,
     OffchainLookup,
     TimeExhausted,
     TooManyRequests,
     TransactionIndexingInProgress,
     TransactionNotFound,
+    Web3RPCError,
+    Web3ValueError,
 )
 from web3.method import (
     Method,
@@ -72,6 +77,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -113,16 +119,16 @@ class Eth(BaseEth):
     def accounts(self) -> Tuple[ChecksumAddress]:
         return self._accounts()
 
-    # eth_hashrate
+    # eth_blobBaseFee
 
-    _hashrate: Method[Callable[[], int]] = Method(
-        RPC.eth_hashrate,
+    _eth_blobBaseFee: Method[Callable[[], Wei]] = Method(
+        RPC.eth_blobBaseFee,
         is_property=True,
     )
 
     @property
-    def hashrate(self) -> int:
-        return self._hashrate()
+    def blob_base_fee(self) -> Wei:
+        return self._eth_blobBaseFee()
 
     # eth_blockNumber
 
@@ -146,17 +152,6 @@ class Eth(BaseEth):
     def chain_id(self) -> int:
         return self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], ChecksumAddress]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    def coinbase(self) -> ChecksumAddress:
-        return self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Wei]] = Method(
@@ -184,24 +179,14 @@ class Eth(BaseEth):
         """
         try:
             return 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 fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], bool]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    def mining(self) -> bool:
-        return self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Union[SyncStatus, bool]]] = Method(
@@ -269,7 +254,7 @@ class Eth(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."
             )
 
@@ -278,7 +263,8 @@ class Eth(BaseEth):
                 return self._call(transaction, block_identifier, state_override)
             except OffchainLookup as offchain_lookup:
                 durin_calldata = handle_offchain_lookup(
-                    offchain_lookup.payload, transaction
+                    offchain_lookup.payload,
+                    transaction,
                 )
                 transaction["data"] = durin_calldata
 
@@ -411,6 +397,16 @@ class Eth(BaseEth):
     ) -> BlockData:
         return self._get_block(block_identifier, full_transactions)
 
+    # eth_getBlockReceipts
+
+    _get_block_receipts: Method[Callable[[BlockIdentifier], BlockReceipts]] = Method(
+        RPC.eth_getBlockReceipts,
+        mungers=[default_root_munger],
+    )
+
+    def get_block_receipts(self, block_identifier: BlockIdentifier) -> BlockReceipts:
+        return self._get_block_receipts(block_identifier)
+
     # eth_getBalance
 
     _get_balance: Method[
@@ -582,10 +578,8 @@ class Eth(BaseEth):
         current_transaction = get_required_transaction(self.w3, transaction_hash)
         return replace_transaction(self.w3, current_transaction, new_transaction)
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     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))
         current_transaction = get_required_transaction(self.w3, transaction_hash)
@@ -611,7 +605,7 @@ class Eth(BaseEth):
     # eth_signTypedData
 
     sign_typed_data: Method[
-        Callable[[Union[Address, ChecksumAddress, ENS], str], HexStr]
+        Callable[[Union[Address, ChecksumAddress, ENS], Dict[str, Any]], HexStr]
     ] = Method(
         RPC.eth_signTypedData,
         mungers=[default_root_munger],
@@ -619,15 +613,15 @@ class Eth(BaseEth):
 
     # eth_newFilter, eth_newBlockFilter, eth_newPendingTransactionFilter
 
-    filter: Method[Callable[[Optional[Union[str, FilterParams, HexStr]]], Filter]] = (
-        Method(
-            method_choice_depends_on_args=select_filter_method(
-                if_new_block_filter=RPC.eth_newBlockFilter,
-                if_new_pending_transaction_filter=RPC.eth_newPendingTransactionFilter,
-                if_new_filter=RPC.eth_newFilter,
-            ),
-            mungers=[BaseEth.filter_munger],
-        )
+    filter: Method[
+        Callable[[Optional[Union[str, FilterParams, HexStr]]], Filter]
+    ] = Method(
+        method_choice_depends_on_args=select_filter_method(
+            if_new_block_filter=RPC.eth_newBlockFilter,
+            if_new_pending_transaction_filter=RPC.eth_newPendingTransactionFilter,
+            if_new_filter=RPC.eth_newFilter,
+        ),
+        mungers=[BaseEth.filter_munger],
     )
 
     # eth_getFilterChanges, eth_getFilterLogs, eth_uninstallFilter
@@ -645,32 +639,15 @@ class Eth(BaseEth):
         mungers=[default_root_munger],
     )
 
-    # eth_submitHashrate
-
-    submit_hashrate: Method[Callable[[int, _Hash32], bool]] = Method(
-        RPC.eth_submitHashrate,
-        mungers=[default_root_munger],
-    )
-
-    # eth_getWork, eth_submitWork
-
-    get_work: Method[Callable[[], List[HexBytes]]] = Method(
-        RPC.eth_getWork,
-        is_property=True,
-    )
-
-    submit_work: Method[Callable[[int, _Hash32, _Hash32], bool]] = Method(
-        RPC.eth_submitWork,
-        mungers=[default_root_munger],
-    )
-
     @overload
-    def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]: ...
+    def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:
+        ...
 
     @overload
     def contract(
         self, address: Union[Address, ChecksumAddress, ENS], **kwargs: Any
-    ) -> Contract: ...
+    ) -> Contract:
+        ...
 
     def contract(
         self,

web3/exceptions.py

@@ -1,20 +1,21 @@
 import datetime
 import time
 from typing import (
+    TYPE_CHECKING,
     Any,
     Dict,
     Optional,
     Union,
 )
 
-from eth_utils import (
-    ValidationError,
-)
-
 from web3.types import (
     BlockData,
+    RPCResponse,
 )
 
+if TYPE_CHECKING:
+    import asyncio
+
 
 class Web3Exception(Exception):
     """
@@ -30,6 +31,52 @@ class Web3Exception(Exception):
             # deal with other exceptions
     """
 
+    user_message: Optional[str] = None
+
+    def __init__(
+        self,
+        *args: Any,
+        user_message: Optional[str] = None,
+    ):
+        super().__init__(*args)
+
+        # Assign properties of Web3Exception
+        self.user_message = user_message
+
+
+class Web3AssertionError(Web3Exception, AssertionError):
+    """
+    A web3.py exception wrapper for `AssertionError`, for better control over
+    exception handling.
+    """
+
+
+class Web3ValueError(Web3Exception, ValueError):
+    """
+    A web3.py exception wrapper for `ValueError`, for better control over
+    exception handling.
+    """
+
+
+class Web3AttributeError(Web3Exception, AttributeError):
+    """
+    A web3.py exception wrapper for `AttributeError`, for better control over
+    exception handling.
+    """
+
+
+class Web3TypeError(Web3Exception, TypeError):
+    """
+    A web3.py exception wrapper for `TypeError`, for better control over
+    exception handling.
+    """
+
+
+class MethodNotSupported(Web3Exception):
+    """
+    Raised when a method is not supported by the provider.
+    """
+
 
 class BadFunctionCallOutput(Web3Exception):
     """
@@ -38,24 +85,18 @@ class BadFunctionCallOutput(Web3Exception):
     Most likely ABI mismatch.
     """
 
-    pass
-
 
-class BlockNumberOutofRange(Web3Exception):
+class BlockNumberOutOfRange(Web3Exception):
     """
     block_identifier passed does not match known block.
     """
 
-    pass
-
 
 class ProviderConnectionError(Web3Exception):
     """
     Raised when unable to connect to a provider
     """
 
-    pass
-
 
 class CannotHandleRequest(Web3Exception):
     """
@@ -63,16 +104,12 @@ class CannotHandleRequest(Web3Exception):
     that the manager should proceed to the next provider.
     """
 
-    pass
-
 
 class TooManyRequests(Web3Exception):
     """
     Raised by a provider to signal that too many requests have been made consecutively.
     """
 
-    pass
-
 
 class MultipleFailedRequests(Web3Exception):
     """
@@ -80,16 +117,12 @@ class MultipleFailedRequests(Web3Exception):
     (or similar) data have failed.
     """
 
-    pass
-
 
 class InvalidAddress(Web3Exception):
     """
     The supplied address does not have a valid checksum, as defined in EIP-55
     """
 
-    pass
-
 
 class NameNotFound(Web3Exception):
     """
@@ -97,8 +130,6 @@ class NameNotFound(Web3Exception):
     does not resolve to an address.
     """
 
-    pass
-
 
 class StaleBlockchain(Web3Exception):
     """
@@ -128,17 +159,13 @@ class MismatchedABI(Web3Exception):
     attempt is made to access a function/event that does not exist in the ABI.
     """
 
-    pass
 
-
-class ABIEventFunctionNotFound(AttributeError, MismatchedABI):
+class ABIEventNotFound(AttributeError, MismatchedABI):
     """
     Raised when an attempt is made to access an event
     that does not exist in the ABI.
     """
 
-    pass
-
 
 class ABIFunctionNotFound(AttributeError, MismatchedABI):
     """
@@ -146,56 +173,54 @@ class ABIFunctionNotFound(AttributeError, MismatchedABI):
     that does not exist in the ABI.
     """
 
-    pass
 
+class ABIConstructorNotFound(Web3Exception):
+    """
+    Raised when a constructor function doesn't exist in contract.
+    """
 
-class FallbackNotFound(Web3Exception):
+
+class ABIFallbackNotFound(Web3Exception):
     """
-    Raised when fallback function doesn't exist in contract.
+    Raised when a fallback function doesn't exist in contract.
     """
 
-    pass
+
+class ABIReceiveNotFound(Web3Exception):
+    """
+    Raised when a receive function doesn't exist in contract.
+    """
 
 
-class Web3ValidationError(Web3Exception, ValidationError):
+class Web3ValidationError(Web3Exception):
     """
     Raised when a supplied value is invalid.
     """
 
-    pass
-
 
 class ExtraDataLengthError(Web3ValidationError):
     """
     Raised when an RPC call returns >32 bytes of extraData.
     """
 
-    pass
-
 
 class NoABIFunctionsFound(Web3Exception):
     """
     Raised when an ABI is present, but doesn't contain any functions.
     """
 
-    pass
-
 
 class NoABIFound(Web3Exception):
     """
     Raised when no ABI is present.
     """
 
-    pass
-
 
 class NoABIEventsFound(Web3Exception):
     """
     Raised when an ABI doesn't contain any events.
     """
 
-    pass
-
 
 class InsufficientData(Web3Exception):
     """
@@ -203,8 +228,6 @@ class InsufficientData(Web3Exception):
     complete a calculation
     """
 
-    pass
-
 
 class TimeExhausted(Web3Exception):
     """
@@ -212,57 +235,24 @@ class TimeExhausted(Web3Exception):
     result within a specified timeout.
     """
 
-    pass
-
-
-class TransactionNotFound(Web3Exception):
-    """
-    Raised when a tx hash used to lookup a tx in a jsonrpc call cannot be found.
-    """
-
-    pass
-
-
-class TransactionIndexingInProgress(Web3Exception):
-    """
-    Raised when a transaction receipt is not yet available due to transaction indexing
-    still being in progress.
-    """
-
-    pass
-
-
-class BlockNotFound(Web3Exception):
-    """
-    Raised when the block id used to lookup a block in a jsonrpc call cannot be found.
-    """
-
-    pass
-
 
 class InfuraProjectIdNotFound(Web3Exception):
     """
     Raised when there is no Infura Project Id set.
     """
 
-    pass
-
 
 class LogTopicError(Web3Exception):
     """
     Raised when the number of log topics is mismatched.
     """
 
-    pass
-
 
 class InvalidEventABI(Web3Exception):
     """
     Raised when the event ABI is invalid.
     """
 
-    pass
-
 
 class ContractLogicError(Web3Exception):
     """
@@ -274,6 +264,7 @@ class ContractLogicError(Web3Exception):
         message: Optional[str] = None,
         data: Optional[Union[str, Dict[str, str]]] = None,
     ):
+        super().__init__(message, data)
         self.message = message
         self.data = data
 
@@ -283,16 +274,12 @@ class ContractCustomError(ContractLogicError):
     Raised on a contract revert custom error
     """
 
-    pass
-
 
 class ContractPanicError(ContractLogicError):
     """
     Raised when a contract reverts with Panic, as of Solidity 0.8.0
     """
 
-    pass
-
 
 class OffchainLookup(ContractLogicError):
     """
@@ -330,12 +317,100 @@ class BadResponseFormat(Web3Exception):
     Raised when a JSON-RPC response comes back in an unexpected format
     """
 
-    pass
+
+class TaskNotRunning(Web3Exception):
+    """
+    Used to signal between asyncio contexts that a task that is being awaited
+    is not currently running.
+    """
+
+    def __init__(
+        self, task: "asyncio.Task[Any]", message: Optional[str] = None
+    ) -> None:
+        self.task = task
+        if message is None:
+            message = f"Task {task} is not running."
+        self.message = message
+        super().__init__(message)
+
+
+class PersistentConnectionError(Web3Exception):
+    """
+    Raised when a persistent connection encounters an error.
+    """
+
+
+class ReadBufferLimitReached(PersistentConnectionError, Web3ValueError):
+    """
+    Raised when the read buffer limit is reached while reading data from a persistent
+    connection.
+    """
+
+
+class PersistentConnectionClosedOK(PersistentConnectionError):
+    """
+    Raised when a persistent connection is closed gracefully by the server.
+    """
 
 
-class MethodUnavailable(Web3Exception):
+class SubscriptionProcessingFinished(Web3Exception):
+    """
+    Raised to alert the subscription manager that the processing of subscriptions
+    has finished.
+    """
+
+
+class Web3RPCError(Web3Exception):
+    """
+    Raised when a JSON-RPC response contains an error field.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        rpc_response: Optional[RPCResponse] = None,
+        user_message: Optional[str] = None,
+    ) -> None:
+        if user_message is None:
+            user_message = (
+                "An RPC error was returned by the node. Check the message provided in "
+                "the error and any available logs for more information."
+            )
+
+        super().__init__(
+            message,
+            user_message=user_message,
+        )
+        self.message = message
+        self.rpc_response = rpc_response
+
+
+class MethodUnavailable(Web3RPCError):
     """
     Raised when the method is not available on the node
     """
 
-    pass
+
+class RequestTimedOut(Web3RPCError):
+    """
+    Raised when a request to the node times out.
+    """
+
+
+class TransactionNotFound(Web3RPCError):
+    """
+    Raised when a tx hash used to look up a tx in a jsonrpc call cannot be found.
+    """
+
+
+class TransactionIndexingInProgress(Web3RPCError):
+    """
+    Raised when a transaction receipt is not yet available due to transaction indexing
+    still being in progress.
+    """
+
+
+class BlockNotFound(Web3RPCError):
+    """
+    Raised when the block id used to look up a block in a jsonrpc call cannot be found.
+    """

web3/gas_strategies/time_based.py

@@ -5,6 +5,7 @@ from typing import (
     Iterable,
     Sequence,
     Tuple,
+    cast,
 )
 
 from eth_typing import (
@@ -35,6 +36,7 @@ from web3.exceptions import (
 from web3.types import (
     BlockNumber,
     GasPriceStrategy,
+    TxData,
     TxParams,
     Wei,
 )
@@ -84,8 +86,8 @@ def _get_raw_miner_data(
     latest = w3.eth.get_block("latest", full_transactions=True)
 
     for transaction in latest["transactions"]:
-        # type ignored b/c actual transaction is TxData not HexBytes
-        yield (latest["miner"], latest["hash"], transaction["gasPrice"])  # type: ignore
+        transaction = cast(TxData, transaction)
+        yield (latest["miner"], latest["hash"], transaction["gasPrice"])
 
     block = latest
 
@@ -97,8 +99,8 @@ def _get_raw_miner_data(
         # block numbers to make caching the data easier to implement.
         block = w3.eth.get_block(block["parentHash"], full_transactions=True)
         for transaction in block["transactions"]:
-            # type ignored b/c actual transaction is TxData not HexBytes
-            yield (block["miner"], block["hash"], transaction["gasPrice"])  # type: ignore  # noqa: E501
+            transaction = cast(TxData, transaction)
+            yield (block["miner"], block["hash"], transaction["gasPrice"])
 
 
 def _aggregate_miner_data(
@@ -112,11 +114,11 @@ def _aggregate_miner_data(
             # types ignored b/c mypy has trouble inferring gas_prices: Sequence[Wei]
             price_percentile = percentile(gas_prices, percentile=20)  # type: ignore
         except InsufficientData:
-            price_percentile = min(gas_prices)  # type: ignore
+            price_percentile = min(gas_prices)
         yield MinerData(
             miner,
             len(set(block_hashes)),
-            min(gas_prices),  # type: ignore
+            min(gas_prices),
             price_percentile,
         )