web3 6.20.2__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/providers/async_base.py

@@ -1,10 +1,13 @@
+import asyncio
 import itertools
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Coroutine,
-    Sequence,
+    List,
+    Optional,
+    Set,
     Tuple,
     cast,
 )
@@ -15,6 +18,10 @@ from eth_utils import (
     to_text,
 )
 
+from web3._utils.caching import (
+    CACHEABLE_REQUESTS,
+    async_handle_request_caching,
+)
 from web3._utils.encoding import (
     FriendlyJsonSerde,
     Web3JsonEncoder,
@@ -23,81 +30,138 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    async_combine_middlewares,
+    async_combine_middleware,
 )
-from web3.types import (
-    AsyncMiddleware,
-    AsyncMiddlewareOnion,
+from web3.middleware.base import (
+    Middleware,
     MiddlewareOnion,
+)
+from web3.types import (
     RPCEndpoint,
     RPCResponse,
 )
+from web3.utils import (
+    SimpleCache,
+)
 
 if TYPE_CHECKING:
+    from websockets import (
+        WebSocketClientProtocol,
+    )
+
     from web3 import (  # noqa: F401
         AsyncWeb3,
-        WebsocketProviderV2,
+        WebSocketProvider,
+    )
+    from web3.providers.persistent import (  # noqa: F401
+        RequestProcessor,
     )
 
 
 class AsyncBaseProvider:
-    _middlewares: Tuple[AsyncMiddleware, ...] = ()
-    # a tuple of (all_middlewares, request_func)
     _request_func_cache: Tuple[
-        Tuple[AsyncMiddleware, ...], Callable[..., Coroutine[Any, Any, RPCResponse]]
-    ] = (
-        None,
-        None,
-    )
+        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
 
-    @property
-    def middlewares(self) -> Tuple[AsyncMiddleware, ...]:
-        return self._middlewares
+    # request caching
+    _request_cache: SimpleCache
+    _request_cache_lock: asyncio.Lock = asyncio.Lock()
 
-    @middlewares.setter
-    def middlewares(self, values: MiddlewareOnion) -> None:
-        # tuple(values) converts to MiddlewareOnion -> Tuple[Middleware, ...]
-        self._middlewares = tuple(values)  # type: ignore
+    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", outer_middlewares: AsyncMiddlewareOnion
+        self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
-        # type ignored b/c tuple(MiddlewareOnion) converts to tuple of middlewares
-        all_middlewares: Tuple[AsyncMiddleware] = tuple(outer_middlewares) + tuple(self.middlewares)  # type: ignore  # noqa: E501
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key is None or cache_key != all_middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                all_middlewares,
-                await self._generate_request_func(async_w3, all_middlewares),
+                middleware,
+                await async_combine_middleware(
+                    middleware=middleware,
+                    async_w3=async_w3,
+                    provider_request_fn=self.make_request,
+                ),
             )
         return self._request_func_cache[-1]
 
-    async def _generate_request_func(
-        self, async_w3: "AsyncWeb3", middlewares: Sequence[AsyncMiddleware]
-    ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
-        return await async_combine_middlewares(
-            middlewares=middlewares,
-            async_w3=async_w3,
-            provider_request_fn=self.make_request,
-        )
+    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")
 
+    # -- persistent connection providers -- #
+
+    _request_processor: "RequestProcessor"
+    _message_listener_task: "asyncio.Task[None]"
+    _listen_event: "asyncio.Event"
+
+    async def connect(self) -> None:
+        raise NotImplementedError(
+            "Persistent connection providers must implement this method"
+        )
+
+    async def disconnect(self) -> None:
+        raise NotImplementedError(
+            "Persistent connection providers must implement this method"
+        )
+
+    # WebSocket typing
+    _ws: "WebSocketClientProtocol"
+
+    # IPC typing
+    _reader: Optional[asyncio.StreamReader]
+    _writer: Optional[asyncio.StreamWriter]
+
 
 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)
@@ -110,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
         )
@@ -119,7 +184,7 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
     async def is_connected(self, show_traceback: bool = False) -> bool:
         try:
             response = await self.make_request(RPCEndpoint("web3_clientVersion"), [])
-        except OSError as e:
+        except (OSError, ProviderConnectionError) as e:
             if show_traceback:
                 raise ProviderConnectionError(
                     f"Problem connecting to provider with error: {type(e)}: {e}"
@@ -133,9 +198,22 @@ class AsyncJSONBaseProvider(AsyncBaseProvider):
                 )
             return False
 
-        if response["jsonrpc"] == "2.0":
+        if response.get("jsonrpc") == "2.0":
             return True
         else:
             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/auto.py

