web3 7.0.0b1__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/middleware/signing.py

@@ -19,6 +19,9 @@ from eth_account import (
 from eth_account.signers.local import (
     LocalAccount,
 )
+from eth_account.types import (
+    TransactionDictType as EthAccountTxParams,
+)
 from eth_keys.datatypes import (
     PrivateKey,
 )
@@ -55,6 +58,9 @@ from web3._utils.transactions import (
     fill_nonce,
     fill_transaction_defaults,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -108,7 +114,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 +138,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,11 +185,11 @@ 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"),
-                    [raw_tx.hex()],
+                    [raw_tx.to_0x_hex()],
                 )
 
     # -- async -- #
@@ -207,9 +214,11 @@ 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(
+                    cast(EthAccountTxParams, filled_transaction)
+                ).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
-                    [raw_tx.hex()],
+                    [raw_tx.to_0x_hex()],
                 )

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)

web3/module.py

@@ -5,6 +5,8 @@ from typing import (
     Coroutine,
     Dict,
     Optional,
+    Sequence,
+    Tuple,
     TypeVar,
     Union,
     cast,
@@ -30,6 +32,7 @@ from web3.providers.persistent import (
     PersistentConnectionProvider,
 )
 from web3.types import (
+    FormattedEthSubscriptionResponse,
     RPCEndpoint,
     RPCResponse,
 )
@@ -55,9 +58,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(
+                None, 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,9 +119,20 @@ def retrieve_blocking_method_call_fn(
 
 @curry
 def retrieve_async_method_call_fn(
-    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]:
+    async_w3: "AsyncWeb3",
+    module: "Module",
+    method: Method[Callable[..., Any]],
+) -> Callable[
+    ...,
+    Coroutine[
+        Any,
+        Any,
+        Optional[Union[RPCResponse, FormattedEthSubscriptionResponse, AsyncLogFilter]],
+    ],
+]:
+    async def caller(
+        *args: Any, **kwargs: Any
+    ) -> Union[RPCResponse, FormattedEthSubscriptionResponse, AsyncLogFilter]:
         try:
             (method_str, params), response_formatters = method.process_params(
                 module, *args, **kwargs
@@ -93,32 +141,17 @@ 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
+            return await async_w3.manager.socket_request(
+                cast(RPCEndpoint, method_str),
+                params,
+                response_formatters=response_formatters,
             )
-            try:
-                method_str = cast(RPCEndpoint, method_str)
-                return await async_w3.manager.send(method_str, params)
-            except Exception as e:
-                if (
-                    cache_key is not None
-                    and cache_key
-                    in provider._request_processor._request_information_cache
-                ):
-                    provider._request_processor.pop_cached_request_information(
-                        cache_key
-                    )
-                raise e
         else:
             (
                 result_formatters,
                 error_formatters,
                 null_result_formatters,
             ) = response_formatters
-
             result = await async_w3.manager.coro_request(
                 method_str, params, error_formatters, null_result_formatters
             )
@@ -129,7 +162,7 @@ def retrieve_async_method_call_fn(
 
 #  Module should no longer have access to the full web3 api.
 #  Only the calling functions need access to the request methods.
-#  Any "re-entrant" shenanigans can go in the middlewares, which do
+#  Any "re-entrant" shenanigans can go in the middleware, which do
 #  have web3 access.
 class Module:
     is_async = False
@@ -139,6 +172,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 +188,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/__init__.py

@@ -8,6 +8,10 @@ from .base import (
     BaseProvider,
     JSONBaseProvider,
 )
+from .eth_tester import (
+    AsyncEthereumTesterProvider,
+    EthereumTesterProvider,
+)
 from .ipc import (
     IPCProvider,
 )
@@ -26,3 +30,20 @@ from .persistent import (
 from .auto import (
     AutoProvider,
 )
+
+__all__ = [
+    "AsyncBaseProvider",
+    "AsyncEthereumTesterProvider",
+    "AsyncHTTPProvider",
+    "AsyncIPCProvider",
+    "AutoProvider",
+    "BaseProvider",
+    "EthereumTesterProvider",
+    "HTTPProvider",
+    "IPCProvider",
+    "JSONBaseProvider",
+    "LegacyWebSocketProvider",
+    "PersistentConnection",
+    "PersistentConnectionProvider",
+    "WebSocketProvider",
+]

web3/providers/async_base.py

@@ -1,13 +1,17 @@
 import asyncio
 import itertools
+import logging
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Coroutine,
+    Dict,
+    List,
     Optional,
     Set,
     Tuple,
+    Union,
     cast,
 )
 
@@ -18,7 +22,11 @@ from eth_utils import (
 )
 
 from web3._utils.caching import (
-    async_handle_request_caching,
+    CACHEABLE_REQUESTS,
+)
+from web3._utils.empty import (
+    Empty,
+    empty,
 )
 from web3._utils.encoding import (
     FriendlyJsonSerde,
@@ -28,7 +36,7 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    async_combine_middlewares,
+    async_combine_middleware,
 )
 from web3.middleware.base import (
     Middleware,
@@ -36,9 +44,11 @@ from web3.middleware.base import (
 )
 from web3.types import (
     RPCEndpoint,
+    RPCRequest,
     RPCResponse,
 )
 from web3.utils import (
+    RequestCacheValidationThreshold,
     SimpleCache,
 )
 
@@ -56,63 +66,84 @@ 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:
+    # Set generic logger for the provider. Override in subclasses for more specificity.
+    logger: logging.Logger = logging.getLogger(
+        "web3.providers.async_base.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,
+        request_cache_validation_threshold: Optional[
+            Union[RequestCacheValidationThreshold, int, Empty]
+        ] = empty,
+    ) -> None:
         self._request_cache = SimpleCache(1000)
+        self._request_cache_lock: asyncio.Lock = asyncio.Lock()
+
+        self.cache_allowed_requests = cache_allowed_requests
+        self.cacheable_requests = cacheable_requests or CACHEABLE_REQUESTS
+        self.request_cache_validation_threshold = request_cache_validation_threshold
 
     async def request_func(
         self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
-        middlewares: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middlewares()
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                await async_combine_middlewares(
-                    middlewares=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_handle_request_caching
+    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 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,22 +172,33 @@ class AsyncBaseProvider:
 
 
 class AsyncJSONBaseProvider(AsyncBaseProvider):
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
         self.request_counter = itertools.count()
 
-    def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
+    def form_request(self, method: RPCEndpoint, params: Any = None) -> RPCRequest:
         request_id = next(self.request_counter)
         rpc_dict = {
+            "id": request_id,
             "jsonrpc": "2.0",
             "method": method,
             "params": params or [],
-            "id": request_id,
         }
-        encoded = FriendlyJsonSerde().json_encode(rpc_dict, cls=Web3JsonEncoder)
+        return cast(RPCRequest, rpc_dict)
+
+    @staticmethod
+    def encode_rpc_dict(rpc_dict: RPCRequest) -> bytes:
+        encoded = FriendlyJsonSerde().json_encode(
+            cast(Dict[str, Any], rpc_dict), cls=Web3JsonEncoder
+        )
         return to_bytes(text=encoded)
 
-    def decode_rpc_response(self, raw_response: bytes) -> RPCResponse:
+    def encode_rpc_request(self, method: RPCEndpoint, params: Any) -> bytes:
+        rpc_dict = self.form_request(method, params)
+        return self.encode_rpc_dict(rpc_dict)
+
+    @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 +227,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"]"
+        )