web3 7.10.0__py3-none-any.whl → 7.11.0__py3-none-any.whl

ens/exceptions.py

@@ -32,7 +32,7 @@ class AddressMismatch(ENSException):
 class InvalidName(idna.IDNAError, ENSException):
     """
     Raised if the provided name does not meet the normalization
-    standards specified in `ENSIP-15
+    standards specified in `ENSIP-15`
     <https://docs.ens.domains/ens-improvement-proposals/ensip-15-normalization-standard>`_.
     """
 

web3/_utils/batching.py

@@ -1,6 +1,9 @@
 from copy import (
     copy,
 )
+from functools import (
+    wraps,
+)
 from types import (
     TracebackType,
 )
@@ -12,9 +15,11 @@ from typing import (
     Dict,
     Generic,
     List,
+    Protocol,
     Sequence,
     Tuple,
     Type,
+    TypeVar,
     Union,
     cast,
 )
@@ -33,6 +38,7 @@ from web3.exceptions import (
     Web3ValueError,
 )
 from web3.types import (
+    RPCEndpoint,
     TFunc,
     TReturn,
 )
@@ -55,7 +61,6 @@ if TYPE_CHECKING:
         JSONBaseProvider,
     )
     from web3.types import (  # noqa: F401
-        RPCEndpoint,
         RPCResponse,
     )
 
@@ -215,3 +220,39 @@ 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/encoding.py

