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

web3/contract/utils.py

@@ -9,6 +9,7 @@ from typing import (
     Tuple,
     Type,
     Union,
+    cast,
 )
 
 from eth_abi.exceptions import (
@@ -16,6 +17,11 @@ from eth_abi.exceptions import (
 )
 from eth_typing import (
     ChecksumAddress,
+    TypeStr,
+)
+from eth_utils.toolz import (
+    compose,
+    curry,
 )
 from hexbytes import (
     HexBytes,
@@ -60,10 +66,50 @@ if TYPE_CHECKING:
         AsyncWeb3,
         Web3,
     )
+    from web3.providers.persistent import (  # noqa: F401
+        PersistentConnectionProvider,
+    )
 
 ACCEPTABLE_EMPTY_STRINGS = ["0x", b"0x", "", b""]
 
 
+@curry
+def format_contract_call_return_data_curried(
+    async_w3: Union["AsyncWeb3", "Web3"],
+    decode_tuples: bool,
+    fn_abi: ABIFunction,
+    function_identifier: FunctionIdentifier,
+    normalizers: Tuple[Callable[..., Any], ...],
+    output_types: Sequence[TypeStr],
+    return_data: Any,
+) -> Any:
+    """
+    Helper function for formatting contract call return data for batch requests. Curry
+    with all arguments except `return_data` and process `return_data` once it is
+    available.
+    """
+    try:
+        output_data = async_w3.codec.decode(output_types, return_data)
+    except DecodingError as e:
+        msg = (
+            f"Could not decode contract function call to {function_identifier} "
+            f"with return data: {str(return_data)}, output_types: {output_types}"
+        )
+        raise BadFunctionCallOutput(msg) from e
+
+    _normalizers = itertools.chain(
+        BASE_RETURN_NORMALIZERS,
+        normalizers,
+    )
+    normalized_data = map_abi_data(_normalizers, output_types, output_data)
+
+    if decode_tuples:
+        decoded = named_tree(fn_abi["outputs"], normalized_data)
+        normalized_data = recursive_dict_to_namedtuple(decoded)
+
+    return normalized_data[0] if len(normalized_data) == 1 else normalized_data
+
+
 def call_contract_function(
     w3: "Web3",
     address: ChecksumAddress,
@@ -108,6 +154,34 @@ def call_contract_function(
 
     output_types = get_abi_output_types(fn_abi)
 
+    provider = w3.provider
+    if hasattr(provider, "_is_batching") and provider._is_batching:
+        # request_information == ((method, params), response_formatters)
+        request_information = tuple(return_data)
+        method_and_params = request_information[0]
+
+        # append return data formatting to result formatters
+        current_response_formatters = request_information[1]
+        current_result_formatters = current_response_formatters[0]
+        updated_result_formatters = compose(
+            # contract call return data formatter
+            format_contract_call_return_data_curried(
+                w3,
+                decode_tuples,
+                fn_abi,
+                function_identifier,
+                normalizers,
+                output_types,
+            ),
+            current_result_formatters,
+        )
+        response_formatters = (
+            updated_result_formatters,  # result formatters
+            current_response_formatters[1],  # error formatters
+            current_response_formatters[2],  # null result formatters
+        )
+        return (method_and_params, response_formatters)
+
     try:
         output_data = w3.codec.decode(output_types, return_data)
     except DecodingError as e:
@@ -319,6 +393,43 @@ async def async_call_contract_function(
 
     output_types = get_abi_output_types(fn_abi)
 
+    if async_w3.provider._is_batching:
+        contract_call_return_data_formatter = format_contract_call_return_data_curried(
+            async_w3,
+            decode_tuples,
+            fn_abi,
+            function_identifier,
+            normalizers,
+            output_types,
+        )
+        if async_w3.provider.has_persistent_connection:
+            # get the current request id
+            provider = cast("PersistentConnectionProvider", async_w3.provider)
+            current_request_id = provider._batch_request_counter - 1
+            provider._request_processor.append_result_formatter_for_request(
+                current_request_id, contract_call_return_data_formatter
+            )
+        else:
+            # request_information == ((method, params), response_formatters)
+            request_information = tuple(return_data)
+            method_and_params = request_information[0]
+
+            # append return data formatter to result formatters
+            current_response_formatters = request_information[1]
+            current_result_formatters = current_response_formatters[0]
+            updated_result_formatters = compose(
+                contract_call_return_data_formatter,
+                current_result_formatters,
+            )
+            response_formatters = (
+                updated_result_formatters,  # result formatters
+                current_response_formatters[1],  # error formatters
+                current_response_formatters[2],  # null result formatters
+            )
+            return (method_and_params, response_formatters)
+
+        return return_data
+
     try:
         output_data = async_w3.codec.decode(output_types, return_data)
     except DecodingError as e:
@@ -350,10 +461,7 @@ async def async_call_contract_function(
         decoded = named_tree(fn_abi["outputs"], normalized_data)
         normalized_data = recursive_dict_to_namedtuple(decoded)
 
-    if len(normalized_data) == 1:
-        return normalized_data[0]
-    else:
-        return normalized_data
+    return normalized_data[0] if len(normalized_data) == 1 else normalized_data
 
 
 async def async_transact_with_contract_function(

web3/eth/__init__.py

@@ -8,3 +8,10 @@ from .eth import (
     Contract,
     Eth,
 )
+
+__all__ = [
+    "AsyncEth",
+    "BaseEth",
+    "Contract",
+    "Eth",
+]

web3/eth/async_eth.py

@@ -35,6 +35,9 @@ from web3._utils.async_transactions import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     async_fee_history_priority_fee,
 )
@@ -124,17 +127,6 @@ class AsyncEth(BaseEth):
     async def accounts(self) -> Tuple[ChecksumAddress]:
         return await self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], Awaitable[int]]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    async def hashrate(self) -> int:
-        return await self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], Awaitable[BlockNumber]]] = Method(
@@ -157,17 +149,6 @@ class AsyncEth(BaseEth):
     async def chain_id(self) -> int:
         return await self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], Awaitable[ChecksumAddress]]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    async def coinbase(self) -> ChecksumAddress:
