web3 7.6.1__py3-none-any.whl → 7.8.0__py3-none-any.whl

web3/_utils/module_testing/utils.py

@@ -10,10 +10,14 @@ from typing import (
     cast,
 )
 
-from toolz import (
+from eth_utils.toolz import (
     merge,
 )
 
+from web3.providers.persistent import (
+    PersistentConnectionProvider,
+)
+
 if TYPE_CHECKING:
     from web3 import (  # noqa: F401
         AsyncWeb3,
@@ -26,6 +30,7 @@ if TYPE_CHECKING:
         AsyncMakeRequestFn,
         MakeRequestFn,
         RPCEndpoint,
+        RPCRequest,
         RPCResponse,
     )
 
@@ -101,9 +106,21 @@ class RequestMocker:
         self.mock_results = mock_results or {}
         self.mock_errors = mock_errors or {}
         self.mock_responses = mock_responses or {}
-        self._make_request: Union[
-            "AsyncMakeRequestFn", "MakeRequestFn"
-        ] = w3.provider.make_request
+        if isinstance(w3.provider, PersistentConnectionProvider):
+            self._send_request = w3.provider.send_request
+            self._recv_for_request = w3.provider.recv_for_request
+        else:
+            self._make_request: Union[
+                "AsyncMakeRequestFn", "MakeRequestFn"
+            ] = w3.provider.make_request
+
+    def _build_request_id(self) -> int:
+        request_id = (
+            next(copy.deepcopy(self.w3.provider.request_counter))
+            if hasattr(self.w3.provider, "request_counter")
+            else 1
+        )
+        return request_id
 
     def __enter__(self) -> "Self":
         # mypy error: Cannot assign to a method
@@ -131,11 +148,7 @@ class RequestMocker:
         ):
             return self._make_request(method, params)
 
-        request_id = (
-            next(copy.deepcopy(self.w3.provider.request_counter))
-            if hasattr(self.w3.provider, "request_counter")
-            else 1
-        )
+        request_id = self._build_request_id()
         response_dict = {"jsonrpc": "2.0", "id": request_id}
 
         if method in self.mock_responses:
@@ -176,35 +189,34 @@ class RequestMocker:
     # -- async -- #
 
     async def __aenter__(self) -> "Self":
-        # mypy error: Cannot assign to a method
-        self.w3.provider.make_request = self._async_mock_request_handler  # type: ignore[method-assign]  # noqa: E501
-        # reset request func cache to re-build request_func with mocked make_request
-        self.w3.provider._request_func_cache = (None, None)
+        if not isinstance(self.w3.provider, PersistentConnectionProvider):
+            # mypy error: Cannot assign to a method
+            self.w3.provider.make_request = self._async_mock_request_handler  # type: ignore[method-assign]  # noqa: E501
+            # reset request func cache to re-build request_func w/ mocked make_request
+            self.w3.provider._request_func_cache = (None, None)
+        else:
+            self.w3.provider.send_request = self._async_mock_send_handler  # type: ignore[method-assign]  # noqa: E501
+            self.w3.provider.recv_for_request = self._async_mock_recv_handler  # type: ignore[method-assign]  # noqa: E501
+            self.w3.provider._send_func_cache = (None, None)
+            self.w3.provider._recv_func_cache = (None, None)
         return self
 
     async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        # mypy error: Cannot assign to a method
-        self.w3.provider.make_request = self._make_request  # type: ignore[assignment]
-        # reset request func cache to re-build request_func with original make_request
-        self.w3.provider._request_func_cache = (None, None)
+        if not isinstance(self.w3.provider, PersistentConnectionProvider):
+            # mypy error: Cannot assign to a method
+            self.w3.provider.make_request = self._make_request  # type: ignore[assignment]  # noqa: E501
+            # reset request func cache to re-build request_func w/ original make_request
+            self.w3.provider._request_func_cache = (None, None)
+        else:
+            self.w3.provider.send_request = self._send_request  # type: ignore[method-assign]  # noqa: E501
+            self.w3.provider.recv_for_request = self._recv_for_request  # type: ignore[method-assign]  # noqa: E501
+            self.w3.provider._send_func_cache = (None, None)
+            self.w3.provider._recv_func_cache = (None, None)
 
