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

web3/middleware/signing.py

@@ -5,12 +5,12 @@ import operator
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Collection,
     Iterable,
     Tuple,
     TypeVar,
     Union,
+    cast,
 )
 
 from eth_account import (
@@ -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,
 )
@@ -36,6 +39,9 @@ from eth_utils.curried import (
 from eth_utils.toolz import (
     compose,
 )
+from toolz import (
+    curry,
+)
 
 from web3._utils.async_transactions import (
     async_fill_nonce,
@@ -52,12 +58,14 @@ from web3._utils.transactions import (
     fill_nonce,
     fill_transaction_defaults,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
+from web3.middleware.base import (
+    Web3MiddlewareBuilder,
+)
 from web3.types import (
-    AsyncMiddleware,
-    AsyncMiddlewareCoroutine,
-    Middleware,
     RPCEndpoint,
-    RPCResponse,
     TxParams,
 )
 
@@ -106,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. "
@@ -130,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
@@ -141,99 +150,75 @@ def format_transaction(transaction: TxParams) -> TxParams:
     )
 
 
-def construct_sign_and_send_raw_middleware(
-    private_key_or_account: Union[_PrivateKey, Collection[_PrivateKey]]
-) -> Middleware:
-    """Capture transactions sign and send as raw transactions
-
-
-    Keyword arguments:
-    private_key_or_account -- A single private key or a tuple,
-    list or set of private keys. Keys can be any of the following formats:
-      - An eth_account.LocalAccount object
-      - An eth_keys.PrivateKey object
-      - A raw private key as a hex string or byte string
-    """
-
-    accounts = gen_normalized_accounts(private_key_or_account)
-
-    def sign_and_send_raw_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
-    ) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-        format_and_fill_tx = compose(
-            format_transaction, fill_transaction_defaults(w3), fill_nonce(w3)
-        )
-
-        def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method != "eth_sendTransaction":
-                return make_request(method, params)
-            else:
-                transaction = format_and_fill_tx(params[0])
-
-            if "from" not in transaction:
-                return make_request(method, params)
-            elif transaction.get("from") not in accounts:
-                return make_request(method, params)
-
-            account = accounts[transaction["from"]]
-            raw_tx = account.sign_transaction(transaction).rawTransaction
-
-            return make_request(RPCEndpoint("eth_sendRawTransaction"), [raw_tx.hex()])
+class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
+    _accounts = None
+    format_and_fill_tx = None
 
+    @staticmethod
+    @curry
+    def build(
+        private_key_or_account: Union[_PrivateKey, Collection[_PrivateKey]],
+        w3: Union["Web3", "AsyncWeb3"],
+    ) -> "SignAndSendRawMiddlewareBuilder":
+        middleware = SignAndSendRawMiddlewareBuilder(w3)
+        middleware._accounts = gen_normalized_accounts(private_key_or_account)
         return middleware
 
-    return sign_and_send_raw_middleware
+    def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
+        if method != "eth_sendTransaction":
+            return method, params
+        else:
+            w3 = cast("Web3", self._w3)
+            if self.format_and_fill_tx is None:
+                self.format_and_fill_tx = compose(
+                    format_transaction,
+                    fill_transaction_defaults(w3),
+                    fill_nonce(w3),
+                )
+
+            filled_transaction = self.format_and_fill_tx(params[0])
+            tx_from = filled_transaction.get("from", None)
 
+            if tx_from is None or (
+                tx_from is not None and tx_from not in self._accounts
+            ):
+                return method, params
+            else:
+                account = self._accounts[to_checksum_address(tx_from)]
+                raw_tx = account.sign_transaction(filled_transaction).raw_transaction
 
-# -- async -- #
+                return (
+                    RPCEndpoint("eth_sendRawTransaction"),
+                    [raw_tx.hex()],
+                )
 
+    # -- async -- #
 
-async def async_construct_sign_and_send_raw_middleware(
-    private_key_or_account: Union[_PrivateKey, Collection[_PrivateKey]]
-) -> AsyncMiddleware:
-    """
-    Capture transactions & sign and send as raw transactions
-
-    Keyword arguments:
-    private_key_or_account -- A single private key or a tuple,
-    list or set of private keys. Keys can be any of the following formats:
-      - An eth_account.LocalAccount object
-      - An eth_keys.PrivateKey object
-      - A raw private key as a hex string or byte string
-    """
-    accounts = gen_normalized_accounts(private_key_or_account)
+    async def async_request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
+        if method != "eth_sendTransaction":
+            return method, params
 
-    async def async_sign_and_send_raw_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], async_w3: "AsyncWeb3"
-    ) -> AsyncMiddlewareCoroutine:
-        async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method != "eth_sendTransaction":
-                # quick exit if not `eth_sendTransaction`
-                return await make_request(method, params)
+        else:
+            w3 = cast("AsyncWeb3", self._w3)
 
             formatted_transaction = format_transaction(params[0])
             filled_transaction = await async_fill_transaction_defaults(
-                async_w3,
-                formatted_transaction,
-            )
-            filled_transaction = await async_fill_nonce(
-                async_w3,
-                filled_transaction,
+                w3, formatted_transaction
             )