@@ -24,7 +24,7 @@ from web3.providers import (
     BaseProvider,
     HTTPProvider,
     IPCProvider,
-    WebsocketProvider,
+    LegacyWebSocketProvider,
 )
 from web3.types import (
     RPCEndpoint,
@@ -52,7 +52,7 @@ def load_provider_from_uri(
     elif uri.scheme in HTTP_SCHEMES:
         return HTTPProvider(uri_string, headers)
     elif uri.scheme in WS_SCHEMES:
-        return WebsocketProvider(uri_string)
+        return LegacyWebSocketProvider(uri_string)
     else:
         raise NotImplementedError(
             "Web3 does not know how to connect to scheme "
@@ -65,7 +65,7 @@ class AutoProvider(BaseProvider):
         load_provider_from_environment,
         IPCProvider,
         HTTPProvider,
-        WebsocketProvider,
+        LegacyWebSocketProvider,
     )
     _active_provider = None
 

web3/providers/base.py

@@ -1,9 +1,11 @@
 import itertools
+import threading
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Sequence,
+    List,
+    Set,
     Tuple,
     cast,
 )
@@ -13,6 +15,10 @@ from eth_utils import (
     to_text,
 )
 
+from web3._utils.caching import (
+    CACHEABLE_REQUESTS,
+    handle_request_caching,
+)
 from web3._utils.encoding import (
     FriendlyJsonSerde,
     Web3JsonEncoder,
@@ -21,22 +27,26 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    combine_middlewares,
+    combine_middleware,
 )
-from web3.types import (
+from web3.middleware.base import (
     Middleware,
     MiddlewareOnion,
+)
+from web3.types import (
     RPCEndpoint,
     RPCResponse,
 )
+from web3.utils import (
+    SimpleCache,
+)
 
 if TYPE_CHECKING:
     from web3 import Web3  # noqa: F401
 
 
 class BaseProvider:
-    _middlewares: Tuple[Middleware, ...] = ()
-    # a tuple of (all_middlewares, request_func)
+    # a tuple of (middleware, request_func)
     _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
         None,
         None,
@@ -47,44 +57,45 @@ class BaseProvider:
     global_ccip_read_enabled: bool = True
     ccip_read_max_redirects: int = 4
 
-    @property
-    def middlewares(self) -> Tuple[Middleware, ...]:
-        return self._middlewares
+    # request caching
+    _request_cache: SimpleCache
+    _request_cache_lock: threading.Lock = threading.Lock()
 
-    @middlewares.setter
-    def middlewares(self, values: MiddlewareOnion) -> None:
-        # tuple(values) converts to MiddlewareOnion -> Tuple[Middleware, ...]
-        self._middlewares = tuple(values)  # type: ignore
+    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", outer_middlewares: MiddlewareOnion
+        self, w3: "Web3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., RPCResponse]:
         """
-        @param outer_middlewares is an iterable of middlewares,
+        @param w3 is the web3 instance
+        @param middleware_onion is an iterable of middleware,
             ordered by first to execute
         @returns a function that calls all the middleware and
             eventually self.make_request()
         """
-        # type ignored b/c tuple(MiddlewareOnion) converts to tuple of middlewares
-        all_middlewares: Tuple[Middleware] = tuple(outer_middlewares) + tuple(self.middlewares)  # type: ignore # noqa: E501
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key is None or cache_key != all_middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                all_middlewares,
-                self._generate_request_func(w3, all_middlewares),
+                middleware,
+                combine_middleware(
+                    middleware=middleware,
+                    w3=w3,
+                    provider_request_fn=self.make_request,
+                ),
             )
-        return self._request_func_cache[-1]
 
-    def _generate_request_func(
-        self, w3: "Web3", middlewares: Sequence[Middleware]
-    ) -> Callable[..., RPCResponse]:
-        return combine_middlewares(
-            middlewares=middlewares,
-            w3=w3,
-            provider_request_fn=self.make_request,
-        )
+        return self._request_func_cache[-1]
 
+    @handle_request_caching
     def make_request(self, method: RPCEndpoint, params: Any) -> RPCResponse:
         raise NotImplementedError("Providers must implement this method")
 
@@ -93,12 +104,14 @@ class BaseProvider:
 
 
 class JSONBaseProvider(BaseProvider):
-    def __init__(self) -> None:
-        self.request_counter = itertools.count()
+    _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 = {
@@ -110,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"), [])
@@ -133,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/__init__.py

@@ -2,3 +2,8 @@ from .main import (
     AsyncEthereumTesterProvider,
     EthereumTesterProvider,
 )
+
+__all__ = [
+    "AsyncEthereumTesterProvider",
+    "EthereumTesterProvider",
+]

web3/providers/eth_tester/defaults.py

@@ -21,7 +21,6 @@ from eth_tester.exceptions import (
     FilterNotFound,
     TransactionFailed,
     TransactionNotFound,
-    ValidationError,
 )
 from eth_typing import (
     HexAddress,
@@ -218,7 +217,7 @@ def _generate_random_private_key() -> HexStr:
     WARNING: This is not a secure way to generate private keys and should only
     be used for testing purposes.
     """
-    return encode_hex(bytes(bytearray((random.randint(0, 255) for _ in range(32)))))
+    return encode_hex(bytes(bytearray(random.randint(0, 255) for _ in range(32))))
 
 
 @without_params
@@ -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,
@@ -256,12 +243,6 @@ API_ENDPOINTS = {
     "eth": {
         "protocolVersion": static_return(63),
         "syncing": static_return(False),
-        "coinbase": compose(
-            operator.itemgetter(0),
-            call_eth_tester("get_accounts"),
-        ),
-        "mining": static_return(False),
-        "hashrate": static_return(0),
         "chainId": static_return(131277322940537),  # from fixture generation file
         "feeHistory": call_eth_tester("get_fee_history"),
         "maxPriorityFeePerGas": static_return(10**9),
@@ -404,50 +385,6 @@ API_ENDPOINTS = {
         "writeBlockProfile": not_implemented,
         "writeMemProfile": not_implemented,
     },
-    "miner": {
-        "make_dag": not_implemented,
-        "set_extra": not_implemented,
-        "set_gas_price": not_implemented,
-        "start": not_implemented,
-        "stop": not_implemented,
-        "start_auto_dag": not_implemented,
-        "stop_auto_dag": 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"),
     },