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

web3/module.py

@@ -5,6 +5,8 @@ from typing import (
     Coroutine,
     Dict,
     Optional,
+    Sequence,
+    Tuple,
     TypeVar,
     Union,
     cast,
@@ -55,9 +57,43 @@ def apply_result_formatters(
 TReturn = TypeVar("TReturn")
 
 
+@curry
+def retrieve_request_information_for_batching(
+    w3: Union["AsyncWeb3", "Web3"],
+    module: "Module",
+    method: Method[Callable[..., Any]],
+) -> Union[
+    Callable[..., Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]],
+    Callable[..., Coroutine[Any, Any, Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]]],
+]:
+    async def async_inner(
+        *args: Any, **kwargs: Any
+    ) -> Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]:
+        (method_str, params), response_formatters = method.process_params(
+            module, *args, **kwargs
+        )
+        if isinstance(w3.provider, PersistentConnectionProvider):
+            w3.provider._request_processor.cache_request_information(
+                cast(RPCEndpoint, method_str), params, response_formatters
+            )
+        return (cast(RPCEndpoint, method_str), params), response_formatters
+
+    def inner(
+        *args: Any, **kwargs: Any
+    ) -> Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]]:
+        (method_str, params), response_formatters = method.process_params(
+            module, *args, **kwargs
+        )
+        return (cast(RPCEndpoint, method_str), params), response_formatters
+
+    return async_inner if module.is_async else inner
+
+
 @curry
 def retrieve_blocking_method_call_fn(
-    w3: "Web3", module: "Module", method: Method[Callable[..., TReturn]]
+    w3: "Web3",
+    module: "Module",
+    method: Method[Callable[..., TReturn]],
 ) -> Callable[..., Union[TReturn, LogFilter]]:
     def caller(*args: Any, **kwargs: Any) -> Union[TReturn, LogFilter]:
         try:
@@ -82,7 +118,9 @@ def retrieve_blocking_method_call_fn(
 
 @curry
 def retrieve_async_method_call_fn(
-    async_w3: "AsyncWeb3", module: "Module", method: Method[Callable[..., Any]]
+    async_w3: "AsyncWeb3",
+    module: "Module",
+    method: Method[Callable[..., Any]],
 ) -> Callable[..., Coroutine[Any, Any, Optional[Union[RPCResponse, AsyncLogFilter]]]]:
     async def caller(*args: Any, **kwargs: Any) -> Union[RPCResponse, AsyncLogFilter]:
         try:
@@ -93,12 +131,11 @@ def retrieve_async_method_call_fn(
             return AsyncLogFilter(eth_module=module, filter_id=err.filter_id)
 
         if isinstance(async_w3.provider, PersistentConnectionProvider):
-            # TODO: The typing does not seem to be correct for response_formatters.
-            #   For now, keep the expected typing but ignore it here.
             provider = async_w3.provider
             cache_key = provider._request_processor.cache_request_information(
-                cast(RPCEndpoint, method_str), params, response_formatters  # type: ignore # noqa: E501
+                cast(RPCEndpoint, method_str), params, response_formatters
             )
+
             try:
                 method_str = cast(RPCEndpoint, method_str)
                 return await async_w3.manager.send(method_str, params)
@@ -139,6 +176,9 @@ class Module:
             self.retrieve_caller_fn = retrieve_async_method_call_fn(w3, self)
         else:
             self.retrieve_caller_fn = retrieve_blocking_method_call_fn(w3, self)
+        self.retrieve_request_information = retrieve_request_information_for_batching(
+            w3, self
+        )
         self.w3 = w3
 
     @property
@@ -152,8 +192,8 @@ class Module:
     ) -> None:
         for method_name, method_class in methods.items():
             klass = (
-                method_class.__get__(obj=self)()
+                method_class.__get__(module=self)()
                 if method_class.is_property
-                else method_class.__get__(obj=self)
+                else method_class.__get__(module=self)
             )
             setattr(self, method_name, klass)

web3/providers/async_base.py

@@ -5,6 +5,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    List,
     Optional,
     Set,
     Tuple,
@@ -18,6 +19,7 @@ from eth_utils import (
 )
 
 from web3._utils.caching import (
+    CACHEABLE_REQUESTS,
     async_handle_request_caching,
 )
 from web3._utils.encoding import (
@@ -56,41 +58,33 @@ if TYPE_CHECKING:
     )
 
 
-CACHEABLE_REQUESTS = cast(
-    Set[RPCEndpoint],
-    (
-        "eth_chainId",
-        "eth_getBlockByHash",
-        "eth_getBlockTransactionCountByHash",
-        "eth_getRawTransactionByHash",
-        "eth_getTransactionByBlockHashAndIndex",
-        "eth_getTransactionByHash",
-        "eth_getUncleByBlockHashAndIndex",
-        "eth_getUncleCountByBlockHash",
-        "net_version",
-        "web3_clientVersion",
-    ),
-)
-
-
 class AsyncBaseProvider:
     _request_func_cache: Tuple[
         Tuple[Middleware, ...], Callable[..., Coroutine[Any, Any, RPCResponse]]
     ] = (None, None)
 
+    _is_batching: bool = False
+    _batch_request_func_cache: Tuple[
+        Tuple[Middleware, ...], Callable[..., Coroutine[Any, Any, List[RPCResponse]]]
+    ] = (None, None)
+
     is_async = True
     has_persistent_connection = False
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
     # request caching
-    cache_allowed_requests: bool = False
-    cacheable_requests: Set[RPCEndpoint] = CACHEABLE_REQUESTS
     _request_cache: SimpleCache
     _request_cache_lock: asyncio.Lock = asyncio.Lock()
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        cache_allowed_requests: bool = False,
+        cacheable_requests: Set[RPCEndpoint] = None,
+    ) -> None:
         self._request_cache = SimpleCache(1000)