-
+            filled_transaction = await async_fill_nonce(w3, filled_transaction)
             tx_from = filled_transaction.get("from", None)
 
-            if tx_from is None or (tx_from is not None and tx_from not in accounts):
-                return await make_request(method, params)
-
-            account = accounts[to_checksum_address(tx_from)]
-            raw_tx = account.sign_transaction(filled_transaction).rawTransaction
-
-            return await make_request(
-                RPCEndpoint("eth_sendRawTransaction"),
-                [raw_tx.hex()],
-            )
-
-        return middleware
-
-    return async_sign_and_send_raw_middleware
+            if tx_from is None or (
+                tx_from is not None and tx_from not in self._accounts
+            ):
+                return method, params
+            else:
+                account = self._accounts[to_checksum_address(tx_from)]
+                raw_tx = account.sign_transaction(
+                    cast(EthAccountTxParams, filled_transaction)
+                ).raw_transaction
+
+                return (
+                    RPCEndpoint("eth_sendRawTransaction"),
+                    [raw_tx.hex()],
+                )

web3/middleware/stalecheck.py

@@ -6,18 +6,25 @@ from typing import (  # noqa: F401
     Collection,
     Dict,
     Optional,
+    Union,
+    cast,
+)
+
+from toolz import (
+    curry,
 )
 
 from web3.exceptions import (
     StaleBlockchain,
+    Web3ValueError,
+)
+from web3.middleware.base import (
+    Web3Middleware,
+    Web3MiddlewareBuilder,
 )
 from web3.types import (
-    AsyncMiddleware,
-    AsyncMiddlewareCoroutine,
     BlockData,
-    Middleware,
     RPCEndpoint,
-    RPCResponse,
 )
 
 if TYPE_CHECKING:
@@ -35,86 +42,52 @@ def _is_fresh(block: BlockData, allowable_delay: int) -> bool:
     return False
 
 
-def make_stalecheck_middleware(
-    allowable_delay: int,
-    skip_stalecheck_for_methods: Collection[str] = SKIP_STALECHECK_FOR_METHODS,
-) -> Middleware:
-    """
-    Use to require that a function will run only of the blockchain is recently updated.
-
-    This middleware takes an argument, so unlike other middleware, you must make the
-    middleware with a method call.
-
-    For example: `make_stalecheck_middleware(60*5)`
-
-    If the latest block in the chain is older than 5 minutes in this example, then the
-    middleware will raise a StaleBlockchain exception.
-    """
-    if allowable_delay <= 0:
-        raise ValueError(
-            "You must set a positive allowable_delay in seconds for this middleware"
-        )
-
-    def stalecheck_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
-    ) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-        cache: Dict[str, Optional[BlockData]] = {"latest": None}
-
-        def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method not in skip_stalecheck_for_methods:
-                if not _is_fresh(cache["latest"], allowable_delay):
-                    latest = w3.eth.get_block("latest")
-                    if _is_fresh(latest, allowable_delay):
-                        cache["latest"] = latest
-                    else:
-                        raise StaleBlockchain(latest, allowable_delay)
-
-            return make_request(method, params)
-
+class StalecheckMiddlewareBuilder(Web3MiddlewareBuilder):
+    allowable_delay: int
+    skip_stalecheck_for_methods: Collection[str]
+    cache: Dict[str, Optional[BlockData]]
+
+    @staticmethod
+    @curry
+    def build(
+        allowable_delay: int,
+        w3: Union["Web3", "AsyncWeb3"],
+        skip_stalecheck_for_methods: Collection[str] = SKIP_STALECHECK_FOR_METHODS,
+    ) -> Web3Middleware:
+        if allowable_delay <= 0:
+            raise Web3ValueError(
+                "You must set a positive allowable_delay in seconds for this middleware"
+            )
+        middleware = StalecheckMiddlewareBuilder(w3)
+        middleware.allowable_delay = allowable_delay
+        middleware.skip_stalecheck_for_methods = skip_stalecheck_for_methods
+        middleware.cache = {"latest": None}
         return middleware
 
-    return stalecheck_middleware
-
-
-# -- async -- #
-
+    def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
+        if method not in self.skip_stalecheck_for_methods:
+            if not _is_fresh(self.cache["latest"], self.allowable_delay):
+                w3 = cast("Web3", self._w3)
+                latest = w3.eth.get_block("latest")
 
