web3 7.0.0b2__py3-none-any.whl → 7.0.0b4__py3-none-any.whl

web3/_utils/encoding.py

@@ -55,6 +55,10 @@ from web3._utils.validation import (
 from web3.datastructures import (
     AttributeDict,
 )
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 
 
 def hex_encode_abi_type(
@@ -90,7 +94,7 @@ def hex_encode_abi_type(
     elif is_string_type(abi_type):
         return to_hex(text=value)
     else:
-        raise ValueError(f"Unsupported ABI type: {abi_type}")
+        raise Web3ValueError(f"Unsupported ABI type: {abi_type}")
 
 
 def to_hex_twos_compliment(value: Any, bit_size: int) -> HexStr:
@@ -169,7 +173,7 @@ def hexstr_if_str(
     if isinstance(hexstr_or_primitive, str):
         (primitive, hexstr) = (None, hexstr_or_primitive)
         if remove_0x_prefix(HexStr(hexstr)) and not is_hex(hexstr):
-            raise ValueError(
+            raise Web3ValueError(
                 "when sending a str, it must be a hex string. "
                 f"Got: {hexstr_or_primitive!r}"
             )
@@ -210,12 +214,12 @@ class FriendlyJsonSerde:
         except TypeError as full_exception:
             if hasattr(obj, "items"):
                 item_errors = "; ".join(self._json_mapping_errors(obj))
-                raise TypeError(
+                raise Web3TypeError(
                     f"dict had unencodable value at keys: {{{item_errors}}}"
                 )
             elif is_list_like(obj):
                 element_errors = "; ".join(self._json_list_errors(obj))
-                raise TypeError(
+                raise Web3TypeError(
                     f"list had unencodable value at index: [{element_errors}]"
                 )
             else:
@@ -237,19 +241,22 @@ class FriendlyJsonSerde:
         try:
             return self._friendly_json_encode(obj, cls=cls)
         except TypeError as exc:
-            raise TypeError(f"Could not encode to JSON: {exc}")
+            raise Web3TypeError(f"Could not encode to JSON: {exc}")
 
 
 def to_4byte_hex(hex_or_str_or_bytes: Union[HexStr, str, bytes, int]) -> HexStr:
     size_of_4bytes = 4 * 8
     byte_str = hexstr_if_str(to_bytes, hex_or_str_or_bytes)
     if len(byte_str) > 4:
-        raise ValueError(f"expected value of size 4 bytes. Got: {len(byte_str)} bytes")
+        raise Web3ValueError(
+            f"expected value of size 4 bytes. Got: {len(byte_str)} bytes"
+        )
     hex_str = encode_hex(byte_str)
     return pad_hex(hex_str, size_of_4bytes)
 
 
-class DynamicArrayPackedEncoder(BaseArrayEncoder):
+# type ignored because subclassing BaseArrayEncoder which has type Any
+class DynamicArrayPackedEncoder(BaseArrayEncoder):  # type: ignore[misc]
     is_dynamic = True
 
     def encode(self, value: Sequence[Any]) -> bytes:
@@ -291,9 +298,7 @@ class Web3JsonEncoder(json.JSONEncoder):
     def default(self, obj: Any) -> Union[Dict[Any, Any], HexStr]:
         if isinstance(obj, AttributeDict):
             return obj.__dict__
-        elif isinstance(obj, HexBytes):
-            return HexStr(obj.hex())
-        elif isinstance(obj, bytes):
+        elif isinstance(obj, (HexBytes, bytes)):
             return to_hex(obj)
         return json.JSONEncoder.default(self, obj)
 

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

@@ -29,6 +29,7 @@ from eth_abi.codec import (
 from eth_typing import (
     ChecksumAddress,
     HexStr,
+    Primitives,
     TypeStr,
 )
 from eth_utils import (
@@ -75,6 +76,7 @@ from web3.exceptions import (
     InvalidEventABI,
     LogTopicError,
     MismatchedABI,
+    Web3ValueError,
 )
 from web3.types import (
     ABIEvent,
@@ -99,6 +101,12 @@ if TYPE_CHECKING:
     )
 
 
+def _log_entry_data_to_bytes(
+    log_entry_data: Union[Primitives, HexStr, str],
+) -> bytes:
+    return hexstr_if_str(to_bytes, log_entry_data)
+
+
 def construct_event_topic_set(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
@@ -108,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."
             )
@@ -123,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
@@ -155,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."
             )
@@ -228,23 +234,25 @@ def get_event_data(
         log_topics = log_entry["topics"]
     elif not log_entry["topics"]:
         raise MismatchedABI("Expected non-anonymous event to have 1 or more topics")
-    # type ignored b/c event_abi_to_log_topic(event_abi: Dict[str, Any])
-    elif event_abi_to_log_topic(event_abi) != log_entry["topics"][0]:  # type: ignore
+    elif event_abi_to_log_topic(dict(event_abi)) != _log_entry_data_to_bytes(
+        log_entry["topics"][0]
+    ):
         raise MismatchedABI("The event signature did not match the provided ABI")
     else:
         log_topics = log_entry["topics"][1:]
 
+    log_topics_bytes = [_log_entry_data_to_bytes(topic) for topic in log_topics]
     log_topics_abi = get_indexed_event_inputs(event_abi)
     log_topic_normalized_inputs = normalize_event_input_types(log_topics_abi)
     log_topic_types = get_event_abi_types_for_decoding(log_topic_normalized_inputs)
     log_topic_names = get_abi_input_names(ABIEvent({"inputs": log_topics_abi}))
 
-    if len(log_topics) != len(log_topic_types):
+    if len(log_topics_bytes) != len(log_topic_types):
         raise LogTopicError(
-            f"Expected {len(log_topic_types)} log topics.  Got {len(log_topics)}"
+            f"Expected {len(log_topic_types)} log topics.  Got {len(log_topics_bytes)}"
         )
 
-    log_data = hexstr_if_str(to_bytes, log_entry["data"])
+    log_data = _log_entry_data_to_bytes(log_entry["data"])
     log_data_abi = exclude_indexed_event_inputs(event_abi)
     log_data_normalized_inputs = normalize_event_input_types(log_data_abi)
     log_data_types = get_event_abi_types_for_decoding(log_data_normalized_inputs)
@@ -270,7 +278,7 @@ def get_event_data(
 
     decoded_topic_data = [
         abi_codec.decode([topic_type], topic_data)[0]
-        for topic_type, topic_data in zip(log_topic_types, log_topics)
+        for topic_type, topic_data in zip(log_topic_types, log_topics_bytes)
     ]
     normalized_topic_data = map_abi_data(
         BASE_RETURN_NORMALIZERS, log_topic_types, decoded_topic_data
@@ -361,7 +369,7 @@ class BaseEventFilterBuilder:
         if self._fromBlock is None and not self._immutable:
             self._fromBlock = value
         else:
-            raise ValueError(
+            raise Web3ValueError(
                 f"fromBlock is already set to {self._fromBlock!r}. "
                 "Resetting filter parameters is not permitted"
             )
@@ -375,7 +383,7 @@ class BaseEventFilterBuilder:
         if self._toBlock is None and not self._immutable:
             self._toBlock = value
         else:
-            raise ValueError(
+            raise Web3ValueError(
                 f"toBlock is already set to {self._toBlock!r}. "
                 "Resetting filter parameters is not permitted"
             )
@@ -389,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"
             )
@@ -434,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
 
@@ -452,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
 
@@ -470,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()
 
@@ -510,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,
@@ -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:
@@ -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,23 +18,21 @@ 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 Web3ValueError("percentile must be in the range [0, 100]")
 
     sorted_values = sorted(values)
 
-    rank = len(values) * percentile / 100
-    if rank > 0:
-        index = rank - 1
-        if index < 0:
-            return sorted_values[0]
-    else:
-        index = rank
+    index = len(values) * percentile / 100 - 1
+    if index < 0:
+        return sorted_values[0]
 
-    if index % 1 == 0:
+    fractional = index % 1
+    if fractional == 0:
         return sorted_values[int(index)]
-    else:
-        fractional = index % 1
-        integer = int(index - fractional)
-        lower = sorted_values[integer]
-        higher = sorted_values[integer + 1]
-        return lower + fractional * (higher - lower)
+
+    integer = int(index - fractional)
+    lower = sorted_values[integer]
+    higher = sorted_values[integer + 1]
+    return lower + fractional * (higher - lower)

web3/_utils/method_formatters.py

@@ -99,6 +99,8 @@ from web3.datastructures import (
 from web3.exceptions import (
     BlockNotFound,
     TransactionNotFound,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
     BlockIdentifier,
@@ -136,7 +138,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 +146,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 +179,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)
@@ -233,6 +235,10 @@ TRANSACTION_RESULT_FORMATTERS = {
     ),
     "input": HexBytes,
     "data": HexBytes,  # Nethermind, for example, returns both `input` and `data`
+    "maxFeePerBlobGas": to_integer_if_hex,
+    "blobVersionedHashes": apply_formatter_if(
+        is_not_null, apply_formatter_to_array(to_hexbytes(32))
+    ),
 }
 
 
@@ -281,6 +287,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,
 }
 
 
@@ -419,7 +427,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}),
 )
@@ -516,6 +539,7 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     ),
     RPC.eth_getBalance: apply_formatter_at_index(to_hex_if_integer, 1),
     RPC.eth_getBlockByNumber: apply_formatter_at_index(to_hex_if_integer, 0),
+    RPC.eth_getBlockReceipts: apply_formatter_at_index(to_hex_if_integer, 0),
     RPC.eth_getBlockTransactionCountByNumber: apply_formatter_at_index(
         to_hex_if_integer,
         0,
@@ -723,6 +747,7 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBalance: to_integer_if_hex,
     RPC.eth_getBlockByHash: apply_formatter_if(is_not_null, block_formatter),
     RPC.eth_getBlockByNumber: apply_formatter_if(is_not_null, block_formatter),
+    RPC.eth_getBlockReceipts: apply_formatter_to_array(receipt_formatter),
     RPC.eth_getBlockTransactionCountByHash: to_integer_if_hex,
     RPC.eth_getBlockTransactionCountByNumber: to_integer_if_hex,
     RPC.eth_getCode: HexBytes,
@@ -900,6 +925,7 @@ def raise_transaction_not_found_with_index(
 NULL_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBlockByHash: raise_block_not_found,
     RPC.eth_getBlockByNumber: raise_block_not_found,
+    RPC.eth_getBlockReceipts: raise_block_not_found,
     RPC.eth_getBlockTransactionCountByHash: raise_block_not_found,
     RPC.eth_getBlockTransactionCountByNumber: raise_block_not_found,
     RPC.eth_getUncleCountByBlockHash: raise_block_not_found,

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"
             )