web3 7.7.0__py3-none-any.whl → 7.9.0__py3-none-any.whl

web3/contract/contract.py

@@ -13,7 +13,6 @@ from typing import (
 
 from eth_typing import (
     ABI,
-    ABIFunction,
     ChecksumAddress,
 )
 from eth_utils import (
@@ -31,7 +30,6 @@ from hexbytes import (
 
 from web3._utils.abi import (
     fallback_func_abi_exists,
-    get_name_from_abi_element_identifier,
     receive_func_abi_exists,
 )
 from web3._utils.abi_element_identifiers import (
@@ -42,8 +40,6 @@ from web3._utils.compat import (
     Self,
 )
 from web3._utils.contracts import (
-    copy_contract_event,
-    copy_contract_function,
     parse_block_identifier,
 )
 from web3._utils.datatypes import (
@@ -86,12 +82,6 @@ from web3.contract.utils import (
     transact_with_contract_function,
 )
 from web3.exceptions import (
-    ABIEventNotFound,
-    ABIFunctionNotFound,
-    MismatchedABI,
-    NoABIEventsFound,
-    NoABIFound,
-    NoABIFunctionsFound,
     Web3AttributeError,
     Web3TypeError,
     Web3ValidationError,
@@ -103,12 +93,6 @@ from web3.types import (
     StateOverride,
     TxParams,
 )
-from web3.utils.abi import (
-    _filter_by_argument_count,
-    _get_any_abi_signature_with_name,
-    _mismatched_abi_error_diagnosis,
-    get_abi_element,
-)
 
 if TYPE_CHECKING:
     from ens import ENS  # noqa: F401
@@ -119,9 +103,6 @@ class ContractEvent(BaseContractEvent):
     # mypy types
     w3: "Web3"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> "ContractEvent":
-        return copy_contract_event(self, *args, **kwargs)
-
     @combomethod
     def get_logs(
         self,
@@ -255,162 +236,18 @@ class ContractEvent(BaseContractEvent):
         builder.address = self.address
         return builder
 
-    @classmethod
-    def factory(cls, class_name: str, **kwargs: Any) -> Self:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
 
-
-class ContractEvents(BaseContractEvents):
+class ContractEvents(BaseContractEvents[ContractEvent]):
     def __init__(
         self, abi: ABI, w3: "Web3", address: Optional[ChecksumAddress] = None
     ) -> None:
         super().__init__(abi, w3, ContractEvent, address)
 
-    def __getattr__(self, event_name: str) -> "ContractEvent":
-        if super().__getattribute__("abi") is None:
-            raise NoABIFound(
-                "There is no ABI found for this contract.",
-            )
-        elif "_events" not in self.__dict__ or len(self._events) == 0:
-            raise NoABIEventsFound(
-                "The abi for this contract contains no event definitions. ",
-                "Are you sure you provided the correct contract abi?",
-            )
-        elif get_name_from_abi_element_identifier(event_name) not in [
-            get_name_from_abi_element_identifier(event["name"])
-            for event in self._events
-        ]:
-            raise ABIEventNotFound(
-                f"The event '{event_name}' was not found in this contract's abi. ",
-                "Are you sure you provided the correct contract abi?",
-            )
-
-        if "(" not in event_name:
-            event_name = _get_any_abi_signature_with_name(event_name, self._events)
-        else:
-            event_name = f"_{event_name}"
-
-        return super().__getattribute__(event_name)
-
-    def __getitem__(self, event_name: str) -> "ContractEvent":
-        return getattr(self, event_name)
-
-    def __iter__(self) -> Iterable["ContractEvent"]:
-        if not hasattr(self, "_events") or not self._events:
-            return
-
-        for event in self._events:
-            yield self[abi_to_signature(event)]
-
 
 class ContractFunction(BaseContractFunction):
     # mypy types
     w3: "Web3"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> "ContractFunction":
-        # When a function is called, check arguments to obtain the correct function
-        # in the contract. self will be used if all args and kwargs are
-        # encodable to self.abi, otherwise the correct function is obtained from
-        # the contract.
-        if (
-            self.abi_element_identifier in [FallbackFn, ReceiveFn]
-            or self.abi_element_identifier == "constructor"
-        ):
-            return copy_contract_function(self, *args, **kwargs)
-
-        all_functions = cast(
-            List[ABIFunction],
-            filter_abi_by_type(
-                "function",
-                self.contract_abi,
-            ),
-        )
-        # Filter functions by name to obtain function signatures
-        function_name = get_name_from_abi_element_identifier(
-            self.abi_element_identifier
-        )
-        function_abis = [
-            function for function in all_functions if function["name"] == function_name
-        ]
-        num_args = len(args) + len(kwargs)
-        function_abis_with_arg_count = cast(
-            List[ABIFunction],
-            _filter_by_argument_count(
-                num_args,
-                function_abis,
-            ),
-        )
-
-        if not len(function_abis_with_arg_count):
-            # Build an ABI without arguments to determine if one exists
-            function_abis_with_arg_count = [
-                ABIFunction({"type": "function", "name": function_name})
-            ]
-
-        # Check that arguments in call match a function ABI
-        num_attempts = 0
-        function_abi_matches = []
-        contract_function = None
-        for abi in function_abis_with_arg_count:
-            try:
-                num_attempts += 1
-
-                # Search for a function ABI that matches the arguments used
-                function_abi_matches.append(
-                    cast(
-                        ABIFunction,
-                        get_abi_element(
-                            function_abis,
-                            abi_to_signature(abi),
-                            *args,
-                            abi_codec=self.w3.codec,
-                            **kwargs,
-                        ),
-                    )
-                )
-            except MismatchedABI:
-                # ignore exceptions
-                continue
-
-        if len(function_abi_matches) == 1:
-            function_abi = function_abi_matches[0]
-            if abi_to_signature(self.abi) == abi_to_signature(function_abi):
-                contract_function = self
-            else:
-                # Found a match that is not self
-                contract_function = ContractFunction.factory(
-                    abi_to_signature(function_abi),
-                    w3=self.w3,
-                    contract_abi=self.contract_abi,
-                    address=self.address,
-                    abi_element_identifier=abi_to_signature(function_abi),
-                    abi=function_abi,
-                )
-        else:
-            for abi in function_abi_matches:
-                if abi_to_signature(self.abi) == abi_to_signature(abi):
-                    contract_function = self
-                    break
-            else:
-                # Raise exception if multiple found
-                raise MismatchedABI(
-                    _mismatched_abi_error_diagnosis(
-                        function_name,
-                        self.contract_abi,
-                        len(function_abi_matches),
-                        num_args,
-                        *args,
-                        abi_codec=self.w3.codec,
-                        **kwargs,
-                    )
-                )
-
-        return copy_contract_function(contract_function, *args, **kwargs)
-
-    @classmethod
-    def factory(cls, class_name: str, **kwargs: Any) -> Self:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
-
     def call(
         self,
         transaction: Optional[TxParams] = None,
@@ -555,7 +392,7 @@ class ContractFunction(BaseContractFunction):
         return cast(ContractFunction, NonExistentReceiveFunction())
 
 
-class ContractFunctions(BaseContractFunctions):
+class ContractFunctions(BaseContractFunctions[ContractFunction]):
     def __init__(
         self,
         abi: ABI,
@@ -565,46 +402,6 @@ class ContractFunctions(BaseContractFunctions):
     ) -> None:
         super().__init__(abi, w3, ContractFunction, address, decode_tuples)
 
-    def __iter__(self) -> Iterable["ContractFunction"]:
-        if not hasattr(self, "_functions") or not self._functions:
-            return
-
-        for func in self._functions:
-            yield self[abi_to_signature(func)]
-
-    def __getattr__(self, function_name: str) -> "ContractFunction":
-        if super().__getattribute__("abi") is None:
-            raise NoABIFound(
-                "There is no ABI found for this contract.",
-            )
-        elif "_functions" not in self.__dict__ or len(self._functions) == 0:
-            raise NoABIFunctionsFound(
-                "The abi for this contract contains no function definitions. ",
-                "Are you sure you provided the correct contract abi?",
-            )
-        elif get_name_from_abi_element_identifier(function_name) not in [
-            get_name_from_abi_element_identifier(function["name"])
-            for function in self._functions
-        ]:
-            raise ABIFunctionNotFound(
-                f"The function '{function_name}' was not found in this ",
-                "contract's abi.",
-            )
-
-        if "(" not in function_name:
-            function_name = _get_any_abi_signature_with_name(
-                function_name, self._functions
-            )
-        else:
-            function_name = f"_{function_name}"
-
-        return super().__getattribute__(
-            function_name,
-        )
-
-    def __getitem__(self, function_name: str) -> "ContractFunction":
-        return getattr(self, function_name)
-
 
 class Contract(BaseContract):
     # mypy types

web3/datastructures.py

@@ -17,6 +17,7 @@ from typing import (
     Tuple,
     TypeVar,
     Union,
+    ValuesView,
     cast,
 )
 
@@ -337,3 +338,6 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         # This leads to typing issues, so it's better to use
         # ``as_tuple_of_middleware()`` to achieve the same result.
         return iter(self._reversed_middleware())  # type: ignore
+
+    def values(self) -> ValuesView[TValue]:
+        return ValuesView(self._queue)

web3/eth/async_eth.py

@@ -7,6 +7,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Sequence,
     Tuple,
     Type,
     Union,
@@ -89,6 +90,8 @@ from web3.types import (
     LogsSubscriptionArg,
     Nonce,
     SignedTx,
+    SimulateV1Payload,
+    SimulateV1Result,
     StateOverride,
     SubscriptionType,
     SyncStatus,
@@ -288,6 +291,22 @@ class AsyncEth(BaseEth):
 
         raise TooManyRequests("Too many CCIP read redirects")
 
+    # eth_simulateV1
+
+    _simulateV1: Method[
+        Callable[
+            [SimulateV1Payload, BlockIdentifier],
+            Awaitable[Sequence[SimulateV1Result]],
+        ]
+    ] = Method(RPC.eth_simulateV1)
+
+    async def simulate_v1(
+        self,
+        payload: SimulateV1Payload,
+        block_identifier: BlockIdentifier,
+    ) -> Sequence[SimulateV1Result]:
+        return await self._simulateV1(payload, block_identifier)
+
     # eth_createAccessList
 
     _create_access_list: Method[

web3/eth/eth.py

@@ -85,6 +85,8 @@ from web3.types import (
     MerkleProof,
     Nonce,
     SignedTx,
+    SimulateV1Payload,
+    SimulateV1Result,
     StateOverride,
     SyncStatus,
     TxData,
@@ -270,6 +272,19 @@ class Eth(BaseEth):
 
         raise TooManyRequests("Too many CCIP read redirects")
 
+    # eth_simulateV1
+
+    _simulateV1: Method[
+        Callable[[SimulateV1Payload, BlockIdentifier], Sequence[SimulateV1Result]]
+    ] = Method(RPC.eth_simulateV1)
+
+    def simulate_v1(
+        self,
+        payload: SimulateV1Payload,
+        block_identifier: BlockIdentifier,
+    ) -> Sequence[SimulateV1Result]:
+        return self._simulateV1(payload, block_identifier)
+
     # eth_createAccessList
 
     _create_access_list: Method[

web3/gas_strategies/time_based.py

@@ -158,7 +158,7 @@ def _compute_gas_price(
 
     :param probabilities: An iterable of `Probability` named-tuples
         sorted in reverse order.
-    :param desired_probability: An floating point representation of the desired
+    :param desired_probability: A floating point representation of the desired
         probability. (e.g. ``85% -> 0.85``)
     """
     first = probabilities[0]

web3/manager.py

@@ -31,17 +31,19 @@ from web3._utils.caching import (
 from web3._utils.compat import (
     Self,
 )
+from web3._utils.formatters import (
+    apply_null_result_formatters,
+)
+from web3._utils.validation import (
+    raise_error_for_batch_response,
+    validate_rpc_response_and_raise_if_error,
+)
 from web3.datastructures import (
     NamedElementOnion,
 )
 from web3.exceptions import (
-    BadResponseFormat,
-    MethodUnavailable,
     ProviderConnectionError,
-    RequestTimedOut,
     TaskNotRunning,
-    TransactionNotFound,
-    Web3RPCError,
     Web3TypeError,
 )
 from web3.method import (
@@ -94,176 +96,6 @@ if TYPE_CHECKING:
 
 
 NULL_RESPONSES = [None, HexBytes("0x"), "0x"]
-KNOWN_REQUEST_TIMEOUT_MESSAGING = {
-    # Note: It's important to be very explicit here and not too broad. We don't want
-    # to accidentally catch a message that is not for a request timeout. In the worst
-    # case, we raise something more generic like `Web3RPCError`. JSON-RPC unfortunately
-    # has not standardized error codes for request timeouts.
-    "request timed out",  # go-ethereum
-}
-METHOD_NOT_FOUND = -32601
-
-
-def _raise_bad_response_format(response: RPCResponse, error: str = "") -> None:
-    message = "The response was in an unexpected format and unable to be parsed."
-    raw_response = f"The raw response is: {response}"
-
-    if error is not None and error != "":
-        error = error[:-1] if error.endswith(".") else error
-        message = f"{message} {error}. {raw_response}"
-    else:
-        message = f"{message} {raw_response}"
-
-    raise BadResponseFormat(message)
-
-
-def apply_error_formatters(
-    error_formatters: Callable[..., Any],
-    response: RPCResponse,
-) -> RPCResponse:
-    if error_formatters:
-        formatted_resp = pipe(response, error_formatters)
-        return formatted_resp
-    else:
-        return response
-
-
-def apply_null_result_formatters(
-    null_result_formatters: Callable[..., Any],
-    response: RPCResponse,
-    params: Optional[Any] = None,
-) -> RPCResponse:
-    if null_result_formatters:
-        formatted_resp = pipe(params, null_result_formatters)
-        return formatted_resp
-    else:
-        return response
-
-
-def _validate_subscription_fields(response: RPCResponse) -> None:
-    params = response["params"]
-    subscription = params["subscription"]
-    if not isinstance(subscription, str) and not len(subscription) == 34:
-        _raise_bad_response_format(
-            response, "eth_subscription 'params' must include a 'subscription' field."
-        )
-
-
-def _validate_response(
-    response: RPCResponse,
-    error_formatters: Optional[Callable[..., Any]],
-    is_subscription_response: bool = False,
-    logger: Optional[logging.Logger] = None,
-    params: Optional[Any] = None,
-) -> None:
-    if "jsonrpc" not in response or response["jsonrpc"] != "2.0":
-        _raise_bad_response_format(
-            response, 'The "jsonrpc" field must be present with a value of "2.0".'
-        )
-
-    response_id = response.get("id")
-    if "id" in response:
-        int_error_msg = (
-            '"id" must be an integer or a string representation of an integer.'
-        )
-        if response_id is None and "error" in response:
-            # errors can sometimes have null `id`, according to the JSON-RPC spec
-            pass
-        elif not isinstance(response_id, (str, int)):
-            _raise_bad_response_format(response, int_error_msg)
-        elif isinstance(response_id, str):
-            try:
-                int(response_id)
-            except ValueError:
-                _raise_bad_response_format(response, int_error_msg)
-    elif is_subscription_response:
-        # if `id` is not present, this must be a subscription response
-        _validate_subscription_fields(response)
-    else:
-        _raise_bad_response_format(
-            response,
-            'Response must include an "id" field or be formatted as an '
-            "`eth_subscription` response.",
-        )
-
-    if all(key in response for key in {"error", "result"}):
-        _raise_bad_response_format(
-            response, 'Response cannot include both "error" and "result".'
-        )
-    elif (
-        not any(key in response for key in {"error", "result"})
-        and not is_subscription_response
-    ):
-        _raise_bad_response_format(
-            response, 'Response must include either "error" or "result".'
-        )
-    elif "error" in response:
-        web3_rpc_error: Optional[Web3RPCError] = None
-        error = response["error"]
-
-        # raise the error when the value is a string
-        if error is None or not isinstance(error, dict):
-            _raise_bad_response_format(
-                response,
-                'response["error"] must be a valid object as defined by the '
-                "JSON-RPC 2.0 specification.",
-            )
-
-        # errors must include a message
-        error_message = error.get("message")
-        if not isinstance(error_message, str):
-            _raise_bad_response_format(
-                response, 'error["message"] is required and must be a string value.'
-            )
-        elif error_message == "transaction not found":
-            transaction_hash = params[0]
-            web3_rpc_error = TransactionNotFound(
-                repr(error),
-                rpc_response=response,
-                user_message=(f"Transaction with hash {transaction_hash!r} not found."),
-            )
-
-        # errors must include an integer code
-        code = error.get("code")
-        if not isinstance(code, int):
-            _raise_bad_response_format(
-                response, 'error["code"] is required and must be an integer value.'
-            )
-        elif code == METHOD_NOT_FOUND:
-            web3_rpc_error = MethodUnavailable(
-                repr(error),
-                rpc_response=response,
-                user_message=(
-                    "This method is not available. Check your node provider or your "
-                    "client's API docs to see what methods are supported and / or "
-                    "currently enabled."
-                ),
-            )
-        elif any(
-            # parse specific timeout messages
-            timeout_str in error_message.lower()
-            for timeout_str in KNOWN_REQUEST_TIMEOUT_MESSAGING
-        ):
-            web3_rpc_error = RequestTimedOut(
-                repr(error),
-                rpc_response=response,
-                user_message=(
-                    "The request timed out. Check the connection to your node and "
-                    "try again."
-                ),
-            )
-
-        if web3_rpc_error is None:
-            # if no condition was met above, raise a more generic `Web3RPCError`
-            web3_rpc_error = Web3RPCError(repr(error), rpc_response=response)
-
-        response = apply_error_formatters(error_formatters, response)
-        logger.debug(f"RPC error response: {response}")
-
-        raise web3_rpc_error
-
-    elif "result" not in response and not is_subscription_response:
-        _raise_bad_response_format(response)
 
 
 class RequestManager:
@@ -363,7 +195,7 @@ class RequestManager:
             and response["params"].get("result") is not None
         )
 
-        _validate_response(
+        validate_rpc_response_and_raise_if_error(
             response,
             error_formatters,
             is_subscription_response=is_subscription_response,
@@ -422,6 +254,8 @@ class RequestManager:
         """
         Context manager for making batch requests
         """
+        if isinstance(self.provider, AutoProvider):
+            self.provider = self.provider._get_active_provider(use_cache=True)
         if not isinstance(self.provider, (AsyncJSONBaseProvider, JSONBaseProvider)):
             raise Web3TypeError("Batch requests are not supported by this provider.")
         return RequestBatcher(self.w3)
@@ -436,17 +270,23 @@ class RequestManager:
         request_func = provider.batch_request_func(
             cast("Web3", self.w3), cast("MiddlewareOnion", self.middleware_onion)
         )
-        responses = request_func(
+        response = 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)
+
+        if isinstance(response, list):
+            # expected format
+            formatted_responses = [
+                self._format_batched_response(info, cast(RPCResponse, resp))
+                for info, resp in zip(requests_info, response)
+            ]
+            return list(formatted_responses)
+        else:
+            # expect a single response with an error
+            raise_error_for_batch_response(response, self.logger)
 
     async def _async_make_batch_request(
         self,
@@ -465,25 +305,31 @@ class RequestManager:
         # 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(
+        response = 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 [
-                cast(RPCResponse, await self._process_response(resp))
-                for resp in responses
+        if isinstance(response, list):
+            # expected format
+            response = cast(List[RPCResponse], response)
+            if isinstance(self.provider, PersistentConnectionProvider):
+                # call _process_response for each response in the batch
+                return [
+                    cast(RPCResponse, await self._process_response(resp))
+                    for resp in response
+                ]
+
+            formatted_responses = [
+                self._format_batched_response(info, resp)
+                for info, resp in zip(unpacked_requests_info, response)
             ]
-
-        formatted_responses = [
-            self._format_batched_response(info, resp)
-            for info, resp in zip(unpacked_requests_info, responses)
-        ]
-        return list(formatted_responses)
+            return list(formatted_responses)
+        else:
+            # expect a single response with an error
+            raise_error_for_batch_response(response, self.logger)
 
     def _format_batched_response(
         self,
@@ -491,6 +337,13 @@ class RequestManager:
         response: RPCResponse,
     ) -> RPCResponse:
         result_formatters, error_formatters, null_result_formatters = requests_info[1]
+        validate_rpc_response_and_raise_if_error(
+            response,
+            error_formatters,
+            is_subscription_response=False,
+            logger=self.logger,
+            params=requests_info[0][1],
+        )
         return apply_result_formatters(
             result_formatters,
             self.formatted_response(