-async def async_make_stalecheck_middleware(
-    allowable_delay: int,
-    skip_stalecheck_for_methods: Collection[str] = SKIP_STALECHECK_FOR_METHODS,
-) -> AsyncMiddleware:
-    """
-    Use to require that a function will run only of the blockchain is recently updated.
+                if _is_fresh(latest, self.allowable_delay):
+                    self.cache["latest"] = latest
+                else:
+                    raise StaleBlockchain(latest, self.allowable_delay)
 
-    This middleware takes an argument, so unlike other middleware, you must make the
-    middleware with a method call.
+        return method, params
 
-    For example: `async_make_stalecheck_middleware(60*5)`
+    # -- async -- #
 
-    If the latest block in the chain is older than 5 minutes in this example, then the
-    middleware will raise a StaleBlockchain exception.
-    """
-    if allowable_delay <= 0:
-        raise ValueError(
-            "You must set a positive allowable_delay in seconds for this middleware"
-        )
+    async def async_request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
+        if method not in self.skip_stalecheck_for_methods:
+            if not _is_fresh(self.cache["latest"], self.allowable_delay):
+                w3 = cast("AsyncWeb3", self._w3)
+                latest = await w3.eth.get_block("latest")
 
-    async def stalecheck_middleware(
-        make_request: Callable[[RPCEndpoint, Any], Any], w3: "AsyncWeb3"
-    ) -> AsyncMiddlewareCoroutine:
-        cache: Dict[str, Optional[BlockData]] = {"latest": None}
-
-        async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-            if method not in skip_stalecheck_for_methods:
-                if not _is_fresh(cache["latest"], allowable_delay):
-                    latest = await w3.eth.get_block("latest")
-                    if _is_fresh(latest, allowable_delay):
-                        cache["latest"] = latest
-                    else:
-                        raise StaleBlockchain(latest, allowable_delay)
-
-            return await make_request(method, params)
-
-        return middleware
+                if _is_fresh(latest, self.allowable_delay):
+                    self.cache["latest"] = latest
+                else:
+                    raise StaleBlockchain(latest, self.allowable_delay)
 
-    return stalecheck_middleware
+        return method, params

web3/middleware/validation.py

@@ -33,11 +33,9 @@ from web3.exceptions import (
     Web3ValidationError,
 )
 from web3.middleware.formatting import (
-    async_construct_web3_formatting_middleware,
-    construct_web3_formatting_middleware,
+    FormattingMiddlewareBuilder,
 )
 from web3.types import (
-    AsyncMiddlewareCoroutine,
     Formatters,
     FormattersDict,
     RPCEndpoint,
@@ -147,9 +145,6 @@ def build_method_validators(w3: "Web3", method: RPCEndpoint) -> FormattersDict:
     return _build_formatters_dict(request_formatters)
 
 
-validation_middleware = construct_web3_formatting_middleware(build_method_validators)
-
-
 # -- async --- #
 
 
@@ -165,10 +160,7 @@ async def async_build_method_validators(
     return _build_formatters_dict(request_formatters)
 
 
-async def async_validation_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "AsyncWeb3"
-) -> AsyncMiddlewareCoroutine:
-    middleware = await async_construct_web3_formatting_middleware(
-        async_build_method_validators
-    )
-    return await middleware(make_request, w3)
+ValidationMiddleware = FormattingMiddlewareBuilder.build(
+    sync_formatters_builder=build_method_validators,
+    async_formatters_builder=async_build_method_validators,
+)

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,17 +131,20 @@ 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(
-                method_str, params, response_formatters  # type: ignore
+                cast(RPCEndpoint, method_str), params, response_formatters
             )
+
             try:
                 method_str = cast(RPCEndpoint, method_str)
-                return await async_w3.manager.ws_send(method_str, params)
+                return await async_w3.manager.socket_request(method_str, params)
             except Exception as e:
-                if cache_key in provider._request_processor._request_information_cache:
+                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
                     )
@@ -125,7 +166,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
@@ -135,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
@@ -148,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/__init__.py

@@ -1,7 +1,7 @@
 from .async_base import (
     AsyncBaseProvider,
 )
-from .async_rpc import (
+from .rpc import (
     AsyncHTTPProvider,
 )
 from .base import (
@@ -18,12 +18,14 @@ from .ipc import (
 from .rpc import (
     HTTPProvider,
 )
-from .websocket import (
-    WebsocketProvider,
-    WebsocketProviderV2,
+from .legacy_websocket import (
+    LegacyWebSocketProvider,
 )
 from .persistent import (
+    AsyncIPCProvider,
+    PersistentConnection,
     PersistentConnectionProvider,
+    WebSocketProvider,
 )
 from .auto import (
     AutoProvider,
@@ -33,13 +35,15 @@ __all__ = [
     "AsyncBaseProvider",
     "AsyncEthereumTesterProvider",
     "AsyncHTTPProvider",
+    "AsyncIPCProvider",
     "AutoProvider",
     "BaseProvider",
     "EthereumTesterProvider",
     "HTTPProvider",
     "IPCProvider",
     "JSONBaseProvider",
+    "LegacyWebSocketProvider",
+    "PersistentConnection",
     "PersistentConnectionProvider",
-    "WebsocketProvider",
-    "WebsocketProviderV2",
+    "WebSocketProvider",
 ]