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

web3/manager.py

@@ -1,9 +1,11 @@
+import asyncio
 import logging
 from typing import (
     TYPE_CHECKING,
     Any,
     AsyncGenerator,
     Callable,
+    Coroutine,
     List,
     Optional,
     Sequence,
@@ -22,6 +24,9 @@ from websockets.exceptions import (
     ConnectionClosedOK,
 )
 
+from web3._utils.batching import (
+    RequestBatcher,
+)
 from web3._utils.caching import (
     generate_cache_key,
 )
@@ -35,8 +40,12 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    TaskNotRunning,
+    Web3RPCError,
     Web3TypeError,
-    Web3ValueError,
+)
+from web3.method import (
+    Method,
 )
 from web3.middleware import (
     AttributeDictMiddleware,
@@ -54,8 +63,12 @@ from web3.module import (
 )
 from web3.providers import (
     AutoProvider,
+    JSONBaseProvider,
     PersistentConnectionProvider,
 )
+from web3.providers.async_base import (
+    AsyncJSONBaseProvider,
+)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -87,6 +100,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}"
@@ -117,6 +131,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")
 
@@ -203,90 +322,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"'
-            )
-
-        # 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"'
-            )
-
-        # 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 Web3ValueError(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)
+        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
+        )
 
-            raise Web3ValueError(error)
+        _validate_response(
+            response,
+            error_formatters,
+            is_subscription_response=is_subscription_response,
+            logger=self.logger,
+        )
 
-        # 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]],
@@ -317,6 +388,88 @@ class RequestManager:
             response, params, error_formatters, null_result_formatters
         )
 
+    # -- batch requests management -- #
+
+    def _batch_requests(self) -> RequestBatcher[Method[Callable[..., Any]]]:
+        """
+        Context manager for making batch requests
+        """
+        if not isinstance(self.provider, (AsyncJSONBaseProvider, JSONBaseProvider)):
+            raise Web3TypeError("Batch requests are not supported by this provider.")
+        return RequestBatcher(self.w3)
+
+    def _make_batch_request(
+        self, requests_info: List[Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]]
+    ) -> List[RPCResponse]:
+        """
+        Make a batch request using the provider
+        """
+        provider = cast(JSONBaseProvider, self.provider)
+        request_func = provider.batch_request_func(
+            cast("Web3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
+        )
+        responses = request_func(
+            [
+                (method, params)
+                for (method, params), _response_formatters in requests_info
+            ]
+        )
+        formatted_responses = [
+            self._format_batched_response(info, resp)
+            for info, resp in zip(requests_info, responses)
+        ]
+        return list(formatted_responses)
+
+    async def _async_make_batch_request(
+        self,
+        requests_info: List[
+            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]]
+        ],
+    ) -> List[RPCResponse]:
+        """
+        Make an asynchronous batch request using the provider
+        """
+        provider = cast(AsyncJSONBaseProvider, self.provider)
+        request_func = await provider.batch_request_func(
+            cast("AsyncWeb3", self.w3),
+            cast("MiddlewareOnion", self.middleware_onion),
+        )
+        # since we add items to the batch without awaiting, we unpack the coroutines
+        # and await them all here
+        unpacked_requests_info = await asyncio.gather(*requests_info)
+        responses = await request_func(
+            [
+                (method, params)
+                for (method, params), _response_formatters in unpacked_requests_info
+            ]
+        )
+
+        if isinstance(self.provider, PersistentConnectionProvider):
+            # call _process_response for each response in the batch
+            return [await self._process_response(resp) for resp in responses]
+
+        formatted_responses = [
+            self._format_batched_response(info, resp)
+            for info, resp in zip(unpacked_requests_info, responses)
+        ]
+        return list(formatted_responses)
+
+    def _format_batched_response(
+        self,
+        requests_info: Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]],
+        response: RPCResponse,
+    ) -> RPCResponse:
+        result_formatters, error_formatters, null_result_formatters = requests_info[1]
+        return apply_result_formatters(
+            result_formatters,
+            self.formatted_response(
+                response,
+                requests_info[0][1],
+                error_formatters,
+                null_result_formatters,
+            ),
+        )
+
     # -- persistent connection -- #
 
     async def send(self, method: RPCEndpoint, params: Any) -> RPCResponse:
@@ -350,14 +503,24 @@ class RequestManager:
             )
 
         while True:
-            response = await self._request_processor.pop_raw_response(subscription=True)
-            if (
-                response is not None
-                and response.get("params", {}).get("subscription")
-                in self._request_processor.active_subscriptions
-            ):
-                # if response is an active subscription response, process it
-                yield await self._process_response(response)
+            try:
+                response = await self._request_processor.pop_raw_response(
+                    subscription=True
+                )
+                if (
+                    response is not None
+                    and response.get("params", {}).get("subscription")
+                    in self._request_processor.active_subscriptions
+                ):
+                    # if response is an active subscription response, process it
+                    yield await self._process_response(response)
+            except TaskNotRunning:
+                self._provider._handle_listener_task_exceptions()
+                self.logger.error(
+                    "Message listener background task has stopped unexpectedly. "
+                    "Stopping message stream."
+                )
+                raise StopAsyncIteration
 
     async def _process_response(self, response: RPCResponse) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)

