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

web3/_utils/batching.py

@@ -0,0 +1,217 @@
+from copy import (
+    copy,
+)
+from types import (
+    TracebackType,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generic,
+    List,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+import warnings
+
+from web3._utils.compat import (
+    Self,
+)
+from web3.contract.async_contract import (
+    AsyncContractFunction,
+)
+from web3.contract.contract import (
+    ContractFunction,
+)
+from web3.exceptions import (
+    Web3ValueError,
+)
+from web3.types import (
+    TFunc,
+    TReturn,
+)
+
+if TYPE_CHECKING:
+    from web3 import (  # noqa: F401
+        AsyncWeb3,
+        Web3,
+    )
+    from web3.method import (  # noqa: F401
+        Method,
+    )
+    from web3.providers import (  # noqa: F401
+        PersistentConnectionProvider,
+    )
+    from web3.providers.async_base import (  # noqa: F401
+        AsyncJSONBaseProvider,
+    )
+    from web3.providers.base import (  # noqa: F401
+        JSONBaseProvider,
+    )
+    from web3.types import (  # noqa: F401
+        RPCEndpoint,
+        RPCResponse,
+    )
+
+
+BATCH_REQUEST_ID = "batch_request"  # for use as the cache key for batch requests
+
+BatchRequestInformation = Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]
+RPC_METHODS_UNSUPPORTED_DURING_BATCH = {
+    "eth_subscribe",
+    "eth_unsubscribe",
+    "eth_sendRawTransaction",
+    "eth_sendTransaction",
+    "eth_signTransaction",
+    "eth_sign",
+    "eth_signTypedData",
+}
+
+
+class RequestBatcher(Generic[TFunc]):
+    def __init__(self, web3: Union["AsyncWeb3", "Web3"]) -> None:
+        self.web3 = web3
+        self._requests_info: List[BatchRequestInformation] = []
+        self._async_requests_info: List[
+            Coroutine[Any, Any, BatchRequestInformation]
+        ] = []
+        self._initialize_batching()
+
+    @property
+    def _provider(self) -> Union["JSONBaseProvider", "AsyncJSONBaseProvider"]:
+        return (
+            cast("AsyncJSONBaseProvider", self.web3.provider)
+            if self.web3.provider.is_async
+            else cast("JSONBaseProvider", self.web3.provider)
+        )
+
+    def _validate_is_batching(self) -> None:
+        if not self._provider._is_batching:
+            raise Web3ValueError(
+                "Batch has already been executed or cancelled. Create a new batch to "
+                "issue batched requests."
+            )
+
+    def _initialize_batching(self) -> None:
+        self._provider._is_batching = True
+        self.clear()
+
+    def _end_batching(self) -> None:
+        self.clear()
+        self._provider._is_batching = False
+        if self._provider.has_persistent_connection:
+            provider = cast("PersistentConnectionProvider", self._provider)
+            provider._batch_request_counter = None
+
+    def add(self, batch_payload: TReturn) -> None:
+        self._validate_is_batching()
+
+        if isinstance(batch_payload, (ContractFunction, AsyncContractFunction)):
+            batch_payload = batch_payload.call()  # type: ignore
+
+        # When batching, we don't make a request. Instead, we will get the request
+        # information and store it in the `_requests_info` list. So we have to cast the
+        # apparent "request" into the BatchRequestInformation type.
+        if self._provider.is_async:
+            self._async_requests_info.append(
+                cast(Coroutine[Any, Any, BatchRequestInformation], batch_payload)
+            )
+        else:
+            self._requests_info.append(cast(BatchRequestInformation, batch_payload))
+
+    def add_mapping(
+        self,
+        batch_payload: Dict[
+            Union[
+                "Method[Callable[..., Any]]",
+                Callable[..., Any],
+                ContractFunction,
+                AsyncContractFunction,
+            ],
+            List[Any],
+        ],
+    ) -> None:
+        self._validate_is_batching()
+        for method, params in batch_payload.items():
+            for param in params:
+                self.add(method(param))
+
+    def execute(self) -> List["RPCResponse"]:
+        self._validate_is_batching()
+        responses = self.web3.manager._make_batch_request(self._requests_info)
+        self._end_batching()
+        return responses
+
+    def clear(self) -> None:
+        self._requests_info = []
+        self._async_requests_info = []
+        if self._provider.has_persistent_connection:
+            provider = cast("PersistentConnectionProvider", self._provider)
+            provider._batch_request_counter = next(copy(provider.request_counter))
+
+    def cancel(self) -> None:
+        self._end_batching()
+
+    # -- context manager -- #
+
+    def __enter__(self) -> Self:
+        self._initialize_batching()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._end_batching()
+
+    # -- async -- #
+
+    async def async_execute(self) -> List["RPCResponse"]:
+        self._validate_is_batching()
+        responses = await self.web3.manager._async_make_batch_request(
+            self._async_requests_info
+        )
+        self._end_batching()
+        return responses
+
+    # -- async context manager -- #
+
+    async def __aenter__(self) -> Self:
+        self._initialize_batching()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._end_batching()
+
+
+def sort_batch_response_by_response_ids(
+    responses: List["RPCResponse"],
+) -> List["RPCResponse"]:
+    if all(response.get("id") is not None for response in responses):
+        # If all responses have an `id`, sort them by `id, since the JSON-RPC 2.0 spec
+        # doesn't guarantee order.
+        return sorted(responses, key=lambda response: response["id"])
+    else:
+        # If any response is missing an `id`, which should only happen on particular
+        # errors, return them in the order they were received and hope that the
+        # provider is returning them in order. Issue a warning.
+        warnings.warn(
+            "Received batch response with missing `id` for one or more responses. "
+            "Relying on provider to return these responses in order.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        return responses

web3/_utils/caching.py

@@ -6,10 +6,13 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    Dict,
     List,
+    Set,
     Tuple,
     TypeVar,
     Union,
+    cast,
 )
 
 from eth_utils import (
@@ -69,7 +72,11 @@ class RequestInformation:
         self,
         method: "RPCEndpoint",
         params: Any,
-        response_formatters: Tuple[Callable[..., Any], ...],
+        response_formatters: Tuple[
+            Union[Dict[str, Callable[..., Any]], Callable[..., Any]],
+            Callable[..., Any],
+            Callable[..., Any],
+        ],
         subscription_id: str = None,
     ):
         self.method = method
