web3 7.11.1__py3-none-any.whl → 7.12.1__py3-none-any.whl

ens/async_ens.py

@@ -57,7 +57,7 @@ from ens.utils import (
     address_in,
     address_to_reverse_domain,
     default,
-    ens_encode_name,
+    dns_encode_name,
     init_async_web3,
     is_empty_name,
     is_none_or_zero_address,
@@ -500,7 +500,7 @@ class AsyncENS(BaseENS):
 
             calldata = resolver.encode_abi(*contract_func_with_args)
             contract_call_result = await resolver.caller.resolve(
-                ens_encode_name(normal_name),
+                dns_encode_name(normal_name),
                 calldata,
             )
             result = self._decode_ensip10_resolve_data(

ens/ens.py

@@ -56,7 +56,7 @@ from .utils import (
     address_in,
     address_to_reverse_domain,
     default,
-    ens_encode_name,
+    dns_encode_name,
     init_web3,
     is_empty_name,
     is_none_or_zero_address,
@@ -482,7 +482,7 @@ class ENS(BaseENS):
 
             calldata = resolver.encode_abi(*contract_func_with_args)
             contract_call_result = resolver.caller.resolve(
-                ens_encode_name(normal_name),
+                dns_encode_name(normal_name),
                 calldata,
             )
             result = self._decode_ensip10_resolve_data(

ens/utils.py

@@ -13,6 +13,7 @@ from typing import (
     Union,
     cast,
 )
+import warnings
 
 from eth_typing import (
     Address,
@@ -132,7 +133,7 @@ def normalize_name(name: str) -> str:
     return normalize_name_ensip15(name).as_text
 
 
-def ens_encode_name(name: str) -> bytes:
+def dns_encode_name(name: str) -> HexBytes:
     r"""
     Encode a name according to DNS standards specified in section 3.1
     of RFC1035 with the following validations:
@@ -145,7 +146,7 @@ def ens_encode_name(name: str) -> bytes:
     :param str name: the dot-separated ENS name
     """
     if is_empty_name(name):
-        return b"\x00"
+        return HexBytes(b"\x00")
 
     normalized_name = normalize_name(name)
 
@@ -163,7 +164,17 @@ def ens_encode_name(name: str) -> bytes:
     dns_prepped_labels = [to_bytes(len(label)) + label for label in labels_as_bytes]
 
     # return the joined prepped labels in order and append the zero byte at the end:
-    return b"".join(dns_prepped_labels) + b"\x00"
+    return HexBytes(b"".join(dns_prepped_labels) + b"\x00")
+
+
+def ens_encode_name(name: str) -> bytes:
+    warnings.warn(
+        "``ens_encode_name`` is deprecated and will be removed in the next "
+        "major version. Use ``dns_encode_name`` instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return bytes(dns_encode_name(name))
 
 
 def is_valid_name(name: str) -> bool:

web3/_utils/abi.py

@@ -73,7 +73,6 @@ from eth_utils import (
 )
 from eth_utils.toolz import (
     curry,
-    partial,
     pipe,
 )
 
@@ -115,21 +114,21 @@ def receive_func_abi_exists(contract_abi: ABI) -> Sequence[ABIReceive]:
     return filter_abi_by_type("receive", contract_abi)
 
 
-def get_indexed_event_inputs(event_abi: ABIEvent) -> Sequence[ABIComponentIndexed]:
+def get_indexed_event_inputs(event_abi: ABIEvent) -> List[ABIComponentIndexed]:
     return [arg for arg in event_abi["inputs"] if arg["indexed"] is True]
 
 
-def exclude_indexed_event_inputs(event_abi: ABIEvent) -> Sequence[ABIComponentIndexed]:
+def exclude_indexed_event_inputs(event_abi: ABIEvent) -> List[ABIComponentIndexed]:
     return [arg for arg in event_abi["inputs"] if arg["indexed"] is False]
 
 
-def filter_by_types(types: Collection[str], contract_abi: ABI) -> Sequence[ABIElement]:
+def filter_by_types(types: Collection[str], contract_abi: ABI) -> List[ABIElement]:
     return [abi_element for abi_element in contract_abi if abi_element["type"] in types]
 
 
 def filter_by_argument_name(
     argument_names: Collection[str], contract_abi: ABI
-) -> Sequence[ABIElement]:
+) -> List[ABIElement]:
     """
     Return a list of each ``ABIElement`` which contains arguments matching provided
     names.
@@ -186,7 +185,7 @@ def get_name_from_abi_element_identifier(
 
 def get_abi_element_signature(
     abi_element_identifier: ABIElementIdentifier,
-    abi_element_argument_types: Optional[Sequence[str]] = None,
+    abi_element_argument_types: Optional[Iterable[str]] = None,
 ) -> str:
     element_name = get_name_from_abi_element_identifier(abi_element_identifier)
     argument_types = ",".join(abi_element_argument_types or [])
@@ -585,9 +584,9 @@ def normalize_event_input_types(
 
 @curry
 def map_abi_data(
-    normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]],
-    types: Sequence[TypeStr],
-    data: Sequence[Any],
+    normalizers: Iterable[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]],
+    types: Iterable[TypeStr],
+    data: Iterable[Any],
 ) -> Any:
     """
     Applies normalizers to your data, in the context of the relevant types.
@@ -611,17 +610,21 @@ def map_abi_data(
     2. Recursively mapping each of the normalizers to the data
     3. Stripping the types back out of the tree
     """
-    pipeline = itertools.chain(
-        [abi_data_tree(types)],
-        map(data_tree_map, normalizers),
-        [partial(recursive_map, strip_abi_type)],
+    return pipe(
+        data,
+        # 1. Decorating the data tree with types
+        abi_data_tree(types),
+        # 2. Recursively mapping each of the normalizers to the data
+        *map(data_tree_map, normalizers),
+        # 3. Stripping the types back out of the tree
+        strip_abi_types,
     )
 
-    return pipe(data, *pipeline)
-
 
 @curry
-def abi_data_tree(types: Sequence[TypeStr], data: Sequence[Any]) -> List[Any]:
+def abi_data_tree(
+    types: Iterable[TypeStr], data: Iterable[Any]
+) -> List["ABITypedData"]:
     """
     Decorate the data tree with pairs of (type, data). The pair tuple is actually an
     ABITypedData, but can be accessed as a tuple.
@@ -631,10 +634,7 @@ def abi_data_tree(types: Sequence[TypeStr], data: Sequence[Any]) -> List[Any]:
     >>> abi_data_tree(types=["bool[2]", "uint"], data=[[True, False], 0])
     [("bool[2]", [("bool", True), ("bool", False)]), ("uint256", 0)]
     """
-    return [
-        abi_sub_tree(data_type, data_value)
-        for data_type, data_value in zip(types, data)
-    ]
+    return list(map(abi_sub_tree, types, data))
 
 
 @curry
@@ -723,6 +723,10 @@ def strip_abi_type(elements: Any) -> Any:
         return elements
 
 
+def strip_abi_types(elements: Any) -> Any:
+    return recursive_map(strip_abi_type, elements)
+
+
 def build_non_strict_registry() -> ABIRegistry:
     # We make a copy here just to make sure that eth-abi's default registry is not
     # affected by our custom encoder subclasses

web3/_utils/batching.py

@@ -1,9 +1,3 @@
-from copy import (
-    copy,
-)
-from functools import (
-    wraps,
-)
 from types import (
     TracebackType,
 )
@@ -15,11 +9,8 @@ from typing import (
     Dict,
     Generic,
     List,
-    Protocol,
-    Sequence,
     Tuple,
     Type,
-    TypeVar,
     Union,
     cast,
 )
@@ -28,17 +19,10 @@ 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 (
-    RPCEndpoint,
     TFunc,
     TReturn,
 )
@@ -48,6 +32,12 @@ if TYPE_CHECKING:
         AsyncWeb3,
         Web3,
     )
+    from web3.contract.async_contract import (
+        AsyncContractFunction,
+    )
+    from web3.contract.contract import (
+        ContractFunction,
+    )
     from web3.method import (  # noqa: F401
         Method,
     )
@@ -61,13 +51,14 @@ if TYPE_CHECKING:
         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]]
+BatchRequestInformation = Tuple[Tuple["RPCEndpoint", Any], Tuple[Any, ...]]
 RPC_METHODS_UNSUPPORTED_DURING_BATCH = {
     "eth_subscribe",
     "eth_unsubscribe",
@@ -104,21 +95,18 @@ class RequestBatcher(Generic[TFunc]):
             )
 
     def _initialize_batching(self) -> None:
-        self._provider._is_batching = True
+        self._provider._batching_context.set(self)
         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
+        self._provider._batching_context.set(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
+        if hasattr(batch_payload, "call"):
+            batch_payload = batch_payload.call()
 
         # 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
@@ -136,8 +124,8 @@ class RequestBatcher(Generic[TFunc]):
             Union[
                 "Method[Callable[..., Any]]",
                 Callable[..., Any],
-                ContractFunction,
-                AsyncContractFunction,
+                "ContractFunction",
+                "AsyncContractFunction",
             ],
             List[Any],
         ],
@@ -156,9 +144,6 @@ class RequestBatcher(Generic[TFunc]):
     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()
@@ -181,9 +166,14 @@ class RequestBatcher(Generic[TFunc]):
 
     async def async_execute(self) -> List["RPCResponse"]:
         self._validate_is_batching()
-        responses = await self.web3.manager._async_make_batch_request(
-            self._async_requests_info
-        )
+        if self._provider.has_persistent_connection:
+            responses = await self.web3.manager._async_make_socket_batch_request(
+                self._async_requests_info
+            )
+        else:
+            responses = await self.web3.manager._async_make_batch_request(
+                self._async_requests_info
+            )
         self._end_batching()
         return responses
 
@@ -220,39 +210,3 @@ def sort_batch_response_by_response_ids(
             stacklevel=2,
         )
         return responses
-
-
-class SupportsBatching(Protocol):
-    _is_batching: bool
-
-
-R = TypeVar("R")
-T = TypeVar("T", bound=SupportsBatching)
-
-
-def async_batching_context(
-    method: Callable[[T, List[Tuple[RPCEndpoint, Any]]], Coroutine[Any, Any, R]]
-) -> Callable[[T, List[Tuple[RPCEndpoint, Any]]], Coroutine[Any, Any, R]]:
-    @wraps(method)
-    async def wrapper(self: T, requests: List[Tuple[RPCEndpoint, Any]]) -> R:
-        self._is_batching = True
-        try:
-            return await method(self, requests)
-        finally:
-            self._is_batching = False
-
-    return wrapper
-
-
-def batching_context(
-    method: Callable[[T, List[Tuple[RPCEndpoint, Any]]], R]
-) -> Callable[[T, List[Tuple[RPCEndpoint, Any]]], R]:
-    @wraps(method)
-    def wrapper(self: T, requests: List[Tuple[RPCEndpoint, Any]]) -> R:
-        self._is_batching = True
-        try:
-            return method(self, requests)
-        finally:
-            self._is_batching = False
-
-    return wrapper

web3/_utils/caching/request_caching_validation.py

@@ -73,7 +73,8 @@ def is_beyond_validation_threshold(
         else:
             provider.logger.error(
                 "Invalid request_cache_validation_threshold value. This should not "
-                f"have happened. Request not cached.\n    threshold: {threshold}"
+                "have happened. Request not cached.\n    threshold: %s",
+                threshold,
             )
             return False
     except Exception as e:
@@ -128,7 +129,8 @@ def validate_from_blocknum_in_result(
         else:
             provider.logger.error(
                 "Could not find block number in result. This should not have happened. "
-                f"Request not cached.\n    result: {result}",
+                "Request not cached.\n    result: %s",
+                result,
             )
             return False
     except Exception as e:
@@ -198,7 +200,8 @@ async def async_is_beyond_validation_threshold(
         else:
             provider.logger.error(
                 "Invalid request_cache_validation_threshold value. This should not "
-                f"have happened. Request not cached.\n    threshold: {threshold}"
+                "have happened. Request not cached.\n    threshold: %s",
+                threshold,
             )
             return False
     except Exception as e:
@@ -253,7 +256,8 @@ async def async_validate_from_blocknum_in_result(
         else:
             provider.logger.error(
                 "Could not find block number in result. This should not have happened. "
-                f"Request not cached.\n    result: {result}",
+                "Request not cached.\n    result: %s",
+                result,
             )
             return False
     except Exception as e:

web3/_utils/decorators.py

@@ -3,6 +3,8 @@ import threading
 from typing import (
     Any,
     Callable,
+    Set,
+    Tuple,
     TypeVar,
     cast,
 )
@@ -20,21 +22,22 @@ def reject_recursive_repeats(to_wrap: Callable[..., Any]) -> Callable[..., Any]:
     Prevent simple cycles by returning None when called recursively with same instance
     """
     # types ignored b/c dynamically set attribute
-    to_wrap.__already_called = {}  # type: ignore
+    already_called: Set[Tuple[int, ...]] = set()
+    to_wrap.__already_called = already_called  # type: ignore
+
+    add_call = already_called.add
+    remove_call = already_called.remove
 
     @functools.wraps(to_wrap)
     def wrapped(*args: Any) -> Any:
-        arg_instances = tuple(map(id, args))
-        thread_id = threading.get_ident()
-        thread_local_args = (thread_id,) + arg_instances
-        if thread_local_args in to_wrap.__already_called:  # type: ignore
+        thread_local_args = (threading.get_ident(), *map(id, args))
+        if thread_local_args in already_called:
             raise Web3ValueError(f"Recursively called {to_wrap} with {args!r}")
-        to_wrap.__already_called[thread_local_args] = True  # type: ignore
+        add_call(thread_local_args)
         try:
-            wrapped_val = to_wrap(*args)
+            return to_wrap(*args)
         finally:
-            del to_wrap.__already_called[thread_local_args]  # type: ignore
-        return wrapped_val
+            remove_call(thread_local_args)
 
     return wrapped
 

web3/_utils/http_session_manager.py

@@ -81,14 +81,14 @@ class HTTPSessionManager:
 
         with self._lock:
             cached_session, evicted_items = self.session_cache.cache(cache_key, session)
-            self.logger.debug(f"Session cached: {endpoint_uri}, {cached_session}")
+            self.logger.debug("Session cached: %s, %s", endpoint_uri, cached_session)
 
         if evicted_items is not None:
             evicted_sessions = evicted_items.values()
             for evicted_session in evicted_sessions:
                 self.logger.debug(
-                    "Session cache full. Session evicted from cache: "
-                    f"{evicted_session}",
+                    "Session cache full. Session evicted from cache: %s",
+                    evicted_session,
                 )
             threading.Timer(
                 # If `request_timeout` is `None`, don't wait forever for the closing
@@ -167,7 +167,7 @@ class HTTPSessionManager:
     def _close_evicted_sessions(self, evicted_sessions: List[requests.Session]) -> None:
         for evicted_session in evicted_sessions:
             evicted_session.close()
-            self.logger.debug(f"Closed evicted session: {evicted_session}")
+            self.logger.debug("Closed evicted session: %s", evicted_session)
 
     # -- async -- #
 
@@ -178,7 +178,7 @@ class HTTPSessionManager:
         request_timeout: Optional[ClientTimeout] = None,
     ) -> ClientSession:
         # cache key should have a unique thread identifier
-        cache_key = generate_cache_key(f"{threading.get_ident()}:{endpoint_uri}")
+        cache_key = generate_cache_key(f"{id(asyncio.get_event_loop())}:{endpoint_uri}")
 
         evicted_items = None
         async with async_lock(self.session_pool, self._lock):
@@ -195,7 +195,7 @@ class HTTPSessionManager:
                     cache_key, session
                 )
                 self.logger.debug(
-                    f"Async session cached: {endpoint_uri}, {cached_session}"
+                    "Async session cached: %s, %s", endpoint_uri, cached_session
                 )
 
             else:
@@ -215,8 +215,10 @@ class HTTPSessionManager:
                 )
                 if warning:
                     self.logger.debug(
-                        f"{warning}: {endpoint_uri}, {cached_session}. "
-                        f"Creating and caching a new async session for uri."
+                        "%s: %s, %s. Creating and caching a new async session for uri.",
+                        warning,
+                        endpoint_uri,
+                        cached_session,
                     )
 
                     self.session_cache._data.pop(cache_key)
@@ -224,7 +226,8 @@ class HTTPSessionManager:
                         # if loop was closed but not the session, close the session
                         await cached_session.close()
                     self.logger.debug(
-                        f"Async session closed and evicted from cache: {cached_session}"
+                        "Async session closed and evicted from cache: %s",
+                        cached_session,
                     )
 
                     # replace stale session with a new session at the cache key
@@ -238,7 +241,7 @@ class HTTPSessionManager:
                         cache_key, _session
                     )
                     self.logger.debug(
-                        f"Async session cached: {endpoint_uri}, {cached_session}"
+                        "Async session cached: %s, %s", endpoint_uri, cached_session
                     )
 
         if evicted_items is not None:
@@ -248,8 +251,8 @@ class HTTPSessionManager:
             evicted_sessions = list(evicted_items.values())
             for evicted_session in evicted_sessions:
                 self.logger.debug(
-                    "Async session cache full. Session evicted from cache: "
-                    f"{evicted_session}",
+                    "Async session cache full. Session evicted from cache: %s",
+                    evicted_session,
                 )
             # Kick off an asyncio `Task` to close the evicted sessions. In the case
             # that the cache filled very quickly and some sessions have been evicted
@@ -323,10 +326,10 @@ class HTTPSessionManager:
 
         for evicted_session in evicted_sessions:
             await evicted_session.close()
-            self.logger.debug(f"Closed evicted async session: {evicted_session}")
+            self.logger.debug("Closed evicted async session: %s", evicted_session)
 
         if any(not evicted_session.closed for evicted_session in evicted_sessions):
             self.logger.warning(
-                "Some evicted async sessions were not properly closed: "
-                f"{evicted_sessions}"
+                "Some evicted async sessions were not properly closed: %s",
+                evicted_sessions,
             )

web3/_utils/method_formatters.py

@@ -105,6 +105,7 @@ from web3.types import (
     BlockIdentifier,
     Formatters,
     RPCEndpoint,
+    RPCResponse,
     SimulateV1Payload,
     StateOverrideParams,
     TReturn,
@@ -650,19 +651,15 @@ simulate_v1_request_formatter: Callable[
 )
 
 block_result_formatters_copy = BLOCK_RESULT_FORMATTERS.copy()
-block_result_formatters_copy.update(
-    {
-        "calls": apply_list_to_array_formatter(
-            type_aware_apply_formatters_to_dict(
-                {
-                    "returnData": HexBytes,
-                    "logs": apply_list_to_array_formatter(log_entry_formatter),
-                    "gasUsed": to_integer_if_hex,
-                    "status": to_integer_if_hex,
-                }
-            )
-        )
-    }
+block_result_formatters_copy["calls"] = apply_list_to_array_formatter(
+    type_aware_apply_formatters_to_dict(
+        {
+            "returnData": HexBytes,
+            "logs": apply_list_to_array_formatter(log_entry_formatter),
+            "gasUsed": to_integer_if_hex,
+            "status": to_integer_if_hex,
+        }
+    )
 )
 simulate_v1_result_formatter = apply_formatter_if(
     is_not_null,
@@ -1107,9 +1104,7 @@ def combine_formatters(
             yield formatter_map[method_name]
 
 
-def get_request_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
-) -> Dict[str, Callable[..., Any]]:
+def get_request_formatters(method_name: RPCEndpoint) -> Callable[[RPCResponse], Any]:
     request_formatter_maps = (
         ABI_REQUEST_FORMATTERS,
         # METHOD_NORMALIZERS needs to be after ABI_REQUEST_FORMATTERS
@@ -1241,7 +1236,7 @@ FILTER_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
 
 @to_tuple
 def apply_module_to_formatters(
-    formatters: Tuple[Callable[..., TReturn]],
+    formatters: Iterable[Callable[..., TReturn]],
     module: "Module",
     method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
 ) -> Iterable[Callable[..., TReturn]]:
@@ -1250,9 +1245,9 @@ def apply_module_to_formatters(
 
 
 def get_result_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
+    method_name: RPCEndpoint,
     module: "Module",
-) -> Dict[str, Callable[..., Any]]:
+) -> Callable[[RPCResponse], Any]:
     formatters = combine_formatters((PYTHONIC_RESULT_FORMATTERS,), method_name)
     formatters_requiring_module = combine_formatters(
         (FILTER_RESULT_FORMATTERS,), method_name
@@ -1263,9 +1258,7 @@ def get_result_formatters(
     return compose(*partial_formatters, *formatters)
 
 
-def get_error_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
-) -> Callable[..., Any]:
+def get_error_formatters(method_name: RPCEndpoint) -> Callable[[RPCResponse], Any]:
     #  Note error formatters work on the full response dict
     error_formatter_maps = (ERROR_FORMATTERS,)
     formatters = combine_formatters(error_formatter_maps, method_name)
@@ -1274,8 +1267,8 @@ def get_error_formatters(
 
 
 def get_null_result_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
-) -> Callable[..., Any]:
+    method_name: RPCEndpoint,
+) -> Callable[[RPCResponse], Any]:
     formatters = combine_formatters((NULL_RESULT_FORMATTERS,), method_name)
 
     return compose(*formatters)