-        return await self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Awaitable[Wei]]] = Method(
@@ -203,17 +184,6 @@ class AsyncEth(BaseEth):
             )
             return await async_fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], Awaitable[bool]]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    async def mining(self) -> bool:
-        return await self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Awaitable[Union[SyncStatus, bool]]]] = Method(
@@ -594,10 +564,8 @@ class AsyncEth(BaseEth):
             self.w3, current_transaction, new_transaction
         )
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     async def modify_transaction(
-        self, transaction_hash: _Hash32, **transaction_params: Any
+        self, transaction_hash: _Hash32, **transaction_params: Unpack[TxParams]
     ) -> HexBytes:
         assert_valid_transaction_params(cast(TxParams, transaction_params))
 
@@ -765,7 +733,7 @@ class AsyncEth(BaseEth):
 
     @overload
     # mypy error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
-    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[misc]  # noqa: E501
+    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[overload-overlap]  # noqa: E501
         ...
 
     @overload

web3/eth/eth.py

@@ -30,6 +30,9 @@ from hexbytes import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     fee_history_priority_fee,
 )
@@ -116,17 +119,6 @@ class Eth(BaseEth):
     def accounts(self) -> Tuple[ChecksumAddress]:
         return self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], int]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    def hashrate(self) -> int:
-        return self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], BlockNumber]] = Method(
@@ -149,17 +141,6 @@ class Eth(BaseEth):
     def chain_id(self) -> int:
         return self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], ChecksumAddress]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    def coinbase(self) -> ChecksumAddress:
-        return self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Wei]] = Method(
@@ -195,17 +176,6 @@ class Eth(BaseEth):
             )
             return fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], bool]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    def mining(self) -> bool:
-        return self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Union[SyncStatus, bool]]] = Method(
@@ -282,7 +252,8 @@ class Eth(BaseEth):
                 return self._call(transaction, block_identifier, state_override)
             except OffchainLookup as offchain_lookup:
                 durin_calldata = handle_offchain_lookup(
-                    offchain_lookup.payload, transaction
+                    offchain_lookup.payload,
+                    transaction,
                 )
                 transaction["data"] = durin_calldata
 
@@ -596,10 +567,8 @@ class Eth(BaseEth):
         current_transaction = get_required_transaction(self.w3, transaction_hash)
         return replace_transaction(self.w3, current_transaction, new_transaction)
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     def modify_transaction(
-        self, transaction_hash: _Hash32, **transaction_params: Any
+        self, transaction_hash: _Hash32, **transaction_params: Unpack[TxParams]
     ) -> HexBytes:
         assert_valid_transaction_params(cast(TxParams, transaction_params))
         current_transaction = get_required_transaction(self.w3, transaction_hash)
@@ -659,28 +628,9 @@ class Eth(BaseEth):
         mungers=[default_root_munger],
     )
 
-    # eth_submitHashrate
-
-    submit_hashrate: Method[Callable[[int, _Hash32], bool]] = Method(
-        RPC.eth_submitHashrate,
-        mungers=[default_root_munger],
-    )
-
-    # eth_getWork, eth_submitWork
-
-    get_work: Method[Callable[[], List[HexBytes]]] = Method(
-        RPC.eth_getWork,
-        is_property=True,
-    )
-
-    submit_work: Method[Callable[[int, _Hash32, _Hash32], bool]] = Method(
-        RPC.eth_submitWork,
-        mungers=[default_root_munger],
-    )
-
     @overload
     # type error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
