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

web3/manager.py

@@ -35,6 +35,8 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    Web3RPCError,
+    Web3TypeError,
 )
 from web3.middleware import (
     AttributeDictMiddleware,
@@ -85,6 +87,7 @@ def _raise_bad_response_format(response: RPCResponse, error: str = "") -> None:
     raw_response = f"The raw response is: {response}"
 
     if error is not None and error != "":
+        error = error[:-1] if error.endswith(".") else error
         message = f"{message} {error}. {raw_response}"
     else:
         message = f"{message} {raw_response}"
@@ -115,6 +118,111 @@ def apply_null_result_formatters(
         return response
 
 
+def _validate_subscription_fields(response: RPCResponse) -> None:
+    params = response["params"]
+    subscription = params["subscription"]
+    if not isinstance(subscription, str) and not len(subscription) == 34:
+        _raise_bad_response_format(
+            response, "eth_subscription 'params' must include a 'subscription' field."
+        )
+
+
+def _validate_response(
+    response: RPCResponse,
+    error_formatters: Optional[Callable[..., Any]],
+    is_subscription_response: bool = False,
+    logger: Optional[logging.Logger] = None,
+) -> None:
+    if "jsonrpc" not in response or response["jsonrpc"] != "2.0":
+        _raise_bad_response_format(
+            response, 'The "jsonrpc" field must be present with a value of "2.0".'
+        )
+
+    response_id = response.get("id")
+    if "id" in response:
+        int_error_msg = (
+            '"id" must be an integer or a string representation of an integer.'
+        )
+        if response_id is None and "error" in response:
+            # errors can sometimes have null `id`, according to the JSON-RPC spec
+            pass
+        elif not isinstance(response_id, (str, int)):
+            _raise_bad_response_format(response, int_error_msg)
+        elif isinstance(response_id, str):
+            try:
+                int(response_id)
+            except ValueError:
+                _raise_bad_response_format(response, int_error_msg)
+    elif is_subscription_response:
+        # if `id` is not present, this must be a subscription response
+        _validate_subscription_fields(response)
+    else:
+        _raise_bad_response_format(
+            response,
+            'Response must include an "id" field or be formatted as an '
+            "`eth_subscription` response.",
+        )
+
+    if all(key in response for key in {"error", "result"}):
+        _raise_bad_response_format(
+            response, 'Response cannot include both "error" and "result".'
+        )
+    elif (
+        not any(key in response for key in {"error", "result"})
+        and not is_subscription_response
+    ):
+        _raise_bad_response_format(
+            response, 'Response must include either "error" or "result".'
+        )
+    elif "error" in response:
+        error = response["error"]
+
+        # raise the error when the value is a string
+        if error is None or not isinstance(error, dict):
+            _raise_bad_response_format(
+                response,
+                'response["error"] must be a valid object as defined by the '
+                "JSON-RPC 2.0 specification.",
+            )
+
+        # errors must include an integer code
+        code = error.get("code")
+        if not isinstance(code, int):
+            _raise_bad_response_format(
+                response, 'error["code"] is required and must be an integer value.'
+            )
+        elif code == METHOD_NOT_FOUND:
+            exception = MethodUnavailable(
+                repr(error),
+                rpc_response=response,
+                user_message=(
+                    "This method is not available. Check your node provider or your "
+                    "client's API docs to see what methods are supported and / or "
+                    "currently enabled."
+                ),
+            )
+            logger.error(exception.user_message)
+            logger.debug(f"RPC error response: {response}")
+            raise exception
+
+        # errors must include a message
+        error_message = error.get("message")
+        if not isinstance(error_message, str):
+            _raise_bad_response_format(
+                response, 'error["message"] is required and must be a string value.'
+            )
+
+        apply_error_formatters(error_formatters, response)
+
+        web3_rpc_error = Web3RPCError(repr(error), rpc_response=response)
+        logger.error(web3_rpc_error.user_message)
+        logger.debug(f"RPC error response: {response}")
+        raise web3_rpc_error
+
+    elif "result" not in response and not is_subscription_response:
+        _raise_bad_response_format(response)
+
+
 class RequestManager:
     logger = logging.getLogger("web3.manager.RequestManager")
 
@@ -201,90 +309,42 @@ class RequestManager:
     #
     # See also: https://www.jsonrpc.org/specification
     #
-    @staticmethod
     def formatted_response(
+        self,
         response: RPCResponse,
         params: Any,
         error_formatters: Optional[Callable[..., Any]] = None,
         null_result_formatters: Optional[Callable[..., Any]] = None,
     ) -> Any:
-        # jsonrpc is not enforced (as per the spec) but if present, it must be 2.0
-        if "jsonrpc" in response and response["jsonrpc"] != "2.0":
-            _raise_bad_response_format(
-                response, 'The "jsonrpc" field must be present with a value of "2.0"'
-            )
+        is_subscription_response = (
+            response.get("method") == "eth_subscription"
+            and response.get("params") is not None
+            and response["params"].get("subscription") is not None
+            and response["params"].get("result") is not None
+        )
 
-        # id is not enforced (as per the spec) but if present, it must be a
-        # string or integer
-        # TODO: v7 - enforce id per the spec
-        if "id" in response:
-            response_id = response["id"]
-            # id is always None for errors
-            if response_id is None and "error" not in response:
-                _raise_bad_response_format(
-                    response, '"id" must be None when an error is present'
-                )
-            elif not isinstance(response_id, (str, int, type(None))):
-                _raise_bad_response_format(response, '"id" must be a string or integer')
-
-        # Response may not include both "error" and "result"
-        if "error" in response and "result" in response:
-            _raise_bad_response_format(
-                response, 'Response cannot include both "error" and "result"'
-            )
+        _validate_response(
+            response,
+            error_formatters,
+            is_subscription_response=is_subscription_response,
+            logger=self.logger,
+        )
 
-        # Format and validate errors
-        elif "error" in response:
-            error = response.get("error")
-            # Raise the error when the value is a string
-            if error is None or isinstance(error, str):
-                raise ValueError(error)
-
-            # Errors must include an integer code
-            code = error.get("code")
-            if not isinstance(code, int):
-                _raise_bad_response_format(response, "error['code'] must be an integer")
-            elif code == METHOD_NOT_FOUND:
-                raise MethodUnavailable(
-                    error,
-                    user_message="Check your node provider's API docs to see what "
-                    "methods are supported",
-                )
-
-            # Errors must include a message
-            if not isinstance(error.get("message"), str):
-                _raise_bad_response_format(
-                    response, "error['message'] must be a string"
-                )
-
-            apply_error_formatters(error_formatters, response)
-
-            raise ValueError(error)
-
-        # Format and validate results
-        elif "result" in response:
+        # format results
+        if "result" in response:
             # Null values for result should apply null_result_formatters
             # Skip when result not present in the response (fallback to False)
             if response.get("result", False) in NULL_RESPONSES:
                 apply_null_result_formatters(null_result_formatters, response, params)
             return response.get("result")
 
-        # Response from eth_subscription includes response["params"]["result"]
-        elif (
-            response.get("method") == "eth_subscription"
-            and response.get("params") is not None
-            and response["params"].get("subscription") is not None
-            and response["params"].get("result") is not None
-        ):
+        # response from eth_subscription includes response["params"]["result"]
+        elif is_subscription_response:
             return {
                 "subscription": response["params"]["subscription"],
                 "result": response["params"]["result"],
             }
 
-        # Any other response type raises BadResponseFormat
-        else:
-            _raise_bad_response_format(response)
-
     def request_blocking(
         self,
         method: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
@@ -323,8 +383,8 @@ class RequestManager:
             cast("AsyncWeb3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
         self.logger.debug(
-            "Making request to open socket connection - "
-            f"uri: {provider.endpoint_uri}, method: {method}"
+            "Making request to open socket connection: "
+            f"{provider.get_endpoint_uri_or_ipc_path()}, method: {method}"
         )
         response = await request_func(method, params)
         return await self._process_response(response)
@@ -337,7 +397,7 @@ class RequestManager:
 
     async def _message_stream(self) -> AsyncGenerator[RPCResponse, None]:
         if not isinstance(self._provider, PersistentConnectionProvider):
-            raise TypeError(
+            raise Web3TypeError(
                 "Only providers that maintain an open, persistent connection "
                 "can listen to streams."
             )

web3/method.py

@@ -32,7 +32,9 @@ from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     RPCEndpoint,
@@ -66,7 +68,9 @@ def _set_mungers(
     return (
         mungers
         if mungers
-        else [default_munger] if is_property else [default_root_munger]
+        else [default_munger]
+        if is_property
+        else [default_root_munger]
     )
 
 
@@ -84,7 +88,8 @@ TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 
 
 class Method(Generic[TFunc]):
-    """Method object for web3 module methods
+    """
+    Method object for web3 module methods
 
     Calls to the Method go through these steps:
 
@@ -147,7 +152,7 @@ class Method(Generic[TFunc]):
         self, obj: Optional["Module"] = None, obj_type: Optional[Type["Module"]] = None
     ) -> TFunc:
         if obj is None:
-            raise TypeError(
+            raise Web3TypeError(
                 "Direct calls to methods are not supported. "
                 "Methods must be called from an module instance, "
                 "usually attached to a web3 instance."
@@ -163,7 +168,7 @@ class Method(Generic[TFunc]):
             return self.json_rpc_method
         elif isinstance(self.json_rpc_method, (str,)):
             return lambda *_: self.json_rpc_method
-        raise ValueError(
+        raise Web3ValueError(
             "``json_rpc_method`` config invalid.  May be a string or function"
         )
 
@@ -175,7 +180,9 @@ class Method(Generic[TFunc]):
             lambda args, munger: munger(module, *args, **kwargs), self.mungers, args
         )
 
-    def process_params(self, module: "Module", *args: Any, **kwargs: Any) -> Tuple[
+    def process_params(
+        self, module: "Module", *args: Any, **kwargs: Any
+    ) -> Tuple[
         Tuple[Union[RPCEndpoint, Callable[..., RPCEndpoint]], Tuple[Any, ...]],
         Tuple[
             Union[TReturn, Dict[str, Callable[..., Any]]],
@@ -226,5 +233,6 @@ class DeprecatedMethod:
         warnings.warn(
             f"{self.old_name} is deprecated in favor of {self.new_name}",
             category=DeprecationWarning,
+            stacklevel=2,
         )
         return self.method.__get__(obj, obj_type)

web3/middleware/base.py

@@ -48,7 +48,9 @@ class Web3Middleware:
     def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         return method, params
 
-    def response_processor(self, method: "RPCEndpoint", response: "RPCResponse") -> Any:
+    def response_processor(
+        self, method: "RPCEndpoint", response: "RPCResponse"
+    ) -> "RPCResponse":
         return response
 
     # -- async -- #
@@ -76,7 +78,7 @@ class Web3Middleware:
         self,
         method: "RPCEndpoint",
         response: "RPCResponse",
-    ) -> Any:
+    ) -> "RPCResponse":
         return response
 
 

web3/middleware/filter.py

@@ -42,6 +42,9 @@ from web3._utils.formatters import (
 from web3._utils.rpc_abi import (
     RPC,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3Middleware,
 )
@@ -71,7 +74,8 @@ else:
 
 
 def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, int]]:
-    """Creates a segment counting generator
+    """
+    Creates a segment counting generator
 
     The generator returns tuple pairs of integers
     that correspond to segments in the provided range.
@@ -84,6 +88,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
 
 
     Example:
+    -------
 
     >>> segment_counter = segment_count(start=0, stop=10, step=3)
     >>> next(segment_counter)
@@ -94,6 +99,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
     (6, 9)
     >>> next(segment_counter) #  Remainder is also returned
     (9, 10)
+
     """
     return gen_bounded_segments(start, stop, step)
 
@@ -104,10 +110,9 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
     if start + step >= stop:
         yield (start, stop)
         return
-    for segment in zip(
+    yield from zip(
         range(start, stop - step + 1, step), range(start + step, stop + 1, step)
-    ):
-        yield segment
+    )
 
     remainder = (stop - start) % step
     #  Handle the remainder
@@ -118,13 +123,14 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
 def block_ranges(
     start_block: BlockNumber, last_block: Optional[BlockNumber], step: int = 5
 ) -> Iterable[Tuple[BlockNumber, BlockNumber]]:
-    """Returns 2-tuple ranges describing ranges of block from start_block to last_block
+    """
+    Returns 2-tuple ranges describing ranges of block from start_block to last_block
 
     Ranges do not overlap to facilitate use as ``toBlock``, ``fromBlock``
     json-rpc arguments, which are both inclusive.
     """
     if last_block is not None and start_block > last_block:
-        raise TypeError(
+        raise Web3TypeError(
             "Incompatible start and stop arguments.",
             "Start must be less than or equal to stop.",
         )
@@ -138,7 +144,8 @@ def block_ranges(
 def iter_latest_block(
     w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> Iterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -160,8 +167,7 @@ def iter_latest_block(
 
     while True:
         latest_block = w3.eth.block_number
-        # type ignored b/c is_bounded_range prevents unsupported comparison
-        if is_bounded_range and latest_block > to_block:  # type: ignore
+        if is_bounded_range and latest_block > to_block:
             yield None
         #  No new blocks since last iteration.
         if _last is not None and _last == latest_block:
@@ -176,7 +182,8 @@ def iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> Iterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `fromBlock` to the latest mined block,
     until reaching toBlock. e.g.:
@@ -212,7 +219,8 @@ def get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> Iterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -247,9 +255,8 @@ class RequestLogs:
         if from_block is None or from_block == "latest":
             self._from_block = BlockNumber(w3.eth.block_number + 1)
         elif is_string(from_block) and is_hex(from_block):
-            self._from_block = BlockNumber(hex_to_integer(from_block))  # type: ignore
+            self._from_block = BlockNumber(hex_to_integer(from_block))
         else:
-            # cast b/c LatestBlockParam is handled above
             self._from_block = from_block
         self._to_block = to_block
         self.filter_changes = self._get_filter_changes()
@@ -265,7 +272,7 @@ class RequestLogs:
         elif self._to_block == "latest":
             to_block = self.w3.eth.block_number
         elif is_string(self._to_block) and is_hex(self._to_block):
-            to_block = BlockNumber(hex_to_integer(self._to_block))  # type: ignore
+            to_block = BlockNumber(hex_to_integer(self._to_block))
         else:
             to_block = self._to_block
 
@@ -352,7 +359,8 @@ def block_hashes_in_range(
 async def async_iter_latest_block(
     w3: "AsyncWeb3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> AsyncIterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -390,7 +398,8 @@ async def async_iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `from_block` to the latest mined block,
     until reaching to_block. e.g.:
@@ -423,7 +432,8 @@ async def async_get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> AsyncIterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -579,6 +589,10 @@ SyncFilter = Union[RequestLogs, RequestBlocks]
 AsyncFilter = Union[AsyncRequestLogs, AsyncRequestBlocks]
 
 
+def _simulate_rpc_response_with_result(filter_id: str) -> "RPCResponse":
+    return {"jsonrpc": "2.0", "id": -1, "result": filter_id}
+
+
 class LocalFilterMiddleware(Web3Middleware):
     def __init__(self, w3: Union["Web3", "AsyncWeb3"]):
         self.filters: Dict[str, SyncFilter] = {}
@@ -605,7 +619,7 @@ class LocalFilterMiddleware(Web3Middleware):
                     raise NotImplementedError(method)
 
                 self.filters[filter_id] = _filter
-                return {"result": filter_id}
+                return _simulate_rpc_response_with_result(filter_id)
 
             elif method in FILTER_CHANGES_METHODS:
                 _filter_id = params[0]
@@ -616,12 +630,16 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 _filter = self.filters[_filter_id]
                 if method == RPC.eth_getFilterChanges:
-                    return {"result": next(_filter.filter_changes)}
+                    return _simulate_rpc_response_with_result(
+                        next(_filter.filter_changes)  # type: ignore
+                    )
 
                 elif method == RPC.eth_getFilterLogs:
                     # type ignored b/c logic prevents RequestBlocks which
                     # doesn't implement get_logs
-                    return {"result": _filter.get_logs()}  # type: ignore
+                    return _simulate_rpc_response_with_result(
+                        _filter.get_logs()  # type: ignore
+                    )
                 else:
                     raise NotImplementedError(method)
             else:
@@ -653,7 +671,7 @@ class LocalFilterMiddleware(Web3Middleware):
                     raise NotImplementedError(method)
 
                 self.async_filters[filter_id] = _filter
-                return {"result": filter_id}
+                return _simulate_rpc_response_with_result(filter_id)
 
             elif method in FILTER_CHANGES_METHODS:
                 _filter_id = params[0]
@@ -664,12 +682,16 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 _filter = self.async_filters[_filter_id]
                 if method == RPC.eth_getFilterChanges:
-                    return {"result": await _filter.filter_changes.__anext__()}
+                    return _simulate_rpc_response_with_result(
+                        await _filter.filter_changes.__anext__()  # type: ignore
+                    )
 
                 elif method == RPC.eth_getFilterLogs:
                     # type ignored b/c logic prevents RequestBlocks which
                     # doesn't implement get_logs
-                    return {"result": await _filter.get_logs()}  # type: ignore
+                    return _simulate_rpc_response_with_result(
+                        await _filter.get_logs()  # type: ignore
+                    )
                 else:
                     raise NotImplementedError(method)
             else:

web3/middleware/formatting.py

@@ -3,6 +3,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    Literal,
     Optional,
     Union,
     cast,
@@ -14,6 +15,9 @@ from eth_utils.toolz import (
     merge,
 )
 
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -21,7 +25,6 @@ from web3.types import (
     EthSubscriptionParams,
     Formatters,
     FormattersDict,
-    Literal,
     RPCEndpoint,
     RPCResponse,
 )
@@ -118,7 +121,7 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
         if (
             sync_formatters_builder is None and async_formatters_builder is not None
         ) or (sync_formatters_builder is not None and async_formatters_builder is None):
-            raise ValueError(
+            raise Web3ValueError(
                 "Must specify both sync_formatters_builder and async_formatters_builder"
             )
 
@@ -128,7 +131,7 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
                 or result_formatters is not None
                 or error_formatters is not None
             ):
-                raise ValueError(
+                raise Web3ValueError(
                     "Cannot specify formatters_builder and formatters at the same time"
                 )
 

web3/middleware/names.py

@@ -31,6 +31,9 @@ from .._utils.abi import (
 from .._utils.formatters import (
     recursive_map,
 )
+from ..exceptions import (
+    Web3TypeError,
+)
 from .base import (
     Web3Middleware,
 )
@@ -92,7 +95,7 @@ async def async_apply_ens_to_address_conversion(
         return (formatted_params_dict, *params[1:])
 
     else:
-        raise TypeError(
+        raise Web3TypeError(
             f"ABI definitions must be a list or dictionary, "
             f"got {abi_types_for_method!r}"
         )

web3/middleware/signing.py

@@ -55,6 +55,9 @@ from web3._utils.transactions import (
     fill_nonce,
     fill_transaction_defaults,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -108,7 +111,7 @@ def gen_normalized_accounts(
 
 @singledispatch
 def to_account(val: Any) -> LocalAccount:
-    raise TypeError(
+    raise Web3TypeError(
         "key must be one of the types: "
         "eth_keys.datatype.PrivateKey, eth_account.signers.local.LocalAccount, "
         "or raw private key as a hex string or byte string. "
@@ -132,7 +135,8 @@ to_account.register(bytes, private_key_to_account)
 
 
 def format_transaction(transaction: TxParams) -> TxParams:
-    """Format transaction so that it can be used correctly in the signing middleware.
+    """
+    Format transaction so that it can be used correctly in the signing middleware.
 
     Converts bytes to hex strings and other types that can be passed to
     the underlying layers. Also has the effect of normalizing 'from' for
@@ -178,7 +182,7 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
                 return method, params
             else:
                 account = self._accounts[to_checksum_address(tx_from)]
-                raw_tx = account.sign_transaction(filled_transaction).rawTransaction
+                raw_tx = account.sign_transaction(filled_transaction).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
@@ -207,7 +211,7 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
                 return method, params
             else:
                 account = self._accounts[to_checksum_address(tx_from)]
-                raw_tx = account.sign_transaction(filled_transaction).rawTransaction
+                raw_tx = account.sign_transaction(filled_transaction).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),

web3/middleware/stalecheck.py

@@ -16,6 +16,7 @@ from toolz import (
 
 from web3.exceptions import (
     StaleBlockchain,
+    Web3ValueError,
 )
 from web3.middleware.base import (
     Web3Middleware,
@@ -54,7 +55,7 @@ class StalecheckMiddlewareBuilder(Web3MiddlewareBuilder):
         skip_stalecheck_for_methods: Collection[str] = SKIP_STALECHECK_FOR_METHODS,
     ) -> Web3Middleware:
         if allowable_delay <= 0:
-            raise ValueError(
+            raise Web3ValueError(
                 "You must set a positive allowable_delay in seconds for this middleware"
             )
         middleware = StalecheckMiddlewareBuilder(w3)