@@ -87,7 +94,24 @@ def is_cacheable_request(
     return False
 
 
-# -- request caching decorators -- #
+# -- request caching -- #
+
+
+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",
+    ),
+)
 
 
 def _should_cache_response(response: "RPCResponse") -> bool:

web3/_utils/compat/__init__.py

@@ -11,4 +11,5 @@
 from typing_extensions import (
     NotRequired,  # py311
     Self,  # py311
+    Unpack,  # py311
 )

web3/_utils/events.py

@@ -444,8 +444,8 @@ class EventFilterBuilder(BaseEventFilterBuilder):
         if not isinstance(w3, web3.Web3):
             raise Web3ValueError(f"Invalid web3 argument: got: {w3!r}")
 
-        for arg in AttributeDict.values(self.args):
-            arg._immutable = True  # type: ignore[attr-defined]
+        for arg in self.args.values():
+            arg._immutable = True
         self._immutable = True
 
         log_filter = cast("LogFilter", w3.eth.filter(self.filter_params))

web3/_utils/module_testing/eth_module.py

@@ -220,7 +220,7 @@ class AsyncEthModuleTest:
         txn_hash = await async_w3.eth.send_transaction(txn_params)
 
         modified_txn_hash = await async_w3.eth.modify_transaction(
-            txn_hash, gasPrice=(cast(int, txn_params["gasPrice"]) * 2), value=2
+            txn_hash, gasPrice=(cast(Wei, txn_params["gasPrice"] * 2)), value=Wei(2)
         )
         modified_txn = await async_w3.eth.get_transaction(modified_txn_hash)
 
@@ -252,9 +252,9 @@ class AsyncEthModuleTest:
 
         modified_txn_hash = await async_w3.eth.modify_transaction(
             txn_hash,
-            value=2,
-            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"]) * 2),
-            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"]) * 2),
+            value=Wei(2),
+            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"] * 2)),
+            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"] * 2)),
         )
         modified_txn = await async_w3.eth.get_transaction(modified_txn_hash)
 
@@ -721,7 +721,7 @@ class AsyncEthModuleTest:
             "gasPrice": 10**9,
         }
         signed = keyfile_account.sign_transaction(txn)
-        txn_hash = await async_w3.eth.send_raw_transaction(signed.rawTransaction)
+        txn_hash = await async_w3.eth.send_raw_transaction(signed.raw_transaction)
         assert txn_hash == HexBytes(signed.hash)
 
     @pytest.mark.asyncio
@@ -3657,7 +3657,7 @@ class EthModuleTest:
         txn_hash = w3.eth.send_transaction(txn_params)
 
         modified_txn_hash = w3.eth.modify_transaction(
-            txn_hash, gasPrice=(cast(int, txn_params["gasPrice"]) * 2), value=2
+            txn_hash, gasPrice=(cast(Wei, txn_params["gasPrice"] * 2)), value=Wei(2)
         )
         modified_txn = w3.eth.get_transaction(modified_txn_hash)
 
@@ -3686,9 +3686,9 @@ class EthModuleTest:
 
         modified_txn_hash = w3.eth.modify_transaction(
             txn_hash,
-            value=2,
-            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"]) * 2),
-            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"]) * 2),
+            value=Wei(2),
+            maxPriorityFeePerGas=(cast(Wei, txn_params["maxPriorityFeePerGas"] * 2)),
+            maxFeePerGas=(cast(Wei, txn_params["maxFeePerGas"] * 2)),
         )
         modified_txn = w3.eth.get_transaction(modified_txn_hash)
 
@@ -3720,7 +3720,7 @@ class EthModuleTest:
             "gasPrice": 10**9,
         }
         signed = keyfile_account.sign_transaction(txn)
-        txn_hash = w3.eth.send_raw_transaction(signed.rawTransaction)
+        txn_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
         assert txn_hash == HexBytes(signed.hash)
 
     def test_eth_call(self, w3: "Web3", math_contract: "Contract") -> None:

web3/_utils/module_testing/module_testing_utils.py

@@ -177,6 +177,12 @@ class WebSocketMessageStreamMock:
         self.messages = deque(messages) if messages else deque()
         self.raise_exception = raise_exception
 
+    def __await__(self) -> Generator[Any, Any, "Self"]:
+        async def __async_init__() -> "Self":
+            return self
+
+        return __async_init__().__await__()
+
     def __aiter__(self) -> "Self":
         return self
 
@@ -189,6 +195,13 @@ class WebSocketMessageStreamMock:
 
         return self.messages.popleft()
 
+    @staticmethod
+    async def pong() -> Literal[False]:
+        return False
+
+    async def connect(self) -> None:
+        pass
+
     async def send(self, data: bytes) -> None:
         pass