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

ens/utils.py

@@ -35,6 +35,11 @@ from hexbytes import (
     HexBytes,
 )
 
+from ens.exceptions import (
+    ENSTypeError,
+    ENSValueError,
+)
+
 from .constants import (
     ACCEPTABLE_STALE_HOURS,
     AUCTION_START_GAS_CONSTANT,
@@ -77,7 +82,7 @@ def Web3() -> Type["_Web3"]:
 
 
 def init_web3(
-    provider: "BaseProvider" = cast("BaseProvider", default),
+    provider: "BaseProvider" = None,
     middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
 ) -> "_Web3":
     from web3 import (
@@ -87,6 +92,7 @@ def init_web3(
         Eth as EthMain,
     )
 
+    provider = provider or cast("BaseProvider", default)
     if provider is default:
         w3 = Web3Main(ens=None, modules={"eth": (EthMain)})
     else:
@@ -135,7 +141,7 @@ def normalize_name(name: str) -> str:
 
 
 def ens_encode_name(name: str) -> bytes:
-    """
+    r"""
     Encode a name according to DNS standards specified in section 3.1
     of RFC1035 with the following validations:
 
@@ -199,17 +205,17 @@ def sha3_text(val: Union[str, bytes]) -> HexBytes:
 def label_to_hash(label: str) -> HexBytes:
     label = normalize_name(label)
     if "." in label:
-        raise ValueError(f"Cannot generate hash for label {label!r} with a '.'")
+        raise ENSValueError(f"Cannot generate hash for label {label!r} with a '.'")
     return Web3().keccak(text=label)
 
 
 def normal_name_to_hash(name: str) -> HexBytes:
     """
-    This method will not normalize the name. 'normal' name here means the name
-    should already be normalized before calling this method.
+    Hashes a pre-normalized name.
+    The normalization of the name is a prerequisite and is not handled by this function.
 
-    :param name:            the name to hash - should already be normalized
-    :return: namehash       the hash of the name
+    :param str name: A normalized name string to be hashed.
+    :return: namehash - the hash of the name
     :rtype: HexBytes
     """
     node = EMPTY_SHA3_BYTES
@@ -264,7 +270,7 @@ def assert_signer_in_modifier_kwargs(modifier_kwargs: Any) -> ChecksumAddress:
 
     _modifier_type, modifier_dict = dict(modifier_kwargs).popitem()
     if "from" not in modifier_dict:
-        raise TypeError(ERR_MSG)
+        raise ENSTypeError(ERR_MSG)
 
     return modifier_dict["from"]
 
@@ -300,7 +306,7 @@ def get_abi_output_types(abi: "ABIFunction") -> List[str]:
 
 
 def init_async_web3(
-    provider: "AsyncBaseProvider" = cast("AsyncBaseProvider", default),
+    provider: "AsyncBaseProvider" = None,
     middleware: Optional[Sequence[Tuple["Middleware", str]]] = (),
 ) -> "AsyncWeb3":
     from web3 import (
@@ -313,8 +319,9 @@ def init_async_web3(
         StalecheckMiddlewareBuilder,
     )
 
+    provider = provider or cast("AsyncBaseProvider", default)
     middleware = list(middleware)
-    for i, (mw, name) in enumerate(middleware):
+    for i, (_mw, name) in enumerate(middleware):
         if name == "ens_name_to_address":
             middleware.pop(i)
 

web3/__init__.py

@@ -1,14 +1,9 @@
 from eth_account import Account  # noqa: E402
 import sys
 
-if sys.version_info.major == 3 and sys.version_info.minor < 8:
-    import pkg_resources
+from importlib.metadata import version
 
-    __version__ = pkg_resources.get_distribution("web3").version
-else:
-    from importlib.metadata import version
-
-    __version__ = version("web3")
+__version__ = version("web3")
 
 
 from web3.main import (

web3/_utils/abi.py

@@ -80,6 +80,9 @@ from web3._utils.formatters import (
 from web3.exceptions import (
     FallbackNotFound,
     MismatchedABI,
+    Web3AttributeError,
+    Web3TypeError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -187,7 +190,8 @@ def filter_by_argument_name(
     ]
 
 
-class AddressEncoder(encoding.AddressEncoder):
+# type ignored because subclassing encoding.AddressEncoder which has type Any
+class AddressEncoder(encoding.AddressEncoder):  # type: ignore[misc]
     @classmethod
     def validate_value(cls, value: Any) -> None:
         if is_ens_name(value):
@@ -196,7 +200,8 @@ class AddressEncoder(encoding.AddressEncoder):
         super().validate_value(value)
 
 
-class AcceptsHexStrEncoder(encoding.BaseEncoder):
+# type ignored because subclassing encoding.BytesEncoder which has type Any
+class AcceptsHexStrEncoder(encoding.BaseEncoder):  # type: ignore[misc]
     subencoder_cls: Type[encoding.BaseEncoder] = None
     is_strict: bool = None
     is_big_endian: bool = False
@@ -227,7 +232,7 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
     @classmethod
     def get_subencoder_class(cls) -> Type[encoding.BaseEncoder]:
         if cls.subencoder_cls is None:
-            raise AttributeError(f"No subencoder class is set. {cls.__name__}")
+            raise Web3AttributeError(f"No subencoder class is set. {cls.__name__}")
         return cls.subencoder_cls
 
     def validate_value(self, value: Any) -> None:
@@ -287,20 +292,20 @@ class ExactLengthBytesEncoder(BytesEncoder):
     def validate(self) -> None:
         super().validate()
         if self.value_bit_size is None:
-            raise ValueError("`value_bit_size` may not be none")
+            raise Web3ValueError("`value_bit_size` may not be none")
         if self.data_byte_size is None:
-            raise ValueError("`data_byte_size` may not be none")
+            raise Web3ValueError("`data_byte_size` may not be none")
         if self.is_big_endian is None:
-            raise ValueError("`is_big_endian` may not be none")
+            raise Web3ValueError("`is_big_endian` may not be none")
 
         if self.value_bit_size % 8 != 0:
-            raise ValueError(
+            raise Web3ValueError(
                 f"Invalid value bit size: {self.value_bit_size}. "
                 "Must be a multiple of 8"
             )
 
         if self.value_bit_size > self.data_byte_size * 8:
-            raise ValueError("Value byte size exceeds data size")
+            raise Web3ValueError("Value byte size exceeds data size")
 
     @parse_type_str("bytes")
     def from_type_str(
@@ -308,9 +313,7 @@ class ExactLengthBytesEncoder(BytesEncoder):
     ) -> "ExactLengthBytesEncoder":
         subencoder_cls = cls.get_subencoder_class()
         subencoder = subencoder_cls.from_type_str(abi_type.to_type_str(), registry)
-        # type ignored b/c @parse_type_str decorator turns it into a classmethod,
-        # so mypy thinks cls(...) is a call to __call__, but actually calls __init__
-        return cls(  # type: ignore
+        return cls(
             subencoder,
             value_bit_size=abi_type.sub * 8,
             data_byte_size=abi_type.sub,
@@ -327,7 +330,8 @@ class StrictByteStringEncoder(AcceptsHexStrEncoder):
     is_strict = True
 
 
-class TextStringEncoder(encoding.TextStringEncoder):
+# type ignored because subclassing encoding.TextStringEncoder which has type Any
+class TextStringEncoder(encoding.TextStringEncoder):  # type: ignore[misc]
     @classmethod
     def validate_value(cls, value: Any) -> None:
         if is_bytes(value):
@@ -394,7 +398,7 @@ def merge_args_and_kwargs(
     """
     # Ensure the function is being applied to the correct number of args
     if len(args) + len(kwargs) != len(function_abi.get("inputs", [])):
-        raise TypeError(
+        raise Web3TypeError(
             f"Incorrect argument count. Expected '{len(function_abi['inputs'])}'"
             f". Got '{len(args) + len(kwargs)}'"
         )
@@ -410,7 +414,7 @@ def merge_args_and_kwargs(
     # Check for duplicate args
     duplicate_args = kwarg_names.intersection(args_as_kwargs.keys())
     if duplicate_args:
-        raise TypeError(
+        raise Web3TypeError(
             f"{function_abi.get('name')}() got multiple values for argument(s) "
             f"'{', '.join(duplicate_args)}'"
         )
@@ -419,11 +423,11 @@ def merge_args_and_kwargs(
     unknown_args = kwarg_names.difference(sorted_arg_names)
     if unknown_args:
         if function_abi.get("name"):
-            raise TypeError(
+            raise Web3TypeError(
                 f"{function_abi.get('name')}() got unexpected keyword argument(s)"
                 f" '{', '.join(unknown_args)}'"
             )
-        raise TypeError(
+        raise Web3TypeError(
             f"Type: '{function_abi.get('type')}' got unexpected keyword argument(s)"
             f" '{', '.join(unknown_args)}'"
         )
@@ -497,7 +501,7 @@ def _align_abi_input(arg_abi: ABIFunctionParams, arg: Any) -> Tuple[Any, ...]:
         aligned_arg = arg
 
     if not is_list_like(aligned_arg):
-        raise TypeError(
+        raise Web3TypeError(
             f'Expected non-string sequence for "{arg_abi.get("type")}" '
             f"component type: got {aligned_arg}"
         )
@@ -528,9 +532,7 @@ def get_aligned_abi_inputs(
         args = tuple(args[abi["name"]] for abi in input_abis)
 
     return (
-        # typed dict cannot be used w/ a normal Dict
-        # https://github.com/python/mypy/issues/4976
-        tuple(collapse_if_tuple(abi) for abi in input_abis),  # type: ignore
+        tuple(collapse_if_tuple(abi) for abi in input_abis),
         type(args)(_align_abi_input(abi, arg) for abi, arg in zip(input_abis, args)),
     )
 
@@ -542,7 +544,7 @@ def get_constructor_abi(contract_abi: ABI) -> ABIFunction:
     elif len(candidates) == 0:
         return None
     elif len(candidates) > 1:
-        raise ValueError("Found multiple constructors.")
+        raise Web3ValueError("Found multiple constructors.")
     return None
 
 
@@ -564,7 +566,7 @@ STATIC_TYPES = list(
 )
 
 BASE_TYPE_REGEX = "|".join(
-    (_type + "(?![a-z0-9])" for _type in itertools.chain(STATIC_TYPES, DYNAMIC_TYPES))
+    _type + "(?![a-z0-9])" for _type in itertools.chain(STATIC_TYPES, DYNAMIC_TYPES)
 )
 
 SUB_TYPE_REGEX = r"\[" "[0-9]*" r"\]"
@@ -630,14 +632,14 @@ END_BRACKETS_OF_ARRAY_TYPE_REGEX = r"\[[^]]*\]$"
 
 def sub_type_of_array_type(abi_type: TypeStr) -> str:
     if not is_array_type(abi_type):
-        raise ValueError(f"Cannot parse subtype of nonarray abi-type: {abi_type}")
+        raise Web3ValueError(f"Cannot parse subtype of nonarray abi-type: {abi_type}")
 
-    return re.sub(END_BRACKETS_OF_ARRAY_TYPE_REGEX, "", abi_type, 1)
+    return re.sub(END_BRACKETS_OF_ARRAY_TYPE_REGEX, "", abi_type, count=1)
 
 
 def length_of_array_type(abi_type: TypeStr) -> int:
     if not is_array_type(abi_type):
-        raise ValueError(f"Cannot parse length of nonarray abi-type: {abi_type}")
+        raise Web3ValueError(f"Cannot parse length of nonarray abi-type: {abi_type}")
 
     inner_brackets = (
         re.search(END_BRACKETS_OF_ARRAY_TYPE_REGEX, abi_type).group(0).strip("[]")
@@ -705,8 +707,8 @@ def map_abi_data(
     data: Sequence[Any],
 ) -> Any:
     """
-    This function will apply normalizers to your data, in the
-    context of the relevant types. Each normalizer is in the format:
+    Applies normalizers to your data, in the context of the relevant types.
+    Each normalizer is in the format:
 
     def normalizer(datatype, data):
         # Conditionally modify data
@@ -772,7 +774,7 @@ def data_tree_map(
 
 class ABITypedData(namedtuple("ABITypedData", "abi_type, data")):
     """
-    This class marks data as having a certain ABI-type.
+    Marks data as having a certain ABI-type.
 
     >>> a1 = ABITypedData(['address', addr1])
     >>> a2 = ABITypedData(['address', addr2])
@@ -1029,7 +1031,6 @@ async def async_map_if_collection(
     Apply an awaitable method to each element of a collection or value of a dictionary.
     If the value is not a collection, return it unmodified.
     """
-
     datatype = type(value)
     if isinstance(value, Mapping):
         return datatype({key: await func(val) for key, val in value.values()})

web3/_utils/async_transactions.py

@@ -24,6 +24,9 @@ from web3._utils.utility_methods import (
 from web3.constants import (
     DYNAMIC_FEE_TXN_PARAMS,
 )
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.types import (
     BlockIdentifier,
     TxData,
@@ -87,7 +90,7 @@ async def get_buffered_gas_estimate(
     gas_limit = await get_block_gas_limit(async_w3.eth)
 
     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}"
@@ -110,7 +113,7 @@ async def async_fill_transaction_defaults(
     async_w3: "AsyncWeb3", transaction: TxParams
 ) -> TxParams:
     """
-    if async_w3 is None, fill as much as possible while offline
+    If async_w3 is None, fill as much as possible while offline
     """
     strategy_based_gas_price = async_w3.eth.generate_gas_price(transaction)
 
@@ -134,7 +137,7 @@ async def async_fill_transaction_defaults(
 
             if callable(default_getter):
                 if async_w3 is None:
-                    raise ValueError(
+                    raise Web3ValueError(
                         f"You must specify a '{key}' value in the transaction"
                     )
                 if key == "gasPrice":
@@ -155,7 +158,7 @@ async def async_get_required_transaction(
 ) -> TxData:
     current_transaction = await async_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

web3/_utils/blocks.py

@@ -15,6 +15,10 @@ from eth_utils.toolz import (
     curry,
 )
 
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from web3.types import (
     RPCEndpoint,
 )
@@ -32,7 +36,7 @@ def is_predefined_block_number(value: Any) -> bool:
     elif is_integer(value):
         return False
     else:
-        raise TypeError(f"unrecognized block reference: {value!r}")
+        raise Web3TypeError(f"unrecognized block reference: {value!r}")
 
     return value_text in {"latest", "pending", "earliest", "safe", "finalized"}
 
@@ -70,6 +74,6 @@ def select_method_for_block_identifier(
     elif is_hex_encoded_block_number(value):
         return if_number
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"Value did not match any of the recognized block identifiers: {value}"
         )

web3/_utils/caching.py

@@ -23,6 +23,10 @@ from eth_utils import (
     to_bytes,
 )
 
+from web3.exceptions import (
+    Web3TypeError,
+)
+
 if TYPE_CHECKING:
     from web3.providers import (  # noqa: F401
         AsyncBaseProvider,
@@ -51,11 +55,11 @@ def generate_cache_key(value: Any) -> str:
     elif is_boolean(value) or is_null(value) or is_number(value):
         return generate_cache_key(repr(value))
     elif is_dict(value):
-        return generate_cache_key(((key, value[key]) for key in sorted(value.keys())))
+        return generate_cache_key((key, value[key]) for key in sorted(value.keys()))
     elif is_list_like(value) or isinstance(value, collections.abc.Generator):
-        return generate_cache_key("".join((generate_cache_key(item) for item in value)))
+        return generate_cache_key("".join(generate_cache_key(item) for item in value))
     else:
-        raise TypeError(
+        raise Web3TypeError(
             f"Cannot generate cache key for value {value} of type {type(value)}"
         )
 

web3/_utils/compat/__init__.py

@@ -9,9 +9,6 @@
 # imported from `typing`
 
 from typing_extensions import (
-    Literal,  # py38
     NotRequired,  # py311
-    Protocol,  # py38
-    TypedDict,  # py38
     Self,  # py311
 )

web3/_utils/contract_sources/compile_contracts.py

@@ -116,7 +116,7 @@ contracts_in_file = {}
 
 def compile_files(file_list: List[str]) -> None:
     for filename in file_list:
-        with open(os.path.join(os.getcwd(), filename), "r") as f:
+        with open(os.path.join(os.getcwd(), filename)) as f:
             dot_sol_file = f.readlines()
 
         contract_names = []

web3/_utils/contracts.py

@@ -75,8 +75,10 @@ from web3._utils.normalizers import (
     abi_string_to_text,
 )
 from web3.exceptions import (
-    BlockNumberOutofRange,
+    BlockNumberOutOfRange,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     ABI,
@@ -136,9 +138,9 @@ def find_matching_event_abi(
     if len(event_abi_candidates) == 1:
         return event_abi_candidates[0]
     elif not event_abi_candidates:
-        raise ValueError("No matching events found")
+        raise Web3ValueError("No matching events found")
     else:
-        raise ValueError("Multiple events found")
+        raise Web3ValueError("Multiple events found")
 
 
 def find_matching_fn_abi(
@@ -159,7 +161,7 @@ def find_matching_fn_abi(
         return get_receive_func_abi(abi)
 
     if not is_text(fn_identifier):
-        raise TypeError("Unsupported function identifier")
+        raise Web3TypeError("Unsupported function identifier")
 
     name_filter = functools.partial(filter_by_name, fn_identifier)
     arg_count_filter = functools.partial(filter_by_argument_count, num_arguments)
@@ -217,7 +219,7 @@ def encode_abi(
     argument_types = get_abi_input_types(abi)
 
     if not check_if_arguments_can_be_encoded(abi, w3.codec, arguments, {}):
-        raise TypeError(
+        raise Web3TypeError(
             "One or more arguments could not be encoded to the necessary "
             f"ABI type. Expected types are: {', '.join(argument_types)}"
         )
@@ -274,7 +276,7 @@ def prepare_transaction(
         prepared_transaction = cast(TxParams, dict(**transaction))
 
     if "data" in prepared_transaction:
-        raise ValueError("Transaction parameter may not contain a 'data' key")
+        raise Web3ValueError("Transaction parameter may not contain a 'data' key")
 
     if address:
         prepared_transaction.setdefault("to", address)
@@ -317,7 +319,7 @@ def encode_transaction_data(
             kwargs,
         )
     else:
-        raise TypeError("Unsupported function identifier")
+        raise Web3TypeError("Unsupported function identifier")
 
     return add_0x_prefix(encode_abi(w3, fn_abi, fn_arguments, fn_selector))
 
@@ -327,8 +329,7 @@ def decode_transaction_data(
     data: HexStr,
     normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]] = None,
 ) -> Dict[str, Any]:
-    # type ignored b/c expects data arg to be HexBytes
-    data = HexBytes(data)  # type: ignore
+    data = HexBytes(data)
     types = get_abi_input_types(fn_abi)
     abi_codec = ABICodec(default_registry)
     decoded = abi_codec.decode(types, HexBytes(data[4:]))
@@ -373,9 +374,7 @@ def get_function_info(
     if fn_abi is None:
         fn_abi = find_matching_fn_abi(contract_abi, abi_codec, fn_name, args, kwargs)
 
-    # typed dict cannot be used w/ a normal Dict
-    # https://github.com/python/mypy/issues/4976
-    fn_selector = encode_hex(function_abi_to_4byte_selector(fn_abi))  # type: ignore
+    fn_selector = encode_hex(function_abi_to_4byte_selector(fn_abi))
 
     fn_arguments = merge_args_and_kwargs(fn_abi, args, kwargs)
 
@@ -385,7 +384,8 @@ def get_function_info(
 
 
 def validate_payable(transaction: TxParams, abi: ABIFunction) -> None:
-    """Raise Web3ValidationError if non-zero ether
+    """
+    Raise Web3ValidationError if non-zero ether
     is sent to a non-payable function.
     """
     if "value" in transaction:
@@ -424,7 +424,7 @@ def parse_block_identifier(
     ):
         return w3.eth.get_block(block_identifier)["number"]
     else:
-        raise BlockNumberOutofRange
+        raise BlockNumberOutOfRange
 
 
 def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNumber:
@@ -434,7 +434,7 @@ def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNu
         last_block = w3.eth.get_block("latest")["number"]
         block_num = last_block + block_identifier_int + 1
         if block_num < 0:
-            raise BlockNumberOutofRange
+            raise BlockNumberOutOfRange
     return BlockNumber(block_num)
 
 
@@ -453,7 +453,7 @@ async def async_parse_block_identifier(
         requested_block = await async_w3.eth.get_block(block_identifier)
         return requested_block["number"]
     else:
-        raise BlockNumberOutofRange
+        raise BlockNumberOutOfRange
 
 
 async def async_parse_block_identifier_int(
@@ -466,5 +466,5 @@ async def async_parse_block_identifier_int(
         last_block_num = last_block["number"]
         block_num = last_block_num + block_identifier_int + 1
         if block_num < 0:
-            raise BlockNumberOutofRange
+            raise BlockNumberOutOfRange
     return BlockNumber(block_num)

web3/_utils/datatypes.py

@@ -14,10 +14,14 @@ from eth_utils.toolz import (
     concat,
 )
 
+from web3.exceptions import (
+    Web3AttributeError,
+)
+
 
 def verify_attr(class_name: str, key: str, namespace: Collection[str]) -> None:
     if key not in namespace:
-        raise AttributeError(
+        raise Web3AttributeError(
             f"Property {key} not found on {class_name} class. "
             f"`{class_name}.factory` only accepts keyword arguments which are "
             f"present on the {class_name} class"

web3/_utils/decorators.py

@@ -8,6 +8,10 @@ from typing import (
 )
 import warnings
 
+from web3.exceptions import (
+    Web3ValueError,
+)
+
 TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 
 
@@ -24,7 +28,7 @@ def reject_recursive_repeats(to_wrap: Callable[..., Any]) -> Callable[..., Any]:
         thread_id = threading.get_ident()
         thread_local_args = (thread_id,) + arg_instances
         if thread_local_args in to_wrap.__already_called:  # type: ignore
-            raise ValueError(f"Recursively called {to_wrap} with {args!r}")
+            raise Web3ValueError(f"Recursively called {to_wrap} with {args!r}")
         to_wrap.__already_called[thread_local_args] = True  # type: ignore
         try:
             wrapped_val = to_wrap(*args)
@@ -50,6 +54,7 @@ def deprecated_for(replace_message: str) -> Callable[..., Any]:
             warnings.warn(
                 f"{to_wrap.__name__} is deprecated in favor of {replace_message}",
                 category=DeprecationWarning,
+                stacklevel=2,
             )
             return to_wrap(*args, **kwargs)
 

web3/_utils/empty.py

@@ -1,4 +1,4 @@
-from web3._utils.compat import (
+from typing import (
     Literal,
 )
 

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)