@@ -36,6 +36,9 @@ from eth_utils.toolz import (
 from hexbytes import (
     HexBytes,
 )
+from pydantic import (
+    BaseModel,
+)
 
 from web3._utils.abi import (
     is_address_type,
@@ -299,6 +302,11 @@ class Web3JsonEncoder(json.JSONEncoder):
             return obj.__dict__
         elif isinstance(obj, (HexBytes, bytes)):
             return to_hex(obj)
+        elif isinstance(obj, BaseModel):
+            # TODO: For now we can assume all BaseModel objects behave this way, but
+            #  internally we will start to use the CamelModel from eth-utils. Perhaps
+            #  we should check for that type instead.
+            return obj.model_dump(by_alias=True)
         return json.JSONEncoder.default(self, obj)
 
 

web3/_utils/ens.py

@@ -65,13 +65,21 @@ class StaticENS:
         return self.registry.get(name, None)
 
 
+class AsyncStaticENS:
+    def __init__(self, name_addr_pairs: Dict[str, ChecksumAddress]) -> None:
+        self.registry = dict(name_addr_pairs)
+
+    async def address(self, name: str) -> ChecksumAddress:
+        return self.registry.get(name, None)
+
+
 @contextmanager
 def ens_addresses(
     w3: Union["Web3", "AsyncWeb3"], name_addr_pairs: Dict[str, ChecksumAddress]
 ) -> Iterator[None]:
     original_ens = w3.ens
     if w3.provider.is_async:
-        w3.ens = cast(AsyncENS, StaticENS(name_addr_pairs))
+        w3.ens = cast(AsyncENS, AsyncStaticENS(name_addr_pairs))
     else:
         w3.ens = cast(ENS, StaticENS(name_addr_pairs))
     yield

web3/_utils/method_formatters.py

@@ -47,6 +47,9 @@ from eth_utils.toolz import (
 from hexbytes import (
     HexBytes,
 )
+from pydantic import (
+    BaseModel,
+)
 
 from web3._utils.abi import (
     is_length,
@@ -161,6 +164,12 @@ def type_aware_apply_formatters_to_dict(
     """
     Preserve ``AttributeDict`` types if original ``value`` was an ``AttributeDict``.
     """
+    # TODO: In v8, Use eth-utils 5.3.0 as lower pin where ``apply_formatters_to_dict``
+    #  already handles the CamelModel case, rather than generalizing to all BaseModel
+    #  instances.
+    if isinstance(value, BaseModel):
+        value = value.model_dump(by_alias=True)
+
     formatted_dict: Dict[str, Any] = apply_formatters_to_dict(formatters, dict(value))
     return (
         AttributeDict.recursive(formatted_dict)
@@ -177,6 +186,9 @@ def type_aware_apply_formatters_to_dict_keys_and_values(
     """
     Preserve ``AttributeDict`` types if original ``value`` was an ``AttributeDict``.
     """
+    if isinstance(dict_like_object, BaseModel):
+        dict_like_object = dict_like_object.model_dump(by_alias=True)
+
     formatted_dict = {
         key_formatters(k): value_formatters(v) for k, v in dict_like_object.items()
     }
@@ -223,6 +235,22 @@ ACCESS_LIST_RESPONSE_FORMATTER = type_aware_apply_formatters_to_dict(
     }
 )
 
+AUTH_LIST_RESULT_FORMATTER = apply_formatter_if(
+    is_not_null,
+    apply_formatter_to_array(
+        type_aware_apply_formatters_to_dict(
+            {
+                "chainId": to_integer_if_hex,
+                "address": to_checksum_address,
+                "nonce": to_integer_if_hex,
+                "yParity": to_integer_if_hex,
+                "r": to_hexbytes(32, variable_length=True),
+                "s": to_hexbytes(32, variable_length=True),
+            }
+        ),
+    ),
+)
+
 TRANSACTION_RESULT_FORMATTERS = {
     "blockHash": apply_formatter_if(is_not_null, to_hexbytes(32)),
     "blockNumber": apply_formatter_if(is_not_null, to_integer_if_hex),
@@ -255,6 +283,7 @@ TRANSACTION_RESULT_FORMATTERS = {
     "blobVersionedHashes": apply_formatter_if(
         is_not_null, apply_formatter_to_array(to_hexbytes(32))
     ),
+    "authorizationList": AUTH_LIST_RESULT_FORMATTER,
 }
 
 
@@ -332,6 +361,7 @@ BLOCK_REQUEST_FORMATTERS = {
     "transactionsRoot": to_hex_if_bytes,
     "withdrawalsRoot": to_hex_if_bytes,
     "parentBeaconBlockRoot": to_hex_if_bytes,
+    "requestsHash": to_hex_if_bytes,
 }
 block_request_formatter = type_aware_apply_formatters_to_dict(BLOCK_REQUEST_FORMATTERS)
 
@@ -374,6 +404,7 @@ BLOCK_RESULT_FORMATTERS = {
     "blobGasUsed": to_integer_if_hex,
     "excessBlobGas": to_integer_if_hex,
     "parentBeaconBlockRoot": apply_formatter_if(is_not_null, to_hexbytes(32)),
+    "requestsHash": apply_formatter_if(is_not_null, to_hexbytes(32)),
 }
 block_result_formatter = type_aware_apply_formatters_to_dict(BLOCK_RESULT_FORMATTERS)
 
@@ -466,6 +497,22 @@ filter_result_formatter = apply_one_of_formatters(
     )
 )
 
+AUTH_LIST_REQUEST_FORMATTER = apply_formatter_if(
+    is_not_null,
+    apply_formatter_to_array(
+        type_aware_apply_formatters_to_dict(
+            {
+                "chainId": to_hex_if_integer,
+                "address": to_checksum_address,
+                "nonce": to_hex_if_integer,
+                "yParity": to_hex_if_integer,
+                "r": to_hex_if_integer,
+                "s": to_hex_if_integer,
+            }
+        ),
+    ),
+)
+
 TRANSACTION_REQUEST_FORMATTER = {
     "from": to_checksum_address,
     "to": apply_formatter_if(is_address, to_checksum_address),
@@ -477,12 +524,13 @@ TRANSACTION_REQUEST_FORMATTER = {
     "maxFeePerGas": to_hex_if_integer,
     "maxPriorityFeePerGas": to_hex_if_integer,
     "chainId": to_hex_if_integer,
+    "authorizationList": AUTH_LIST_REQUEST_FORMATTER,
 }
 transaction_request_formatter = type_aware_apply_formatters_to_dict(
     TRANSACTION_REQUEST_FORMATTER
 )
 
-ACCESS_LIST_REQUEST_FORMATTER = type_aware_apply_formatters_to_dict(
+ETH_CALL_TX_FORMATTER = type_aware_apply_formatters_to_dict(
     {
         "accessList": apply_formatter_if(
             is_not_null,
@@ -494,10 +542,11 @@ ACCESS_LIST_REQUEST_FORMATTER = type_aware_apply_formatters_to_dict(
                 )
             ),
         ),
+        "authorizationList": AUTH_LIST_REQUEST_FORMATTER,
     }
 )
 transaction_param_formatter = compose(
-    ACCESS_LIST_REQUEST_FORMATTER,
+    ETH_CALL_TX_FORMATTER,
     remove_key_if("to", lambda txn: txn["to"] in {"", b"", None}),
     remove_key_if("gasPrice", lambda txn: txn["gasPrice"] in {"", b"", None}),
 )
@@ -1057,7 +1106,7 @@ def combine_formatters(
 
 
 def get_request_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]]
+    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
 ) -> Dict[str, Callable[..., Any]]:
     request_formatter_maps = (
         ABI_REQUEST_FORMATTERS,
@@ -1083,7 +1132,7 @@ def raise_block_not_found(params: Tuple[BlockIdentifier, bool]) -> NoReturn:
 
 
 def raise_block_not_found_for_uncle_at_index(
-    params: Tuple[BlockIdentifier, Union[HexStr, int]]
+    params: Tuple[BlockIdentifier, Union[HexStr, int]],
 ) -> NoReturn:
     try:
         block_identifier = params[0]
@@ -1109,7 +1158,7 @@ def raise_transaction_not_found(params: Tuple[_Hash32]) -> NoReturn:
 
 
 def raise_transaction_not_found_with_index(
-    params: Tuple[BlockIdentifier, int]
+    params: Tuple[BlockIdentifier, int],
 ) -> NoReturn:
     try:
         block_identifier = params[0]
@@ -1213,7 +1262,7 @@ def get_result_formatters(
 
 
 def get_error_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]]
+    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
 ) -> Callable[..., Any]:
     #  Note error formatters work on the full response dict
     error_formatter_maps = (ERROR_FORMATTERS,)
@@ -1223,7 +1272,7 @@ def get_error_formatters(
 
 
 def get_null_result_formatters(
-    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]]
+    method_name: Union[RPCEndpoint, Callable[..., RPCEndpoint]],
 ) -> Callable[..., Any]:
     formatters = combine_formatters((NULL_RESULT_FORMATTERS,), method_name)