-    async def _async_mock_request_handler(
-        self, method: "RPCEndpoint", params: Any
+    async def _async_build_mock_result(
+        self, method: "RPCEndpoint", params: Any, request_id: int = None
     ) -> "RPCResponse":
-        self.w3 = cast("AsyncWeb3", self.w3)
-        self._make_request = cast("AsyncMakeRequestFn", self._make_request)
-
-        if all(
-            method not in mock_dict
-            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
-        ):
-            return await self._make_request(method, params)
-
-        request_id = (
-            next(copy.deepcopy(self.w3.provider.request_counter))
-            if hasattr(self.w3.provider, "request_counter")
-            else 1
-        )
+        request_id = request_id if request_id else self._build_request_id()
         response_dict = {"jsonrpc": "2.0", "id": request_id}
 
         if method in self.mock_responses:
@@ -244,6 +256,19 @@ class RequestMocker:
         else:
             raise Exception("Invariant: unreachable code path")
 
+        return mocked_result
+
+    async def _async_mock_request_handler(
+        self, method: "RPCEndpoint", params: Any
+    ) -> "RPCResponse":
+        self.w3 = cast("AsyncWeb3", self.w3)
+        self._make_request = cast("AsyncMakeRequestFn", self._make_request)
+        if all(
+            method not in mock_dict
+            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+        ):
+            return await self._make_request(method, params)
+        mocked_result = await self._async_build_mock_result(method, params)
         decorator = getattr(self._make_request, "_decorator", None)
         if decorator is not None:
             # If the original make_request was decorated, we need to re-apply
@@ -259,6 +284,47 @@ class RequestMocker:
         else:
             return mocked_result
 
+    async def _async_mock_send_handler(
+        self, method: "RPCEndpoint", params: Any
+    ) -> "RPCRequest":
+        if all(
+            method not in mock_dict
+            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+        ):
+            return await self._send_request(method, params)
+        else:
+            request_id = self._build_request_id()
+            return {"id": request_id, "method": method, "params": params}
+
+    async def _async_mock_recv_handler(
+        self, rpc_request: "RPCRequest"
+    ) -> "RPCResponse":
+        self.w3 = cast("AsyncWeb3", self.w3)
+        method = rpc_request["method"]
+        request_id = rpc_request["id"]
+        if all(
+            method not in mock_dict
+            for mock_dict in (self.mock_errors, self.mock_results, self.mock_responses)
+        ):
+            return await self._recv_for_request(request_id)
+        mocked_result = await self._async_build_mock_result(
+            method, rpc_request["params"], request_id=int(request_id)
+        )
+        decorator = getattr(self._recv_for_request, "_decorator", None)
+        if decorator is not None:
+            # If the original recv_for_request was decorated, we need to re-apply
+            # the decorator to the mocked recv_for_request. This is necessary for
+            # the request caching decorator to work properly.
+
+            async def _coro(
+                _provider: Any, _rpc_request: "RPCRequest"
+            ) -> "RPCResponse":
+                return mocked_result
+
+            return await decorator(_coro)(self.w3.provider, rpc_request)
+        else:
+            return mocked_result
+
     @staticmethod
     def _create_error_object(error: Dict[str, Any]) -> Dict[str, Any]:
         code = error.get("code", -32000)

web3/beacon/api_endpoints.py

@@ -59,6 +59,16 @@ GET_BEACON_HEADS = "/eth/v1/debug/beacon/heads"
 GET_NODE_IDENTITY = "/eth/v1/node/identity"
 GET_PEERS = "/eth/v1/node/peers"
 GET_PEER = "/eth/v1/node/peers/{0}"
+GET_PEER_COUNT = "/eth/v1/node/peer_count"
 GET_HEALTH = "/eth/v1/node/health"
 GET_VERSION = "/eth/v1/node/version"
 GET_SYNCING = "/eth/v1/node/syncing"
+
+# [ VALIDATOR endpoints ]
+
+GET_ATTESTER_DUTIES = "/eth/v1/validator/duties/attester/{0}"
+GET_BLOCK_PROPOSERS_DUTIES = "/eth/v1/validator/duties/proposer/{0}"
+GET_SYNC_COMMITTEE_DUTIES = "/eth/v1/validator/duties/sync/{0}"
+
+# [ REWARDS endpoints ]
+GET_ATTESTATIONS_REWARDS = "/eth/v1/beacon/rewards/attestations/{0}"

web3/beacon/async_beacon.py

@@ -3,6 +3,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Union,
 )
 
 from aiohttp import (
@@ -18,6 +19,8 @@ from web3._utils.http_session_manager import (
 )
 from web3.beacon.api_endpoints import (
     GET_ATTESTATIONS,
+    GET_ATTESTATIONS_REWARDS,
+    GET_ATTESTER_DUTIES,
     GET_ATTESTER_SLASHINGS,
     GET_BEACON_HEADS,
     GET_BEACON_STATE,
@@ -27,6 +30,7 @@ from web3.beacon.api_endpoints import (
     GET_BLOCK_ATTESTATIONS,
     GET_BLOCK_HEADER,
     GET_BLOCK_HEADERS,
+    GET_BLOCK_PROPOSERS_DUTIES,
     GET_BLOCK_ROOT,
     GET_BLS_TO_EXECUTION_CHANGES,
     GET_DEPOSIT_CONTRACT,
@@ -45,10 +49,12 @@ from web3.beacon.api_endpoints import (
     GET_LIGHT_CLIENT_UPDATES,
     GET_NODE_IDENTITY,
     GET_PEER,
+    GET_PEER_COUNT,
     GET_PEERS,
     GET_PROPOSER_SLASHINGS,
     GET_REWARDS,
     GET_SPEC,
+    GET_SYNC_COMMITTEE_DUTIES,
     GET_SYNCING,
     GET_VALIDATOR,
     GET_VALIDATOR_BALANCES,
@@ -78,6 +84,14 @@ class AsyncBeacon:
             uri, params=params, timeout=ClientTimeout(self.request_timeout)
         )
 
+    async def _async_make_post_request(
+        self, endpoint_uri: str, body: Union[List[str], Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        uri = URI(self.base_url + endpoint_uri)
+        return await self._request_session_manager.async_json_make_post_request(
+            uri, json=body, timeout=self.request_timeout
+        )
+
     # [ BEACON endpoints ]
 
     # states
@@ -216,6 +230,9 @@ class AsyncBeacon:
     async def get_peer(self, peer_id: str) -> Dict[str, Any]:
         return await self._async_make_get_request(GET_PEER.format(peer_id))
 
+    async def get_peer_count(self) -> Dict[str, Any]:
+        return await self._async_make_get_request(GET_PEER_COUNT)
+
     async def get_health(self) -> int:
         url = URI(self.base_url + GET_HEALTH)
         response = (
@@ -239,3 +256,33 @@ class AsyncBeacon:
             GET_BLOB_SIDECARS.format(block_id),
             params=indices_param,
         )
+
+    # [ VALIDATOR endpoints ]
+
+    async def get_attester_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return await self._async_make_post_request(
+            GET_ATTESTER_DUTIES.format(epoch), validator_indices
+        )
+
+    async def get_block_proposer_duties(self, epoch: str) -> Dict[str, Any]:
+        return await self._async_make_get_request(
+            GET_BLOCK_PROPOSERS_DUTIES.format(epoch)
+        )
+
+    async def get_sync_committee_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return await self._async_make_post_request(
+            GET_SYNC_COMMITTEE_DUTIES.format(epoch), validator_indices
+        )
+
+    # [ REWARDS endpoints ]
+
+    async def get_attestations_rewards(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return await self._async_make_post_request(
+            GET_ATTESTATIONS_REWARDS.format(epoch), validator_indices
+        )

web3/beacon/beacon.py

@@ -3,6 +3,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Union,
 )
 
 from eth_typing import (
@@ -15,6 +16,8 @@ from web3._utils.http_session_manager import (
 )
 from web3.beacon.api_endpoints import (
     GET_ATTESTATIONS,
+    GET_ATTESTATIONS_REWARDS,
+    GET_ATTESTER_DUTIES,
     GET_ATTESTER_SLASHINGS,
     GET_BEACON_HEADS,
     GET_BEACON_STATE,
@@ -24,6 +27,7 @@ from web3.beacon.api_endpoints import (
     GET_BLOCK_ATTESTATIONS,
     GET_BLOCK_HEADER,
     GET_BLOCK_HEADERS,
+    GET_BLOCK_PROPOSERS_DUTIES,
     GET_BLOCK_ROOT,
     GET_BLS_TO_EXECUTION_CHANGES,
     GET_DEPOSIT_CONTRACT,
@@ -42,10 +46,12 @@ from web3.beacon.api_endpoints import (
     GET_LIGHT_CLIENT_UPDATES,
     GET_NODE_IDENTITY,
     GET_PEER,
+    GET_PEER_COUNT,
     GET_PEERS,
     GET_PROPOSER_SLASHINGS,
     GET_REWARDS,
     GET_SPEC,
+    GET_SYNC_COMMITTEE_DUTIES,
     GET_SYNCING,
     GET_VALIDATOR,
     GET_VALIDATOR_BALANCES,
@@ -73,6 +79,14 @@ class Beacon:
             uri, params=params, timeout=self.request_timeout
         )
 
+    def _make_post_request(
+        self, endpoint_url: str, body: Union[List[str], Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        uri = URI(self.base_url + endpoint_url)
+        return self._request_session_manager.json_make_post_request(
+            uri, json=body, timeout=self.request_timeout
+        )
+
     # [ BEACON endpoints ]
 
     # states
@@ -201,6 +215,9 @@ class Beacon:
     def get_peer(self, peer_id: str) -> Dict[str, Any]:
         return self._make_get_request(GET_PEER.format(peer_id))
 
+    def get_peer_count(self) -> Dict[str, Any]:
+        return self._make_get_request(GET_PEER_COUNT)
+
     def get_health(self) -> int:
         url = URI(self.base_url + GET_HEALTH)
         response = self._request_session_manager.get_response_from_get_request(url)
@@ -222,3 +239,31 @@ class Beacon:
             GET_BLOB_SIDECARS.format(block_id),
             params=indices_param,
         )
+
+    # [ VALIDATOR endpoints ]
+
+    def get_attester_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return self._make_post_request(
+            GET_ATTESTER_DUTIES.format(epoch), validator_indices
+        )
+
+    def get_block_proposer_duties(self, epoch: str) -> Dict[str, Any]:
+        return self._make_get_request(GET_BLOCK_PROPOSERS_DUTIES.format(epoch))
+
+    def get_sync_committee_duties(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return self._make_post_request(
+            GET_SYNC_COMMITTEE_DUTIES.format(epoch), validator_indices
+        )
+
+    # [ REWARDS endpoints ]
+
+    def get_attestations_rewards(
+        self, epoch: str, validator_indices: List[str]
+    ) -> Dict[str, Any]:
+        return self._make_post_request(
+            GET_ATTESTATIONS_REWARDS.format(epoch), validator_indices
+        )

web3/contract/async_contract.py

@@ -14,7 +14,6 @@ from typing import (
 
 from eth_typing import (
     ABI,
-    ABIFunction,
     ChecksumAddress,
 )
 from eth_utils import (
@@ -22,7 +21,6 @@ from eth_utils import (
 )
 from eth_utils.abi import (
     abi_to_signature,
-    filter_abi_by_type,
     get_abi_input_names,
 )
 from eth_utils.toolz import (
@@ -34,7 +32,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 (
@@ -49,8 +46,6 @@ from web3._utils.compat import (
 )
 from web3._utils.contracts import (
     async_parse_block_identifier,
-    copy_contract_event,
-    copy_contract_function,
 )
 from web3._utils.datatypes import (
     PropertyCheckingFactory,
@@ -89,12 +84,6 @@ from web3.contract.utils import (
     get_function_by_identifier,
 )
 from web3.exceptions import (
-    ABIEventNotFound,
-    ABIFunctionNotFound,
-    MismatchedABI,
-    NoABIEventsFound,
-    NoABIFound,
-    NoABIFunctionsFound,
     Web3AttributeError,
     Web3TypeError,
     Web3ValidationError,
@@ -106,12 +95,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 AsyncENS  # noqa: F401
@@ -122,9 +105,6 @@ class AsyncContractEvent(BaseContractEvent):
     # mypy types
     w3: "AsyncWeb3"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> "AsyncContractEvent":
-        return copy_contract_event(self, *args, **kwargs)
-
     @combomethod
     async def get_logs(
         self,
@@ -255,162 +235,18 @@ class AsyncContractEvent(BaseContractEvent):
         builder.address = self.address
         return builder
 
-    @classmethod
-    def factory(cls, class_name: str, **kwargs: Any) -> Self:
-        return PropertyCheckingFactory(class_name, (cls,), kwargs)()
 
-
-class AsyncContractEvents(BaseContractEvents):
+class AsyncContractEvents(BaseContractEvents[AsyncContractEvent]):
     def __init__(
         self, abi: ABI, w3: "AsyncWeb3", address: Optional[ChecksumAddress] = None
     ) -> None:
         super().__init__(abi, w3, AsyncContractEvent, address)
 
-    def __iter__(self) -> Iterable["AsyncContractEvent"]:
-        if not hasattr(self, "_events") or not self._events:
-            return
-
-        for event in self._events:
-            yield self[abi_to_signature(event)]
-
-    def __getattr__(self, event_name: str) -> "AsyncContractEvent":
-        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) -> "AsyncContractEvent":
-        return getattr(self, event_name)
-
 
 class AsyncContractFunction(BaseContractFunction):
     # mypy types
     w3: "AsyncWeb3"
 
-    def __call__(self, *args: Any, **kwargs: Any) -> "AsyncContractFunction":
-        # 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 = AsyncContractFunction.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)()
-
     async def call(
         self,
         transaction: Optional[TxParams] = None,
@@ -551,7 +387,7 @@ class AsyncContractFunction(BaseContractFunction):
         return cast(AsyncContractFunction, NonExistentReceiveFunction())
 
 
-class AsyncContractFunctions(BaseContractFunctions):
+class AsyncContractFunctions(BaseContractFunctions[AsyncContractFunction]):
     def __init__(
         self,
         abi: ABI,
@@ -561,46 +397,6 @@ class AsyncContractFunctions(BaseContractFunctions):
     ) -> None:
         super().__init__(abi, w3, AsyncContractFunction, address, decode_tuples)
 
-    def __iter__(self) -> Iterable["AsyncContractFunction"]:
-        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) -> "AsyncContractFunction":
-        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) -> "AsyncContractFunction":
-        return getattr(self, function_name)
-
 
 class AsyncContract(BaseContract):
     functions: AsyncContractFunctions = None