+        self.cache_allowed_requests = cache_allowed_requests
+        self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
 
     async def request_func(
         self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
@@ -109,10 +103,34 @@ class AsyncBaseProvider:
             )
         return self._request_func_cache[-1]
 
+    async def batch_request_func(
+        self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
+    ) -> Callable[..., Coroutine[Any, Any, List[RPCResponse]]]:
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
+
+        cache_key = self._batch_request_func_cache[0]
+        if cache_key != middleware:
+            accumulator_fn = self.make_batch_request
+            for mw in reversed(middleware):
+                initialized = mw(async_w3)
+                # type ignore bc in order to wrap the method, we have to call
+                # `async_wrap_make_batch_request` with the accumulator_fn as the
+                # argument which breaks the type hinting for this particular case.
+                accumulator_fn = await initialized.async_wrap_make_batch_request(  # type: ignore # noqa: E501
+                    accumulator_fn
+                )
+            self._batch_request_func_cache = (middleware, accumulator_fn)
+        return self._batch_request_func_cache[-1]
+
     @async_handle_request_caching
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         raise NotImplementedError("Providers must implement this method")
 
+    async def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        raise NotImplementedError("Only AsyncHTTPProvider supports this method")
+
     async def is_connected(self, show_traceback: bool = False) -> bool:
         raise NotImplementedError("Providers must implement this method")
 
@@ -141,9 +159,9 @@ class AsyncBaseProvider:
 
 
 class AsyncJSONBaseProvider(AsyncBaseProvider):
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, **kwargs: Any) -> None:
         self.request_counter = itertools.count()
+        super().__init__(**kwargs)
 
     def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
         request_id = next(self.request_counter)
@@ -156,7 +174,8 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
         encoded = FriendlyJsonSerde().json_encode(rpc_dict, cls=Web3JsonEncoder)
         return to_bytes(text=encoded)
 
-    def decode_rpc_response(self, raw_response: bytes) -> RPCResponse:
+    @staticmethod
+    def decode_rpc_response(raw_response: bytes) -> RPCResponse:
         text_response = str(
             to_text(raw_response) if not is_text(raw_response) else raw_response
         )
@@ -185,3 +204,16 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
             if show_traceback:
                 raise ProviderConnectionError(f"Bad jsonrpc version: {response}")
             return False
+
+    # -- batch requests -- #
+
+    def encode_batch_rpc_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> bytes:
+        return (
+            b"["
+            + b", ".join(
+                self.encode_rpc_request(method, params) for method, params in requests
+            )
+            + b"]"
+        )

web3/providers/base.py

@@ -4,6 +4,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    List,
     Set,
     Tuple,
     cast,
