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

web3/_utils/error_formatters_utils.py

@@ -13,6 +13,7 @@ from web3.exceptions import (
     ContractPanicError,
     OffchainLookup,
     TransactionIndexingInProgress,
+    Web3ValueError,
 )
 from web3.types import (
     RPCResponse,
@@ -76,7 +77,9 @@ def _parse_error_with_reverted_prefix(data: str) -> str:
     try:
         error = bytes.fromhex(error).decode("utf8")
     except UnicodeDecodeError:
-        warnings.warn("Could not decode revert reason as UTF-8", RuntimeWarning)
+        warnings.warn(
+            "Could not decode revert reason as UTF-8", RuntimeWarning, stacklevel=2
+        )
         raise ContractLogicError("execution reverted", data=data)
 
     return error
@@ -140,7 +143,7 @@ def raise_contract_logic_error_on_revert(response: RPCResponse) -> RPCResponse:
     """
     error = response.get("error")
     if error is None or isinstance(error, str):
-        raise ValueError(error)
+        raise Web3ValueError(error)
 
     message = error.get("message")
     message_present = message is not None and message != ""
@@ -172,7 +175,6 @@ def raise_transaction_indexing_error_if_indexing(response: RPCResponse) -> RPCRe
     Raise an error if ``eth_getTransactionReceipt`` returns an error indicating that
     transactions are still being indexed.
     """
-
     error = response.get("error")
     if not isinstance(error, str) and error is not None:
         message = error.get("message")

web3/_utils/events.py

@@ -76,6 +76,7 @@ from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
     MismatchedABI,
+    Web3ValueError,
 )
 from web3.types import (
     ABIEvent,
@@ -115,7 +116,7 @@ def construct_event_topic_set(
         arguments = {}
     if isinstance(arguments, (list, tuple)):
         if len(arguments) != len(event_abi["inputs"]):
-            raise ValueError(
+            raise Web3ValueError(
                 "When passing an argument list, the number of arguments must "
                 "match the event constructor."
             )
@@ -130,9 +131,7 @@ def construct_event_topic_set(
         for key, value in arguments.items()  # type: ignore
     }
 
-    # typed dict cannot be used w/ a normal Dict
-    # https://github.com/python/mypy/issues/4976
-    event_topic = encode_hex(event_abi_to_log_topic(event_abi))  # type: ignore
+    event_topic = encode_hex(event_abi_to_log_topic(event_abi))
     indexed_args = get_indexed_event_inputs(event_abi)
     zipped_abi_and_args = [
         (arg, normalized_args.get(arg["name"], [None])) for arg in indexed_args
@@ -162,7 +161,7 @@ def construct_event_data_set(
         arguments = {}
     if isinstance(arguments, (list, tuple)):
         if len(arguments) != len(event_abi["inputs"]):
-            raise ValueError(
+            raise Web3ValueError(
                 "When passing an argument list, the number of arguments must "
                 "match the event constructor."
             )
@@ -341,8 +340,8 @@ is_not_indexed = complement(is_indexed)
 
 class BaseEventFilterBuilder:
     formatter = None
-    _fromBlock = None
-    _toBlock = None
+    _from_block = None
+    _to_block = None
     _address = None
     _immutable = False
 
@@ -362,30 +361,30 @@ class BaseEventFilterBuilder:
         self._ordered_arg_names = tuple(arg["name"] for arg in event_abi["inputs"])
 
     @property
-    def fromBlock(self) -> BlockIdentifier:
-        return self._fromBlock
+    def from_block(self) -> BlockIdentifier:
+        return self._from_block
 
-    @fromBlock.setter
-    def fromBlock(self, value: BlockIdentifier) -> None:
-        if self._fromBlock is None and not self._immutable:
-            self._fromBlock = value
+    @from_block.setter
+    def from_block(self, value: BlockIdentifier) -> None:
+        if self._from_block is None and not self._immutable:
+            self._from_block = value
         else:
-            raise ValueError(
-                f"fromBlock is already set to {self._fromBlock!r}. "
+            raise Web3ValueError(
+                f"from_block is already set to {self._from_block!r}. "
                 "Resetting filter parameters is not permitted"
             )
 
     @property
-    def toBlock(self) -> BlockIdentifier:
-        return self._toBlock
+    def to_block(self) -> BlockIdentifier:
+        return self._to_block
 
-    @toBlock.setter
-    def toBlock(self, value: BlockIdentifier) -> None:
-        if self._toBlock is None and not self._immutable:
-            self._toBlock = value
+    @to_block.setter
+    def to_block(self, value: BlockIdentifier) -> None:
+        if self._to_block is None and not self._immutable:
+            self._to_block = value
         else:
-            raise ValueError(
-                f"toBlock is already set to {self._toBlock!r}. "
+            raise Web3ValueError(
+                f"toBlock is already set to {self._to_block!r}. "
                 "Resetting filter parameters is not permitted"
             )
 
@@ -398,7 +397,7 @@ class BaseEventFilterBuilder:
         if self._address is None and not self._immutable:
             self._address = value
         else:
-            raise ValueError(
+            raise Web3ValueError(
                 f"address is already set to {self.address!r}. "
                 "Resetting filter parameters is not permitted"
             )
@@ -433,8 +432,8 @@ class BaseEventFilterBuilder:
     def filter_params(self) -> FilterParams:
         params = {
             "topics": self.topics,
-            "fromBlock": self.fromBlock,
-            "toBlock": self.toBlock,
+            "fromBlock": self.from_block,
+            "toBlock": self.to_block,
             "address": self.address,
         }
         return valfilter(lambda x: x is not None, params)
@@ -443,9 +442,9 @@ class BaseEventFilterBuilder:
 class EventFilterBuilder(BaseEventFilterBuilder):
     def deploy(self, w3: "Web3") -> "LogFilter":
         if not isinstance(w3, web3.Web3):
-            raise ValueError(f"Invalid web3 argument: got: {w3!r}")
+            raise Web3ValueError(f"Invalid web3 argument: got: {w3!r}")
 
-        for arg in AttributeDict.values(self.args):  # type: ignore[arg-type]
+        for arg in AttributeDict.values(self.args):
             arg._immutable = True  # type: ignore[attr-defined]
         self._immutable = True
 
@@ -461,9 +460,9 @@ class EventFilterBuilder(BaseEventFilterBuilder):
 class AsyncEventFilterBuilder(BaseEventFilterBuilder):
     async def deploy(self, async_w3: "AsyncWeb3") -> "AsyncLogFilter":
         if not isinstance(async_w3, web3.AsyncWeb3):
-            raise ValueError(f"Invalid web3 argument: got: {async_w3!r}")
+            raise Web3ValueError(f"Invalid web3 argument: got: {async_w3!r}")
 
-        for arg in AttributeDict.values(self.args):  # type: ignore[arg-type]
+        for arg in AttributeDict.values(self.args):
             arg._immutable = True  # type: ignore[attr-defined]
         self._immutable = True
 
@@ -479,8 +478,7 @@ class AsyncEventFilterBuilder(BaseEventFilterBuilder):
 
 def initialize_event_topics(event_abi: ABIEvent) -> Union[bytes, List[Any]]:
     if event_abi["anonymous"] is False:
-        # https://github.com/python/mypy/issues/4976
-        return event_abi_to_log_topic(event_abi)  # type: ignore
+        return event_abi_to_log_topic(event_abi)
     else:
         return list()
 
@@ -519,19 +517,23 @@ class BaseArgumentFilter(ABC):
 
     def match_single(self, value: Any) -> None:
         if self._immutable:
-            raise ValueError("Setting values is forbidden after filter is deployed.")
+            raise Web3ValueError(
+                "Setting values is forbidden after filter is deployed."
+            )
         if self._match_values is None:
             self._match_values = _normalize_match_values((value,))
         else:
-            raise ValueError("An argument match value/s has already been set.")
+            raise Web3ValueError("An argument match value/s has already been set.")
 
     def match_any(self, *values: Collection[Any]) -> None:
         if self._immutable:
-            raise ValueError("Setting values is forbidden after filter is deployed.")
+            raise Web3ValueError(
+                "Setting values is forbidden after filter is deployed."
+            )
         if self._match_values is None:
             self._match_values = _normalize_match_values(values)
         else:
-            raise ValueError("An argument match value/s has already been set.")
+            raise Web3ValueError("An argument match value/s has already been set.")
 
     @property
     @abstractmethod

web3/_utils/fee_utils.py

@@ -45,7 +45,7 @@ def fee_history_priority_fee(eth: "Eth") -> Wei:
     # This is a tested internal call so no need for type hinting. We can keep
     # better consistency between the sync and async calls by unpacking
     # PRIORITY_FEE_HISTORY_PARAMS as constants here.
-    fee_history = eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)  # type: ignore
+    fee_history = eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)
     return _fee_history_priority_fee_estimate(fee_history)
 
 
@@ -53,7 +53,5 @@ async def async_fee_history_priority_fee(async_eth: "AsyncEth") -> Wei:
     # This is a tested internal call so no need for type hinting. We can keep
     # better consistency between the sync and async calls by unpacking
     # PRIORITY_FEE_HISTORY_PARAMS as constants here.
-    fee_history = await async_eth.fee_history(
-        *PRIORITY_FEE_HISTORY_PARAMS  # type: ignore
-    )
+    fee_history = await async_eth.fee_history(*PRIORITY_FEE_HISTORY_PARAMS)
     return _fee_history_priority_fee_estimate(fee_history)

web3/_utils/filters.py

@@ -50,7 +50,9 @@ from web3._utils.validation import (
     validate_address,
 )
 from web3.exceptions import (
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     ABIEvent,
@@ -71,8 +73,8 @@ def construct_event_filter_params(
     contract_address: Optional[ChecksumAddress] = None,
     argument_filters: Optional[Dict[str, Any]] = None,
     topics: Optional[Sequence[HexStr]] = None,
-    fromBlock: Optional[BlockIdentifier] = None,
-    toBlock: Optional[BlockIdentifier] = None,
+    from_block: Optional[BlockIdentifier] = None,
+    to_block: Optional[BlockIdentifier] = None,
     address: Optional[ChecksumAddress] = None,
 ) -> Tuple[List[List[Optional[HexStr]]], FilterParams]:
     filter_params: FilterParams = {}
@@ -82,15 +84,14 @@ def construct_event_filter_params(
 
     if topics is not None:
         if len(topic_set) > 1:
-            raise TypeError(
+            raise Web3TypeError(
                 "Merging the topics argument with topics generated "
                 "from argument_filters is not supported."
             )
         topic_set = topics
 
     if len(topic_set) == 1 and is_list_like(topic_set[0]):
-        # type ignored b/c list-like check on line 88
-        filter_params["topics"] = topic_set[0]  # type: ignore
+        filter_params["topics"] = topic_set[0]
     else:
         filter_params["topics"] = topic_set
 
@@ -104,7 +105,7 @@ def construct_event_filter_params(
                 else [address]
             )
         else:
-            raise ValueError(
+            raise Web3ValueError(
                 f"Unsupported type for `address` parameter: {type(address)}"
             )
     elif address:
@@ -120,11 +121,11 @@ def construct_event_filter_params(
     else:
         validate_address(filter_params["address"])
 
-    if fromBlock is not None:
-        filter_params["fromBlock"] = fromBlock
+    if from_block is not None:
+        filter_params["fromBlock"] = from_block
 
-    if toBlock is not None:
-        filter_params["toBlock"] = toBlock
+    if to_block is not None:
+        filter_params["toBlock"] = to_block
 
     data_filters_set = construct_event_data_set(event_abi, abi_codec, argument_filters)
 
@@ -178,7 +179,7 @@ class BaseFilter:
 class Filter(BaseFilter):
     def __init__(self, filter_id: HexStr, eth_module: "Eth") -> None:
         self.eth_module = eth_module
-        super(Filter, self).__init__(filter_id)
+        super().__init__(filter_id)
 
     def get_new_entries(self) -> List[LogReceipt]:
         log_entries = self._filter_valid_entries(
@@ -196,7 +197,7 @@ class Filter(BaseFilter):
 class AsyncFilter(BaseFilter):
     def __init__(self, filter_id: HexStr, eth_module: "AsyncEth") -> None:
         self.eth_module = eth_module
-        super(AsyncFilter, self).__init__(filter_id)
+        super().__init__(filter_id)
 
     async def get_new_entries(self) -> List[LogReceipt]:
         filter_changes = await self.eth_module.get_filter_changes(self.filter_id)
@@ -250,7 +251,8 @@ class LogFilter(Filter):
     def set_data_filters(
         self, data_filter_set: Collection[Tuple[TypeStr, Any]]
     ) -> None:
-        """Sets the data filters (non indexed argument filters)
+        """
+        Sets the data filters (non indexed argument filters)
 
         Expects a set of tuples with the type and value, e.g.:
         (('uint256', [12345, 54321]), ('string', ('a-single-string',)))
@@ -292,7 +294,8 @@ class AsyncLogFilter(AsyncFilter):
     def set_data_filters(
         self, data_filter_set: Collection[Tuple[TypeStr, Any]]
     ) -> None:
-        """Sets the data filters (non indexed argument filters)
+        """
+        Sets the data filters (non indexed argument filters)
 
         Expects a set of tuples with the type and value, e.g.:
         (('uint256', [12345, 54321]), ('string', ('a-single-string',)))
@@ -318,7 +321,8 @@ normalize_to_text = apply_formatter_if(not_text, decode_utf8_bytes)
 
 
 def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
-    """Decodes utf-8 bytes to strings for abi string values.
+    """
+    Decodes utf-8 bytes to strings for abi string values.
 
     eth-abi v1 returns utf-8 bytes for string values.
     This can be removed once eth-abi v2 is required.
@@ -326,7 +330,7 @@ def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
     _type = parse_type_string(type_string)
     if _type.base == "string":
         if _type.arrlist is not None:
-            return tuple((normalize_to_text(value) for value in data_value))
+            return tuple(normalize_to_text(value) for value in data_value)
         else:
             return normalize_to_text(data_value)
     return data_value
@@ -336,7 +340,8 @@ def normalize_data_values(type_string: TypeStr, data_value: Any) -> Any:
 def match_fn(
     codec: ABICodec, match_values_and_abi: Collection[Tuple[str, Any]], data: Any
 ) -> bool:
-    """Match function used for filtering non-indexed event arguments.
+    """
+    Match function used for filtering non-indexed event arguments.
 
     Values provided through the match_values_and_abi parameter are
     compared to the abi decoded log data.
@@ -352,7 +357,7 @@ def match_fn(
         normalized_data = normalize_data_values(abi_type, data_value)
         for value in match_values:
             if not codec.is_encodable(abi_type, value):
-                raise ValueError(
+                raise Web3ValueError(
                     f"Value {value} is of the wrong abi type. "
                     f"Expected {abi_type} typed value."
                 )

web3/_utils/formatters.py

@@ -114,13 +114,13 @@ def apply_key_map(
 def is_array_of_strings(value: Any) -> bool:
     if not is_list_like(value):
         return False
-    return all((is_string(item) for item in value))
+    return all(is_string(item) for item in value)
 
 
 def is_array_of_dicts(value: Any) -> bool:
     if not is_list_like(value):
         return False
-    return all((is_dict(item) for item in value))
+    return all(is_dict(item) for item in value)
 
 
 @curry

web3/_utils/math.py

@@ -5,6 +5,7 @@ from typing import (
 
 from web3.exceptions import (
     InsufficientData,
+    Web3ValueError,
 )
 
 
@@ -17,9 +18,9 @@ def percentile(
             f"Expected a sequence of at least 1 integers, got {values!r}"
         )
     if percentile is None:
-        raise ValueError(f"Expected a percentile choice, got {percentile}")
+        raise Web3ValueError(f"Expected a percentile choice, got {percentile}")
     if percentile < 0 or percentile > 100:
-        raise ValueError("percentile must be in the range [0, 100]")
+        raise Web3ValueError("percentile must be in the range [0, 100]")
 
     sorted_values = sorted(values)
 

web3/_utils/method_formatters.py

@@ -32,8 +32,6 @@ from eth_utils.curried import (
     is_integer,
     is_null,
     is_string,
-    remove_0x_prefix,
-    text_if_str,
     to_checksum_address,
     to_list,
     to_tuple,
@@ -52,10 +50,6 @@ from hexbytes import (
 from web3._utils.abi import (
     is_length,
 )
-from web3._utils.encoding import (
-    hexstr_if_str,
-    to_hex,
-)
 from web3._utils.error_formatters_utils import (
     raise_contract_logic_error_on_revert,
     raise_transaction_indexing_error_if_indexing,
@@ -99,6 +93,8 @@ from web3.datastructures import (
 from web3.exceptions import (
     BlockNotFound,
     TransactionNotFound,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
     BlockIdentifier,
@@ -136,7 +132,7 @@ def to_hexbytes(
     if isinstance(val, (str, int, bytes)):
         result = HexBytes(val)
     else:
-        raise TypeError(f"Cannot convert {val!r} to HexBytes")
+        raise Web3TypeError(f"Cannot convert {val!r} to HexBytes")
 
     extra_bytes = len(result) - num_bytes
     if extra_bytes == 0 or (variable_length and extra_bytes < 0):
@@ -144,7 +140,7 @@ def to_hexbytes(
     elif all(byte == 0 for byte in result[:extra_bytes]):
         return HexBytes(result[extra_bytes:])
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"The value {result!r} is {len(result)} bytes, but should be {num_bytes}"
         )
 
@@ -177,9 +173,9 @@ def type_aware_apply_formatters_to_dict_keys_and_values(
     """
     Preserve ``AttributeDict`` types if original ``value`` was an ``AttributeDict``.
     """
-    formatted_dict = dict(
-        (key_formatters(k), value_formatters(v)) for k, v in dict_like_object.items()
-    )
+    formatted_dict = {
+        key_formatters(k): value_formatters(v) for k, v in dict_like_object.items()
+    }
     return (
         AttributeDict.recursive(formatted_dict)
         if is_attrdict(dict_like_object)
@@ -285,6 +281,8 @@ RECEIPT_FORMATTERS = {
     "to": apply_formatter_if(is_address, to_checksum_address),
     "effectiveGasPrice": to_integer_if_hex,
     "type": to_integer_if_hex,
+    "blobGasPrice": to_integer_if_hex,
+    "blobGasUsed": to_integer_if_hex,
 }
 
 
@@ -423,7 +421,22 @@ filter_result_formatter = apply_one_of_formatters(
     )
 )
 
+ACCESS_LIST_REQUEST_FORMATTER = type_aware_apply_formatters_to_dict(
+    {
+        "accessList": apply_formatter_if(
+            is_not_null,
+            apply_list_to_array_formatter(
+                apply_formatters_to_dict(
+                    {
+                        "storageKeys": apply_list_to_array_formatter(to_hex_if_bytes),
+                    }
+                )
+            ),
+        ),
+    }
+)
 transaction_param_formatter = compose(
+    ACCESS_LIST_REQUEST_FORMATTER,
     remove_key_if("to", lambda txn: txn["to"] in {"", b"", None}),
     remove_key_if("gasPrice", lambda txn: txn["gasPrice"] in {"", b"", None}),
 )
@@ -564,16 +577,6 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_sendTransaction: apply_formatter_at_index(transaction_param_formatter, 0),
     RPC.eth_signTransaction: apply_formatter_at_index(transaction_param_formatter, 0),
     RPC.eth_getProof: apply_formatter_at_index(to_hex_if_integer, 2),
-    # personal
-    RPC.personal_importRawKey: apply_formatter_at_index(
-        compose(remove_0x_prefix, hexstr_if_str(to_hex)),
-        0,
-    ),
-    RPC.personal_sign: apply_formatter_at_index(text_if_str(to_hex), 0),
-    RPC.personal_ecRecover: apply_formatter_at_index(text_if_str(to_hex), 0),
-    RPC.personal_sendTransaction: apply_formatter_at_index(
-        transaction_param_formatter, 0
-    ),
     # Snapshot and Revert
     RPC.evm_revert: apply_formatter_at_index(integer_to_hex, 0),
     # tracing
@@ -769,13 +772,6 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_signTransaction: apply_formatter_if(is_not_null, signed_tx_formatter),
     RPC.eth_signTypedData: HexBytes,
     RPC.eth_syncing: apply_formatter_if(is_not_false, syncing_formatter),
-    # personal
-    RPC.personal_importRawKey: to_checksum_address,
-    RPC.personal_listAccounts: apply_list_to_array_formatter(to_checksum_address),
-    RPC.personal_listWallets: apply_list_to_array_formatter(geth_wallets_formatter),
-    RPC.personal_newAccount: to_checksum_address,
-    RPC.personal_sendTransaction: to_hexbytes(32),
-    RPC.personal_signTypedData: HexBytes,
     # Transaction Pool
     RPC.txpool_content: transaction_pool_content_formatter,
     RPC.txpool_inspect: transaction_pool_inspect_formatter,

web3/_utils/module.py

@@ -13,6 +13,7 @@ from typing import (
 )
 
 from web3.exceptions import (
+    Web3AttributeError,
     Web3ValidationError,
 )
 from web3.module import (
@@ -50,7 +51,7 @@ def attach_modules(
         module_class = module_info[0] if module_info_is_list_like else module_info
 
         if hasattr(parent_module, module_name):
-            raise AttributeError(
+            raise Web3AttributeError(
                 f"Cannot set {parent_module} module named '{module_name}'. "
                 " The web3 object already has an attribute with that name"
             )

web3/_utils/module_testing/__init__.py

@@ -5,9 +5,6 @@ from .eth_module import (
 from .go_ethereum_admin_module import (
     GoEthereumAdminModuleTest,
 )
-from .go_ethereum_personal_module import (
-    GoEthereumPersonalModuleTest,
-)
 from .go_ethereum_txpool_module import (
     GoEthereumAsyncTxPoolModuleTest,
     GoEthereumTxPoolModuleTest,