web3 7.0.0b3__py3-none-any.whl → 7.0.0b5__py3-none-any.whl

web3/_utils/module_testing/module_testing_utils.py

@@ -7,6 +7,7 @@ from typing import (
     Collection,
     Dict,
     Generator,
+    Literal,
     Sequence,
     Union,
 )
@@ -28,9 +29,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
 from web3._utils.request import (
     async_cache_and_return_session,
     cache_and_return_session,

web3/_utils/module_testing/utils.py

@@ -36,6 +36,7 @@ class RequestMocker:
     via a ``request_mocker`` fixture defined within the appropriate context.
 
     Example:
+    -------
 
         def test_my_w3(w3, request_mocker):
             assert w3.eth.block_number == 0
@@ -46,6 +47,7 @@ class RequestMocker:
             assert w3.eth.block_number == 0
 
     Example with async and a mocked response object:
+    -----------------------------------------------
 
         async def test_my_w3(async_w3, request_mocker):
             def _iter_responses():
@@ -77,6 +79,7 @@ class RequestMocker:
 
     If a method name is not present in any of the dicts above, the request is made as
     usual.
+
     """
 
     def __init__(
@@ -90,12 +93,13 @@ class RequestMocker:
         self.mock_results = mock_results or {}
         self.mock_errors = mock_errors or {}
         self.mock_responses = mock_responses or {}
-        self._make_request: Union["AsyncMakeRequestFn", "MakeRequestFn"] = (
-            w3.provider.make_request
-        )
+        self._make_request: Union[
+            "AsyncMakeRequestFn", "MakeRequestFn"
+        ] = w3.provider.make_request
 
     def __enter__(self) -> "Self":
-        setattr(self.w3.provider, "make_request", self._mock_request_handler)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._mock_request_handler  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with mocked make_request
         self.w3.provider._request_func_cache = (None, None)
 
@@ -103,7 +107,8 @@ class RequestMocker:
 
     # define __exit__ with typing information
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        setattr(self.w3.provider, "make_request", self._make_request)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 
@@ -163,13 +168,15 @@ class RequestMocker:
 
     # -- async -- #
     async def __aenter__(self) -> "Self":
-        setattr(self.w3.provider, "make_request", self._async_mock_request_handler)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._async_mock_request_handler  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with mocked make_request
         self.w3.provider._request_func_cache = (None, None)
         return self
 
     async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        setattr(self.w3.provider, "make_request", self._make_request)
+        # mypy error: Cannot assign to a method
+        self.w3.provider.make_request = self._make_request  # type: ignore[method-assign]  # noqa: E501
         # reset request func cache to re-build request_func with original make_request
         self.w3.provider._request_func_cache = (None, None)
 

web3/_utils/normalizers.py

@@ -60,6 +60,7 @@ from web3._utils.validation import (
 from web3.exceptions import (
     InvalidAddress,
     NameNotFound,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -151,7 +152,7 @@ def abi_bytes_to_hex(
 
     num_bytes = abi_type.sub
     if len(bytes_data) > num_bytes:
-        raise ValueError(
+        raise Web3ValueError(
             f"This value was expected to be at most {num_bytes} bytes, "
             f"but instead was {len(bytes_data)}: {data!r}"
         )
@@ -273,8 +274,7 @@ def normalize_address_no_ens(address: ChecksumAddress) -> ChecksumAddress:
 def normalize_bytecode(bytecode: bytes) -> HexBytes:
     if bytecode:
         bytecode = HexBytes(bytecode)
-    # type ignored b/c bytecode is converted to HexBytes above
-    return bytecode  # type: ignore
+    return bytecode
 
 
 # --- async -- #

web3/_utils/request.py

@@ -109,9 +109,9 @@ def get_response_from_post_request(
 
 
 def make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
+    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
 ) -> bytes:
-    response = get_response_from_post_request(endpoint_uri, data=data, *args, **kwargs)
+    response = get_response_from_post_request(endpoint_uri, data=data, **kwargs)
     response.raise_for_status()
     return response.content
 
@@ -236,10 +236,10 @@ async def async_get_response_from_post_request(
 
 
 async def async_make_post_request(
-    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], *args: Any, **kwargs: Any
+    endpoint_uri: URI, data: Union[bytes, Dict[str, Any]], **kwargs: Any
 ) -> bytes:
     response = await async_get_response_from_post_request(
-        endpoint_uri, data=data, *args, **kwargs
+        endpoint_uri, data=data, **kwargs
     )
     response.raise_for_status()
     return await response.read()

web3/_utils/rpc_abi.py

@@ -24,6 +24,9 @@ from eth_utils.toolz import (
 from web3._utils.abi import (
     map_abi_data,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.types import (
     RPCEndpoint,
 )
@@ -120,18 +123,6 @@ class RPC:
     net_peerCount = RPCEndpoint("net_peerCount")
     net_version = RPCEndpoint("net_version")
 
-    # personal
-    personal_ecRecover = RPCEndpoint("personal_ecRecover")
-    personal_importRawKey = RPCEndpoint("personal_importRawKey")
-    personal_listAccounts = RPCEndpoint("personal_listAccounts")
-    personal_listWallets = RPCEndpoint("personal_listWallets")
-    personal_lockAccount = RPCEndpoint("personal_lockAccount")
-    personal_newAccount = RPCEndpoint("personal_newAccount")
-    personal_sendTransaction = RPCEndpoint("personal_sendTransaction")
-    personal_sign = RPCEndpoint("personal_sign")
-    personal_signTypedData = RPCEndpoint("personal_signTypedData")
-    personal_unlockAccount = RPCEndpoint("personal_unlockAccount")
-
     # testing
     testing_timeTravel = RPCEndpoint("testing_timeTravel")
 
@@ -158,6 +149,7 @@ TRANSACTION_PARAMS_ABIS = {
     "from": "address",
     "gas": "uint",
     "gasPrice": "uint",
+    "maxFeePerBlobGas": "uint",
     "maxFeePerGas": "uint",
     "maxPriorityFeePerGas": "uint",
     "nonce": "uint",
@@ -207,12 +199,6 @@ RPC_ABIS: Dict[str, Union[Sequence[Any], Dict[str, str]]] = {
     "eth_signTypedData": ["address", None],
     "eth_submitHashrate": ["uint", "bytes32"],
     "eth_submitWork": ["bytes8", "bytes32", "bytes32"],
-    # personal
-    "personal_sendTransaction": TRANSACTION_PARAMS_ABIS,
-    "personal_lockAccount": ["address"],
-    "personal_unlockAccount": ["address", None, None],
-    "personal_sign": [None, "address", None],
-    "personal_signTypedData": [None, "address", None],
     "trace_call": TRANSACTION_PARAMS_ABIS,
     "trace_filter": TRACE_FILTER_PARAM_ABIS,
 }
@@ -246,6 +232,6 @@ def abi_request_formatters(
             single_dict_formatter = apply_abi_formatters_to_dict(normalizers, abi_types)
             yield method, apply_formatter_at_index(single_dict_formatter, 0)
         else:
-            raise TypeError(
+            raise Web3TypeError(
                 f"ABI definitions must be a list or dictionary, got {abi_types!r}"
             )

web3/_utils/threads.py

@@ -12,11 +12,12 @@ from typing import (
     Any,
     Callable,
     Generic,
+    Literal,
     Type,
 )
 
-from web3._utils.compat import (
-    Literal,
+from web3.exceptions import (
+    Web3ValueError,
 )
 from web3.types import (
     TReturn,
@@ -63,24 +64,24 @@ class Timeout(Exception):
     @property
     def expire_at(self) -> int:
         if self.seconds is None:
-            raise ValueError(
+            raise Web3ValueError(
                 "Timeouts with `seconds == None` do not have an expiration time"
             )
         elif self.begun_at is None:
-            raise ValueError("Timeout has not been started")
+            raise Web3ValueError("Timeout has not been started")
         return self.begun_at + self.seconds
 
     def start(self) -> None:
         if self.is_running is not None:
-            raise ValueError("Timeout has already been started")
+            raise Web3ValueError("Timeout has already been started")
         self.begun_at = time.time()
         self.is_running = True
 
     def check(self) -> None:
         if self.is_running is None:
-            raise ValueError("Timeout has not been started")
+            raise Web3ValueError("Timeout has not been started")
         elif self.is_running is False:
-            raise ValueError("Timeout has already been cancelled")
+            raise Web3ValueError("Timeout has already been cancelled")
         elif self.seconds is None:
             return
         elif time.time() > self.expire_at:

web3/_utils/transactions.py

@@ -2,6 +2,7 @@ import math
 from typing import (
     TYPE_CHECKING,
     List,
+    Literal,
     Optional,
     Union,
     cast,
@@ -19,9 +20,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.compat import (
-    Literal,
-)
 from web3._utils.utility_methods import (
     all_in_dict,
     any_in_dict,
@@ -29,6 +27,10 @@ from web3._utils.utility_methods import (
 from web3.constants import (
     DYNAMIC_FEE_TXN_PARAMS,
 )
+from web3.exceptions import (
+    Web3AttributeError,
+    Web3ValueError,
+)
 from web3.types import (
     BlockIdentifier,
     TxData,
@@ -107,7 +109,7 @@ def fill_nonce(w3: "Web3", transaction: TxParams) -> TxParams:
 @curry
 def fill_transaction_defaults(w3: "Web3", transaction: TxParams) -> TxParams:
     """
-    if w3 is None, fill as much as possible while offline
+    If w3 is None, fill as much as possible while offline
     """
     strategy_based_gas_price = w3.eth.generate_gas_price(transaction)
     is_dynamic_fee_transaction = strategy_based_gas_price is None and (
@@ -130,7 +132,7 @@ def fill_transaction_defaults(w3: "Web3", transaction: TxParams) -> TxParams:
 
             if callable(default_getter):
                 if w3 is None:
-                    raise ValueError(
+                    raise Web3ValueError(
                         f"You must specify a '{key}' value in the transaction"
                     )
                 default_val = default_getter(w3, transaction)
@@ -160,7 +162,7 @@ def get_buffered_gas_estimate(
     gas_limit = get_block_gas_limit(w3)
 
     if gas_estimate > gas_limit:
-        raise ValueError(
+        raise Web3ValueError(
             "Contract does not appear to be deployable within the "
             f"current network gas limits.  Estimated: {gas_estimate}. "
             f"Current gas limit: {gas_limit}"
@@ -172,7 +174,7 @@ def get_buffered_gas_estimate(
 def get_required_transaction(w3: "Web3", transaction_hash: _Hash32) -> TxData:
     current_transaction = w3.eth.get_transaction(transaction_hash)
     if not current_transaction:
-        raise ValueError(
+        raise Web3ValueError(
             f"Supplied transaction with hash {transaction_hash!r} does not exist"
         )
     return current_transaction
@@ -204,7 +206,7 @@ def extract_valid_transaction_params(transaction_params: TxData) -> TxParams:
                 msg = 'failure to handle this transaction due to both "input: {}" and'
                 msg += ' "data: {}" are populated. You need to resolve this conflict.'
                 err_vals = (transaction_params["input"], extracted_params["data"])
-                raise AttributeError(msg.format(*err_vals))
+                raise Web3AttributeError(msg.format(*err_vals))
             else:
                 return extracted_params
         else:
@@ -223,7 +225,7 @@ def extract_valid_transaction_params(transaction_params: TxData) -> TxParams:
 def assert_valid_transaction_params(transaction_params: TxParams) -> None:
     for param in transaction_params:
         if param not in VALID_TRANSACTION_PARAMS:
-            raise ValueError(f"{param} is not a valid transaction parameter")
+            raise Web3ValueError(f"{param} is not a valid transaction parameter")
 
 
 def prepare_replacement_transaction(
@@ -233,14 +235,14 @@ def prepare_replacement_transaction(
     gas_multiplier: float = 1.125,
 ) -> TxParams:
     if original_transaction["blockHash"] is not None:
-        raise ValueError(
+        raise Web3ValueError(
             f'Supplied transaction with hash {original_transaction["hash"]!r} '
             "has already been mined"
         )
     if "nonce" in replacement_transaction and (
         replacement_transaction["nonce"] != original_transaction["nonce"]
     ):
-        raise ValueError(
+        raise Web3ValueError(
             "Supplied nonce in new_transaction must match the pending transaction"
         )
 
@@ -259,7 +261,7 @@ def prepare_replacement_transaction(
         and original_transaction["gasPrice"] is not None
     ):
         if replacement_transaction["gasPrice"] <= original_transaction["gasPrice"]:
-            raise ValueError(
+            raise Web3ValueError(
                 "Supplied gas price must exceed existing transaction gas price"
             )
 

web3/_utils/type_conversion.py

@@ -10,6 +10,10 @@ from eth_utils import (
     to_hex,
 )
 
+from web3.exceptions import (
+    Web3ValueError,
+)
+
 
 def to_hex_if_bytes(val: Union[HexStr, str, bytes, bytearray]) -> HexStr:
     """
@@ -17,7 +21,7 @@ def to_hex_if_bytes(val: Union[HexStr, str, bytes, bytearray]) -> HexStr:
     meant to work with bytes and hex strings.
     """
     if isinstance(val, str) and not val.startswith("0x"):
-        raise ValueError(f"Expected a hex string. Got: {val!r}")
+        raise Web3ValueError(f"Expected a hex string. Got: {val!r}")
 
     return to_hex(val) if isinstance(val, (bytes, bytearray)) else to_hex(hexstr=val)
 

web3/_utils/validation.py

@@ -53,6 +53,8 @@ from web3._utils.abi import (
 )
 from web3.exceptions import (
     InvalidAddress,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -74,16 +76,16 @@ def validate_abi(abi: ABI) -> None:
     Helper function for validating an ABI
     """
     if not is_list_like(abi):
-        raise ValueError("'abi' is not a list")
+        raise Web3ValueError("'abi' is not a list")
 
     if not all(is_dict(e) for e in abi):
-        raise ValueError("'abi' is not a list of dictionaries")
+        raise Web3ValueError("'abi' is not a list of dictionaries")
 
     functions = filter_by_type("function", abi)
     selectors = groupby(compose(encode_hex, function_abi_to_4byte_selector), functions)
     duplicates = valfilter(lambda funcs: len(funcs) > 1, selectors)
     if duplicates:
-        raise ValueError(
+        raise Web3ValueError(
             "Abi contains functions with colliding selectors. "
             f"Functions {_prepare_selector_collision_msg(duplicates)}"
         )
@@ -94,7 +96,7 @@ def validate_abi_type(abi_type: TypeStr) -> None:
     Helper function for validating an abi_type
     """
     if not is_recognized_type(abi_type):
-        raise ValueError(f"Unrecognized abi_type: {abi_type}")
+        raise Web3ValueError(f"Unrecognized abi_type: {abi_type}")
 
 
 def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
@@ -107,12 +109,12 @@ def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
         specified_length = length_of_array_type(abi_type)
         if specified_length is not None:
             if specified_length < 1:
-                raise TypeError(
+                raise Web3TypeError(
                     f"Invalid abi-type: {abi_type}. Length of fixed sized "
                     "arrays must be greater than 0."
                 )
             if specified_length != len(value):
-                raise TypeError(
+                raise Web3TypeError(
                     "The following array length does not the length specified"
                     f"by the abi-type, {abi_type}: {value}"
                 )
@@ -138,14 +140,14 @@ def validate_abi_value(abi_type: TypeStr, value: Any) -> None:
             if is_0x_prefixed(value):
                 return
             else:
-                raise TypeError(
+                raise Web3TypeError(
                     "ABI values of abi-type 'bytes' must be either"
                     "a python3 'bytes' object or an '0x' prefixed string."
                 )
     elif is_string_type(abi_type) and is_string(value):
         return
 
-    raise TypeError(f"The following abi value is not a '{abi_type}': {value}")
+    raise Web3TypeError(f"The following abi value is not a '{abi_type}': {value}")
 
 
 def is_not_address_string(value: Any) -> bool:
@@ -173,7 +175,7 @@ def validate_address(value: Any) -> None:
         return
 
     if not isinstance(value, str):
-        raise TypeError(f"Address {value} must be provided as a string")
+        raise Web3TypeError(f"Address {value} must be provided as a string")
     if not is_hex_address(value):
         raise InvalidAddress(
             "Address must be 20 bytes, as a hex string with a 0x prefix", value
@@ -204,7 +206,7 @@ def has_one_val(*args: Any, **kwargs: Any) -> bool:
 
 def assert_one_val(*args: Any, **kwargs: Any) -> None:
     if not has_one_val(*args, **kwargs):
-        raise TypeError(
+        raise Web3TypeError(
             "Exactly one of the passed values can be specified. "
             f"Instead, values were: {args!r}, {kwargs!r}"
         )

web3/contract/async_contract.py

@@ -82,7 +82,10 @@ from web3.exceptions import (
     ABIFunctionNotFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3AttributeError,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -108,11 +111,12 @@ class AsyncContractEvent(BaseContractEvent):
     async def get_logs(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
         block_hash: Optional[HexBytes] = None,
     ) -> Awaitable[Iterable[EventData]]:
-        """Get events for this contract instance using eth_getLogs API.
+        """
+        Get events for this contract instance using eth_getLogs API.
 
         This is a stateless method, as opposed to createFilter.
         It can be safely called against nodes which do not provide
@@ -131,7 +135,7 @@ class AsyncContractEvent(BaseContractEvent):
             from = max(mycontract.web3.eth.block_number - 10, 1)
             to = mycontract.web3.eth.block_number
 
-            events = mycontract.events.Transfer.getLogs(fromBlock=from, toBlock=to)
+            events = mycontract.events.Transfer.getLogs(from_block=from, to_block=to)
 
             for e in events:
                 print(e["args"]["from"],
@@ -161,10 +165,10 @@ class AsyncContractEvent(BaseContractEvent):
 
         :param argument_filters: Filter by argument values. Indexed arguments are
           filtered by the node while non-indexed arguments are filtered by the library.
-        :param fromBlock: block number or "latest", defaults to "latest"
-        :param toBlock: block number or "latest". Defaults to "latest"
+        :param from_block: block number or "latest", defaults to "latest"
+        :param to_block: block number or "latest". Defaults to "latest"
         :param block_hash: block hash. Cannot be set at the
-          same time as fromBlock or toBlock
+          same time as ``from_block`` or ``to_block``
         :yield: Tuple of :class:`AttributeDict` instances
         """
         event_abi = self._get_event_abi()
@@ -179,7 +183,7 @@ class AsyncContractEvent(BaseContractEvent):
                 )
 
         _filter_params = self._get_event_filter_params(
-            event_abi, argument_filters, fromBlock, toBlock, block_hash
+            event_abi, argument_filters, from_block, to_block, block_hash
         )
         # call JSON-RPC API
         logs = await self.w3.eth.get_logs(_filter_params)
@@ -200,8 +204,8 @@ class AsyncContractEvent(BaseContractEvent):
         self,
         *,  # PEP 3102
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
     ) -> AsyncLogFilter:
@@ -211,8 +215,8 @@ class AsyncContractEvent(BaseContractEvent):
         filter_builder = AsyncEventFilterBuilder(self._get_event_abi(), self.w3.codec)
         self._set_up_filter_builder(
             argument_filters,
-            fromBlock,
-            toBlock,
+            from_block,
+            to_block,
             address,
             topics,
             filter_builder,
@@ -440,12 +444,13 @@ class AsyncContract(BaseContract):
     events: AsyncContractEvents = None
 
     def __init__(self, address: Optional[ChecksumAddress] = None) -> None:
-        """Create a new smart contract proxy object.
-
-        :param address: Contract address as 0x hex string"""
+        """
+        Create a new smart contract proxy object.
 
+        :param address: Contract address as 0x hex string
+        """
         if self.w3 is None:
-            raise AttributeError(
+            raise Web3AttributeError(
                 "The `Contract` class has not been initialized.  Please use the "
                 "`web3.contract` interface to create your contract class."
             )
@@ -454,7 +459,7 @@ class AsyncContract(BaseContract):
             self.address = normalize_address_no_ens(address)
 
         if not self.address:
-            raise TypeError(
+            raise Web3TypeError(
                 "The address argument is required to instantiate a contract."
             )
         self.functions = AsyncContractFunctions(
@@ -523,7 +528,7 @@ class AsyncContract(BaseContract):
         :return: a contract constructor object
         """
         if cls.bytecode is None:
-            raise ValueError(
+            raise Web3ValueError(
                 "Cannot call constructor on a contract that does not have "
                 "'bytecode' associated with it"
             )