@@ -15,6 +16,7 @@ from eth_utils import (
 )
 
 from web3._utils.caching import (
+    CACHEABLE_REQUESTS,
     handle_request_caching,
 )
 from web3._utils.encoding import (
@@ -43,23 +45,6 @@ if TYPE_CHECKING:
     from web3 import Web3  # noqa: F401
 
 
-CACHEABLE_REQUESTS = cast(
-    Set[RPCEndpoint],
-    (
-        "eth_chainId",
-        "eth_getBlockByHash",
-        "eth_getBlockTransactionCountByHash",
-        "eth_getRawTransactionByHash",
-        "eth_getTransactionByBlockHashAndIndex",
-        "eth_getTransactionByHash",
-        "eth_getUncleByBlockHashAndIndex",
-        "eth_getUncleCountByBlockHash",
-        "net_version",
-        "web3_clientVersion",
-    ),
-)
-
-
 class BaseProvider:
     # a tuple of (middleware, request_func)
     _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
@@ -73,13 +58,17 @@ class BaseProvider:
     ccip_read_max_redirects: int = 4
 
     # request caching
-    cache_allowed_requests: bool = False
-    cacheable_requests: Set[RPCEndpoint] = CACHEABLE_REQUESTS
     _request_cache: SimpleCache
     _request_cache_lock: threading.Lock = threading.Lock()
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        cache_allowed_requests: bool = False,
+        cacheable_requests: Set[RPCEndpoint] = None,
+    ) -> None:
         self._request_cache = SimpleCache(1000)
+        self.cache_allowed_requests = cache_allowed_requests
+        self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
 
     def request_func(
         self, w3: "Web3", middleware_onion: MiddlewareOnion
@@ -115,13 +104,14 @@ class BaseProvider:
 
 
 class JSONBaseProvider(BaseProvider):
-    def __init__(self) -> None:
-        self.request_counter = itertools.count()
-        super().__init__()
+    _is_batching: bool = False
+    _batch_request_func_cache: Tuple[
+        Tuple[Middleware, ...], Callable[..., List[RPCResponse]]
+    ] = (None, None)
 
-    def decode_rpc_response(self, raw_response: bytes) -> RPCResponse:
-        text_response = to_text(raw_response)
-        return cast(RPCResponse, FriendlyJsonSerde().json_decode(text_response))
+    def __init__(self, **kwargs: Any) -> None:
+        self.request_counter = itertools.count()
+        super().__init__(**kwargs)
 
     def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
         rpc_dict = {
@@ -133,6 +123,11 @@ class JSONBaseProvider(BaseProvider):
         encoded = FriendlyJsonSerde().json_encode(rpc_dict, Web3JsonEncoder)
         return to_bytes(text=encoded)
 
+    @staticmethod
+    def decode_rpc_response(raw_response: bytes) -> RPCResponse:
+        text_response = to_text(raw_response)
+        return cast(RPCResponse, FriendlyJsonSerde().json_decode(text_response))
+
     def is_connected(self, show_traceback: bool = False) -> bool:
         try:
             response = self.make_request(RPCEndpoint("web3_clientVersion"), [])
@@ -156,3 +151,41 @@ class JSONBaseProvider(BaseProvider):
             if show_traceback:
                 raise ProviderConnectionError(f"Bad jsonrpc version: {response}")
             return False
+
+    #  -- batch requests -- #
+
+    def batch_request_func(
+        self, w3: "Web3", middleware_onion: MiddlewareOnion
+    ) -> Callable[..., List[RPCResponse]]:
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
+
+        cache_key = self._batch_request_func_cache[0]
+        if cache_key != middleware:
+            accumulator_fn = self.make_batch_request
+            for mw in reversed(middleware):
+                initialized = mw(w3)
+                # type ignore bc in order to wrap the method, we have to call
+                # `wrap_make_batch_request` with the accumulator_fn as the argument
+                # which breaks the type hinting for this particular case.
+                accumulator_fn = initialized.wrap_make_batch_request(
+                    accumulator_fn
+                )  # type: ignore  # noqa: E501
+            self._batch_request_func_cache = (middleware, accumulator_fn)
+
+        return self._batch_request_func_cache[-1]
+
+    def encode_batch_rpc_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> bytes:
+        return (
+            b"["
+            + b", ".join(
+                self.encode_rpc_request(method, params) for method, params in requests
+            )
+            + b"]"
+        )
+
+    def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        raise NotImplementedError("Providers must implement this method")

web3/providers/eth_tester/defaults.py

@@ -21,7 +21,6 @@ from eth_tester.exceptions import (
     FilterNotFound,
     TransactionFailed,
     TransactionNotFound,
-    ValidationError,
 )
 from eth_typing import (
     HexAddress,
@@ -226,18 +225,6 @@ def create_new_account(eth_tester: "EthereumTester") -> HexAddress:
     return eth_tester.add_account(_generate_random_private_key())
 
 
-def personal_send_transaction(eth_tester: "EthereumTester", params: Any) -> HexStr:
-    transaction, password = params
-
-    try:
-        eth_tester.unlock_account(transaction["from"], password)
-        transaction_hash = eth_tester.send_transaction(transaction)
-    finally:
-        eth_tester.lock_account(transaction["from"])
-
-    return transaction_hash
-
-
 API_ENDPOINTS = {
     "web3": {
         "clientVersion": client_version,
@@ -404,41 +391,6 @@ API_ENDPOINTS = {
         "writeBlockProfile": not_implemented,
         "writeMemProfile": not_implemented,
     },
-    "personal": {
-        "ec_recover": not_implemented,
-        "import_raw_key": call_eth_tester("add_account"),
-        "list_accounts": call_eth_tester("get_accounts"),
-        "list_wallets": not_implemented,
-        "lock_account": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("lock_account")),
-            static_return(False),
-        ),
-        "new_account": create_new_account,
-        "unlock_account": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("unlock_account")),
-            static_return(False),
-        ),
-        "send_transaction": personal_send_transaction,
-        "sign": not_implemented,
-        # deprecated
-        "ecRecover": not_implemented,
-        "importRawKey": call_eth_tester("add_account"),
-        "listAccounts": call_eth_tester("get_accounts"),
-        "lockAccount": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("lock_account")),
-            static_return(False),
-        ),
-        "newAccount": create_new_account,
-        "unlockAccount": excepts(
-            ValidationError,
-            compose(static_return(True), call_eth_tester("unlock_account")),
-            static_return(False),
-        ),
-        "sendTransaction": personal_send_transaction,
-    },
     "testing": {
         "timeTravel": call_eth_tester("time_travel"),
     },