-    def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:  # type: ignore[misc]  # noqa: E501
+    def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:  # type: ignore[overload-overlap]  # noqa: E501
         ...
 
     @overload

web3/exceptions.py

@@ -1,6 +1,7 @@
 import datetime
 import time
 from typing import (
+    TYPE_CHECKING,
     Any,
     Dict,
     Optional,
@@ -16,6 +17,9 @@ from web3.types import (
     RPCResponse,
 )
 
+if TYPE_CHECKING:
+    import asyncio
+
 
 class Web3Exception(Exception):
     """
@@ -307,6 +311,22 @@ class BadResponseFormat(Web3Exception):
     """
 
 
+class TaskNotRunning(Web3Exception):
+    """
+    Used to signal between asyncio contexts that a task that is being awaited
+    is not currently running.
+    """
+
+    def __init__(
+        self, task: "asyncio.Task[Any]", message: Optional[str] = None
+    ) -> None:
+        self.task = task
+        if message is None:
+            message = f"Task {task} is not running."
+        self.message = message
+        super().__init__(message)
+
+
 class Web3RPCError(Web3Exception):
     """
     Raised when a JSON-RPC response contains an error field.

web3/gas_strategies/time_based.py

@@ -110,11 +110,11 @@ def _aggregate_miner_data(
             # types ignored b/c mypy has trouble inferring gas_prices: Sequence[Wei]
             price_percentile = percentile(gas_prices, percentile=20)  # type: ignore
         except InsufficientData:
-            price_percentile = min(gas_prices)  # type: ignore
+            price_percentile = min(gas_prices)
         yield MinerData(
             miner,
             len(set(block_hashes)),
-            min(gas_prices),  # type: ignore
+            min(gas_prices),
             price_percentile,
         )
 

web3/main.py

@@ -34,6 +34,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncIterator,
+    Callable,
     Dict,
     Generator,
     List,
@@ -100,6 +101,9 @@ from web3.manager import (
     RequestManager as DefaultRequestManager,
 )
 from web3.middleware.base import MiddlewareOnion
+from web3.method import (
+    Method,
+)
 from web3.module import (
     Module,
 )
@@ -143,7 +147,9 @@ from web3.types import (
 )
 
 if TYPE_CHECKING:
+    from web3._utils.batching import RequestBatcher  # noqa: F401
     from web3._utils.empty import Empty  # noqa: F401
+    from web3.providers.persistent import PersistentConnectionProvider  # noqa: F401
 
 
 def get_async_default_modules() -> Dict[str, Union[Type[Module], Sequence[Any]]]:
@@ -336,6 +342,13 @@ class BaseWeb3:
     def is_encodable(self, _type: TypeStr, value: Any) -> bool:
         return self.codec.is_encodable(_type, value)
 
+    # -- APIs for high-level requests -- #
+
+    def batch_requests(
+        self,
+    ) -> "RequestBatcher[Method[Callable[..., Any]]]":
+        return self.manager._batch_requests()
+
 
 class Web3(BaseWeb3):
     # mypy types
@@ -468,7 +481,7 @@ class AsyncWeb3(BaseWeb3):
             new_ens.w3 = self  # set self object reference for ``AsyncENS.w3``
         self._ens = new_ens
 
-        # -- persistent connection methods -- #
+    # -- persistent connection methods -- #
 
     @property
     @persistent_connection_provider_method()
@@ -511,12 +524,11 @@ class AsyncWeb3(BaseWeb3):
         "when instantiating via ``async for``."
     )
     async def __aiter__(self) -> AsyncIterator[Self]:
-        if not await self.provider.is_connected():
-            await self.provider.connect()
-
+        provider = self.provider
         while True:
-            try:
-                yield self
-            except Exception:
-                # provider should handle connection / reconnection
-                continue
+            await provider.connect()
+            yield self
+            cast("PersistentConnectionProvider", provider).logger.error(
+                "Connection interrupted, attempting to reconnect..."
+            )
+            await provider.disconnect()

web3/manager.py

@@ -1,9 +1,11 @@
+import asyncio
 import logging
 from typing import (
     TYPE_CHECKING,
     Any,
     AsyncGenerator,
     Callable,
+    Coroutine,
     List,
     Optional,
     Sequence,
@@ -22,6 +24,9 @@ from websockets.exceptions import (
     ConnectionClosedOK,
 )
 
+from web3._utils.batching import (
+    RequestBatcher,
+)
 from web3._utils.caching import (
     generate_cache_key,
 )
@@ -35,9 +40,13 @@ from web3.exceptions import (
     BadResponseFormat,
     MethodUnavailable,
     ProviderConnectionError,
+    TaskNotRunning,
     Web3RPCError,
     Web3TypeError,
 )
+from web3.method import (
+    Method,
+)
 from web3.middleware import (
     AttributeDictMiddleware,
     BufferedGasEstimateMiddleware,
@@ -54,8 +63,12 @@ from web3.module import (
 )
 from web3.providers import (
     AutoProvider,
+    JSONBaseProvider,
     PersistentConnectionProvider,
 )
+from web3.providers.async_base import (
+    AsyncJSONBaseProvider,
+)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -375,6 +388,88 @@ class RequestManager:
             response, params, error_formatters, null_result_formatters
         )
 
+    # -- batch requests management -- #
+
+    def _batch_requests(self) -> RequestBatcher[Method[Callable[..., Any]]]:
+        """
+        Context manager for making batch requests
+        """
+        if not isinstance(self.provider, (AsyncJSONBaseProvider, JSONBaseProvider)):
+            raise Web3TypeError("Batch requests are not supported by this provider.")
+        return RequestBatcher(self.w3)
+
+    def _make_batch_request(
+        self, requests_info: List[Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]]
+    ) -> List[RPCResponse]:
+        """
+        Make a batch request using the provider
+        """
+        provider = cast(JSONBaseProvider, self.provider)
+        request_func = provider.batch_request_func(
+            cast("Web3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
+        )
+        responses = request_func(
+            [
+                (method, params)
+                for (method, params), _response_formatters in requests_info
+            ]
+        )
+        formatted_responses = [
+            self._format_batched_response(info, resp)
+            for info, resp in zip(requests_info, responses)
+        ]
+        return list(formatted_responses)
+
+    async def _async_make_batch_request(
+        self,
+        requests_info: List[
+            Coroutine[Any, Any, Tuple[Tuple["RPCEndpoint", Any], Sequence[Any]]]
+        ],
+    ) -> List[RPCResponse]:
+        """
+        Make an asynchronous batch request using the provider
+        """
+        provider = cast(AsyncJSONBaseProvider, self.provider)
+        request_func = await provider.batch_request_func(
+            cast("AsyncWeb3", self.w3),
+            cast("MiddlewareOnion", self.middleware_onion),
+        )
+        # since we add items to the batch without awaiting, we unpack the coroutines
+        # and await them all here
+        unpacked_requests_info = await asyncio.gather(*requests_info)
+        responses = await request_func(
+            [
+                (method, params)
+                for (method, params), _response_formatters in unpacked_requests_info
+            ]
+        )
+
+        if isinstance(self.provider, PersistentConnectionProvider):
+            # call _process_response for each response in the batch
+            return [await self._process_response(resp) for resp in responses]
+
+        formatted_responses = [
+            self._format_batched_response(info, resp)
+            for info, resp in zip(unpacked_requests_info, responses)
+        ]
+        return list(formatted_responses)
+
+    def _format_batched_response(
+        self,
+        requests_info: Tuple[Tuple[RPCEndpoint, Any], Sequence[Any]],
+        response: RPCResponse,
+    ) -> RPCResponse:
+        result_formatters, error_formatters, null_result_formatters = requests_info[1]
+        return apply_result_formatters(
+            result_formatters,
+            self.formatted_response(
+                response,
+                requests_info[0][1],
+                error_formatters,
+                null_result_formatters,
+            ),
+        )
+
     # -- persistent connection -- #
 
     async def send(self, method: RPCEndpoint, params: Any) -> RPCResponse:
@@ -408,14 +503,24 @@ class RequestManager:
             )
 
         while True:
-            response = await self._request_processor.pop_raw_response(subscription=True)
-            if (
-                response is not None
-                and response.get("params", {}).get("subscription")
-                in self._request_processor.active_subscriptions
-            ):
-                # if response is an active subscription response, process it
-                yield await self._process_response(response)
+            try:
+                response = await self._request_processor.pop_raw_response(
+                    subscription=True
+                )
+                if (
+                    response is not None
+                    and response.get("params", {}).get("subscription")
+                    in self._request_processor.active_subscriptions
+                ):
+                    # if response is an active subscription response, process it
+                    yield await self._process_response(response)
+            except TaskNotRunning:
+                self._provider._handle_listener_task_exceptions()
+                self.logger.error(
+                    "Message listener background task has stopped unexpectedly. "
+                    "Stopping message stream."
+                )
+                raise StopAsyncIteration
 
     async def _process_response(self, response: RPCResponse) -> RPCResponse:
         provider = cast(PersistentConnectionProvider, self._provider)