web3/method.py

@@ -10,7 +10,6 @@ from typing import (
     Sequence,
     Tuple,
     Type,
-    TypeVar,
     Union,
 )
 import warnings
@@ -22,6 +21,9 @@ from eth_utils.toolz import (
     pipe,
 )
 
+from web3._utils.batching import (
+    RPC_METHODS_UNSUPPORTED_DURING_BATCH,
+)
 from web3._utils.method_formatters import (
     get_error_formatters,
     get_null_result_formatters,
@@ -32,17 +34,22 @@ from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
+    MethodNotSupported,
     Web3TypeError,
     Web3ValidationError,
     Web3ValueError,
 )
 from web3.types import (
     RPCEndpoint,
+    TFunc,
     TReturn,
 )
 
 if TYPE_CHECKING:
-    from web3 import Web3  # noqa: F401
+    from web3 import (  # noqa: F401
+        PersistentConnectionProvider,
+        Web3,
+    )
     from web3.module import Module  # noqa: F401
 
 
@@ -84,9 +91,6 @@ def default_root_munger(_module: "Module", *args: Any) -> List[Any]:
     return [*args]
 
 
-TFunc = TypeVar("TFunc", bound=Callable[..., Any])
-
-
 class Method(Generic[TFunc]):
     """
     Method object for web3 module methods
@@ -149,15 +153,31 @@ class Method(Generic[TFunc]):
         self.is_property = is_property
 
     def __get__(
-        self, obj: Optional["Module"] = None, obj_type: Optional[Type["Module"]] = None
+        self,
+        module: Optional["Module"] = None,
+        _type: Optional[Type["Module"]] = None,
     ) -> TFunc:
-        if obj is None:
+        self._module = module
+        if module is None:
             raise Web3TypeError(
                 "Direct calls to methods are not supported. "
-                "Methods must be called from an module instance, "
+                "Methods must be called from a module instance, "
                 "usually attached to a web3 instance."
             )
-        return obj.retrieve_caller_fn(self)
+
+        provider = module.w3.provider
+        if hasattr(provider, "_is_batching") and provider._is_batching:
+            if self.json_rpc_method in RPC_METHODS_UNSUPPORTED_DURING_BATCH:
+                raise MethodNotSupported(
+                    f"Method `{self.json_rpc_method}` is not supported within a batch "
+                    "request."
+                )
+            return module.retrieve_request_information(self)
+        else:
+            return module.retrieve_caller_fn(self)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.__get__(self._module)(*args, **kwargs)
 
     @property
     def method_selector_fn(

web3/middleware/base.py

@@ -4,6 +4,8 @@ from abc import (
 from typing import (
     TYPE_CHECKING,
     Any,
+    List,
+    Tuple,
     Type,
     Union,
 )
@@ -18,7 +20,9 @@ if TYPE_CHECKING:
         Web3,
     )
     from web3.types import (  # noqa: F401
+        AsyncMakeBatchRequestFn,
         AsyncMakeRequestFn,
+        MakeBatchRequestFn,
         MakeRequestFn,
         RPCEndpoint,
         RPCResponse,
@@ -45,6 +49,25 @@ class Web3Middleware:
 
         return middleware
 
+    def wrap_make_batch_request(
+        self, make_batch_request: "MakeBatchRequestFn"
+    ) -> "MakeBatchRequestFn":
+        def middleware(
+            requests_info: List[Tuple["RPCEndpoint", Any]]
+        ) -> List["RPCResponse"]:
+            req_processed = [
+                self.request_processor(method, params)
+                for (method, params) in requests_info
+            ]
+            responses = make_batch_request(req_processed)
+            methods, _params = zip(*req_processed)
+            formatted_responses = [
+                self.response_processor(m, r) for m, r in zip(methods, responses)
+            ]
+            return formatted_responses
+
+        return middleware
+
     def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         return method, params
 
@@ -67,6 +90,26 @@ class Web3Middleware:
 
         return middleware
 
+    async def async_wrap_make_batch_request(
+        self, make_batch_request: "AsyncMakeBatchRequestFn"
+    ) -> "AsyncMakeBatchRequestFn":
+        async def middleware(
+            requests_info: List[Tuple["RPCEndpoint", Any]]
+        ) -> List["RPCResponse"]:
+            req_processed = [
+                await self.async_request_processor(method, params)
+                for (method, params) in requests_info
+            ]
+            responses = await make_batch_request(req_processed)
+            methods, _params = zip(*req_processed)
+            formatted_responses = [
+                await self.async_response_processor(m, r)
+                for m, r in zip(methods, responses)
+            ]
+            return formatted_responses
+
+        return middleware
+
     async def async_request_processor(
         self,
         method: "RPCEndpoint",

web3/middleware/filter.py

@@ -589,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] = {}
@@ -615,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]
@@ -626,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:
@@ -663,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]
@@ -674,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/signing.py

@@ -182,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"),
@@ -211,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"),