web3/providers/eth_tester/main.py

@@ -7,6 +7,7 @@ from typing import (
     Literal,
     Optional,
     Union,
+    cast,
 )
 
 from eth_abi import (
@@ -59,6 +60,7 @@ if TYPE_CHECKING:
 
 
 class AsyncEthereumTesterProvider(AsyncBaseProvider):
+    _current_request_id = 0
     _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
@@ -99,13 +101,22 @@ class AsyncEthereumTesterProvider(AsyncBaseProvider):
         return self._request_func_cache[-1]
 
     async def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        return _make_request(method, params, self.api_endpoints, self.ethereum_tester)
+        response = _make_request(
+            method,
+            params,
+            self.api_endpoints,
+            self.ethereum_tester,
+            repr(self._current_request_id),
+        )
+        self._current_request_id += 1
+        return response
 
     async def is_connected(self, show_traceback: bool = False) -> Literal[True]:
         return True
 
 
 class EthereumTesterProvider(BaseProvider):
+    _current_request_id = 0
     _middleware = (
         default_transaction_fields_middleware,
         ethereum_tester_middleware,
@@ -173,23 +184,32 @@ class EthereumTesterProvider(BaseProvider):
         return self._request_func_cache[-1]
 
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        return _make_request(method, params, self.api_endpoints, self.ethereum_tester)
+        response = _make_request(
+            method,
+            params,
+            self.api_endpoints,
+            self.ethereum_tester,
+            repr(self._current_request_id),
+        )
+        self._current_request_id += 1
+        return response
 
     def is_connected(self, show_traceback: bool = False) -> Literal[True]:
         return True
 
 
-def _make_response(result: Any, message: str = "") -> RPCResponse:
+def _make_response(result: Any, response_id: str, message: str = "") -> RPCResponse:
     if isinstance(result, Exception):
-        return RPCResponse(
+        return cast(
+            RPCResponse,
             {
-                "id": 1,
+                "id": response_id,
                 "jsonrpc": "2.0",
-                "error": RPCError({"code": -32601, "message": message}),
-            }
+                "error": cast(RPCError, {"code": -32601, "message": message}),
+            },
         )
 
-    return RPCResponse({"id": 1, "jsonrpc": "2.0", "result": result})
+    return cast(RPCResponse, {"id": response_id, "jsonrpc": "2.0", "result": result})
 
 
 def _make_request(
@@ -197,6 +217,7 @@ def _make_request(
     params: Any,
     api_endpoints: Dict[str, Dict[str, Any]],
     ethereum_tester_instance: "EthereumTester",
+    request_id: str,
 ) -> RPCResponse:
     # do not import eth_tester derivatives until runtime,
     # it is not a default dependency
@@ -209,11 +230,15 @@ def _make_request(
     try:
         delegator = api_endpoints[namespace][endpoint]
     except KeyError as e:
-        return _make_response(e, f"Unknown RPC Endpoint: {method}")
+        return _make_response(e, request_id, message=f"Unknown RPC Endpoint: {method}")
     try:
         response = delegator(ethereum_tester_instance, params)
     except NotImplementedError as e:
-        return _make_response(e, f"RPC Endpoint has not been implemented: {method}")
+        return _make_response(
+            e,
+            request_id,
+            message=f"RPC Endpoint has not been implemented: {method}",
+        )
     except TransactionFailed as e:
         first_arg = e.args[0]
         try:
@@ -230,4 +255,4 @@ def _make_request(
             reason = first_arg
         raise TransactionFailed(f"execution reverted: {reason}")
     else:
-        return _make_response(response)
+        return _make_response(response, request_id)

web3/providers/eth_tester/middleware.py

@@ -110,14 +110,14 @@ filter_request_remapper = apply_key_map(FILTER_REQUEST_KEY_MAPPING)
 
 
 FILTER_REQUEST_FORMATTERS = {
-    "fromBlock": to_integer_if_hex,
-    "toBlock": to_integer_if_hex,
+    "from_block": to_integer_if_hex,
+    "to_block": to_integer_if_hex,
 }
 filter_request_formatter = apply_formatters_to_dict(FILTER_REQUEST_FORMATTERS)
 
 filter_request_transformer = compose(
-    filter_request_remapper,
     filter_request_formatter,
+    filter_request_remapper,
 )
 
 
@@ -285,11 +285,6 @@ request_formatters = {
     ),
     # EVM
     RPCEndpoint("evm_revert"): apply_formatters_to_args(hex_to_integer),
-    # Personal
-    RPCEndpoint("personal_sendTransaction"): apply_formatters_to_args(
-        transaction_request_transformer,
-        identity,
-    ),
 }
 
 result_formatters: Optional[Dict[RPCEndpoint, Callable[..., Any]]] = {

web3/providers/ipc.py

@@ -14,8 +14,11 @@ from types import (
 )
 from typing import (
     Any,
+    List,
+    Tuple,
     Type,
     Union,
+    cast,
 )
 
 from web3._utils.threads import (
@@ -26,6 +29,9 @@ from web3.types import (
     RPCResponse,
 )
 
+from .._utils.batching import (
+    sort_batch_response_by_response_ids,
+)
 from ..exceptions import (
     Web3TypeError,
     Web3ValueError,
@@ -135,7 +141,6 @@ class IPCProvider(JSONBaseProvider):
         self,
         ipc_path: Union[str, Path] = None,
         timeout: int = 30,
-        *args: Any,
         **kwargs: Any,
     ) -> None:
         if ipc_path is None:
@@ -148,17 +153,12 @@ class IPCProvider(JSONBaseProvider):
         self.timeout = timeout
         self._lock = threading.Lock()
         self._socket = PersistantSocket(self.ipc_path)
-        super().__init__()
+        super().__init__(**kwargs)
 
     def __str__(self) -> str:
         return f"<{self.__class__.__name__} {self.ipc_path}>"
 
-    def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
-        self.logger.debug(
-            f"Making request IPC. Path: {self.ipc_path}, Method: {method}"
-        )
-        request = self.encode_rpc_request(method, params)
-
+    def _make_request(self, request: bytes) -> RPCResponse:
         with self._lock, self._socket as sock:
             try:
                 sock.sendall(request)
@@ -189,6 +189,21 @@ class IPCProvider(JSONBaseProvider):
                         timeout.sleep(0)
                         continue
 
+    def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
+        self.logger.debug(
+            f"Making request IPC. Path: {self.ipc_path}, Method: {method}"
+        )
+        request = self.encode_rpc_request(method, params)
+        return self._make_request(request)
+
+    def make_batch_request(
+        self, requests: List[Tuple[RPCEndpoint, Any]]
+    ) -> List[RPCResponse]:
+        self.logger.debug(f"Making batch request IPC. Path: {self.ipc_path}")
+        request_data = self.encode_batch_rpc_request(requests)
+        response = cast(List[RPCResponse], self._make_request(request_data))
+        return sort_batch_response_by_response_ids(response)
+
 
 # A valid JSON RPC response can only end in } or ] http://www.jsonrpc.org/specification
 def has_valid_json_rpc_ending(raw_response: bytes) -> bool: