web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/method.py

@@ -10,7 +10,6 @@ from typing import (
     Sequence,
     Tuple,
     Type,
-    TypeVar,
     Union,
 )
 import warnings
@@ -22,6 +21,9 @@ from eth_utils.toolz import (
     pipe,
 )
 
+from web3._utils.batching import (
+    RPC_METHODS_UNSUPPORTED_DURING_BATCH,
+)
 from web3._utils.method_formatters import (
     get_error_formatters,
     get_null_result_formatters,
@@ -32,15 +34,22 @@ from web3._utils.rpc_abi import (
     RPC,
 )
 from web3.exceptions import (
+    MethodNotSupported,
+    Web3TypeError,
     Web3ValidationError,
+    Web3ValueError,
 )
 from web3.types import (
     RPCEndpoint,
+    TFunc,
     TReturn,
 )
 
 if TYPE_CHECKING:
-    from web3 import Web3  # noqa: F401
+    from web3 import (  # noqa: F401
+        PersistentConnectionProvider,
+        Web3,
+    )
     from web3.module import Module  # noqa: F401
 
 
@@ -66,7 +75,9 @@ def _set_mungers(
     return (
         mungers
         if mungers
-        else [default_munger] if is_property else [default_root_munger]
+        else [default_munger]
+        if is_property
+        else [default_root_munger]
     )
 
 
@@ -80,11 +91,9 @@ def default_root_munger(_module: "Module", *args: Any) -> List[Any]:
     return [*args]
 
 
-TFunc = TypeVar("TFunc", bound=Callable[..., Any])
-
-
 class Method(Generic[TFunc]):
-    """Method object for web3 module methods
+    """
+    Method object for web3 module methods
 
     Calls to the Method go through these steps:
 
@@ -144,15 +153,31 @@ class Method(Generic[TFunc]):
         self.is_property = is_property
 
     def __get__(
-        self, obj: Optional["Module"] = None, obj_type: Optional[Type["Module"]] = None
+        self,
+        module: Optional["Module"] = None,
+        _type: Optional[Type["Module"]] = None,
     ) -> TFunc:
-        if obj is None:
-            raise TypeError(
+        self._module = module
+        if module is None:
+            raise Web3TypeError(
                 "Direct calls to methods are not supported. "
-                "Methods must be called from an module instance, "
+                "Methods must be called from a module instance, "
                 "usually attached to a web3 instance."
             )
-        return obj.retrieve_caller_fn(self)
+
+        provider = module.w3.provider
+        if hasattr(provider, "_is_batching") and provider._is_batching:
+            if self.json_rpc_method in RPC_METHODS_UNSUPPORTED_DURING_BATCH:
+                raise MethodNotSupported(
+                    f"Method `{self.json_rpc_method}` is not supported within a batch "
+                    "request."
+                )
+            return module.retrieve_request_information(self)
+        else:
+            return module.retrieve_caller_fn(self)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.__get__(self._module)(*args, **kwargs)
 
     @property
     def method_selector_fn(
@@ -163,7 +188,7 @@ class Method(Generic[TFunc]):
             return self.json_rpc_method
         elif isinstance(self.json_rpc_method, (str,)):
             return lambda *_: self.json_rpc_method
-        raise ValueError(
+        raise Web3ValueError(
             "``json_rpc_method`` config invalid.  May be a string or function"
         )
 
@@ -175,8 +200,10 @@ class Method(Generic[TFunc]):
             lambda args, munger: munger(module, *args, **kwargs), self.mungers, args
         )
 
-    def process_params(self, module: "Module", *args: Any, **kwargs: Any) -> Tuple[
-        Tuple[Union[RPCEndpoint, Callable[..., RPCEndpoint]], Tuple[Any, ...]],
+    def process_params(
+        self, module: "Module", *args: Any, **kwargs: Any
+    ) -> Tuple[
+        Tuple[Union[RPCEndpoint, Callable[..., RPCEndpoint]], Tuple[RPCEndpoint, ...]],
         Tuple[
             Union[TReturn, Dict[str, Callable[..., Any]]],
             Callable[..., Any],
@@ -226,5 +253,6 @@ class DeprecatedMethod:
         warnings.warn(
             f"{self.old_name} is deprecated in favor of {self.new_name}",
             category=DeprecationWarning,
+            stacklevel=2,
         )
         return self.method.__get__(obj, obj_type)

web3/middleware/__init__.py

@@ -92,3 +92,20 @@ async def async_combine_middleware(
         initialized = mw(async_w3)
         accumulator_fn = await initialized.async_wrap_make_request(accumulator_fn)
     return accumulator_fn
+
+
+__all__ = [
+    "AttributeDictMiddleware",
+    "Middleware",
+    "Web3Middleware",
+    "BufferedGasEstimateMiddleware",
+    "LocalFilterMiddleware",
+    "FormattingMiddlewareBuilder",
+    "GasPriceStrategyMiddleware",
+    "ENSNameToAddressMiddleware",
+    "ExtraDataToPOAMiddleware",
+    "PythonicMiddleware",
+    "SignAndSendRawMiddlewareBuilder",
+    "StalecheckMiddlewareBuilder",
+    "ValidationMiddleware",
+]

web3/middleware/attrdict.py

@@ -7,10 +7,6 @@ from typing import (
     cast,
 )
 
-from eth_utils.toolz import (
-    assoc,
-)
-
 from web3.datastructures import (
     AttributeDict,
 )
@@ -33,21 +29,18 @@ if TYPE_CHECKING:
 
 
 def _handle_async_response(response: "RPCResponse") -> "RPCResponse":
+    """
+    Process the RPC response by converting nested dictionaries into AttributeDict.
+    """
     if "result" in response:
-        return assoc(response, "result", AttributeDict.recursive(response["result"]))
+        response["result"] = AttributeDict.recursive(response["result"])
     elif "params" in response and "result" in response["params"]:
-        # this is a subscription response
-        return assoc(
-            response,
-            "params",
-            assoc(
-                response["params"],
-                "result",
-                AttributeDict.recursive(response["params"]["result"]),
-            ),
+        # subscription response
+        response["params"]["result"] = AttributeDict.recursive(
+            response["params"]["result"]
         )
-    else:
-        return response
+
+    return response
 
 
 class AttributeDictMiddleware(Web3Middleware, ABC):
@@ -60,11 +53,9 @@ class AttributeDictMiddleware(Web3Middleware, ABC):
 
     def response_processor(self, method: "RPCEndpoint", response: "RPCResponse") -> Any:
         if "result" in response:
-            return assoc(
-                response, "result", AttributeDict.recursive(response["result"])
-            )
-        else:
-            return response
+            new_result = AttributeDict.recursive(response["result"])
+            response = {**response, "result": new_result}
+        return response
 
     # -- async -- #
 
@@ -72,7 +63,6 @@ class AttributeDictMiddleware(Web3Middleware, ABC):
         self, method: "RPCEndpoint", response: "RPCResponse"
     ) -> Any:
         if self._w3.provider.has_persistent_connection:
-            # asynchronous response processing
             provider = cast("PersistentConnectionProvider", self._w3.provider)
             provider._request_processor.append_middleware_response_processor(
                 response, _handle_async_response

web3/middleware/base.py

@@ -4,6 +4,8 @@ from abc import (
 from typing import (
     TYPE_CHECKING,
     Any,
+    List,
+    Tuple,
     Type,
     Union,
 )
@@ -18,7 +20,9 @@ if TYPE_CHECKING:
         Web3,
     )
     from web3.types import (  # noqa: F401
+        AsyncMakeBatchRequestFn,
         AsyncMakeRequestFn,
+        MakeBatchRequestFn,
         MakeRequestFn,
         RPCEndpoint,
         RPCResponse,
@@ -36,6 +40,14 @@ class Web3Middleware:
     def __init__(self, w3: Union["AsyncWeb3", "Web3"]) -> None:
         self._w3 = w3
 
+    def __hash__(self) -> int:
+        return hash(f"{self.__class__.__name__}({str(self.__dict__)})")
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Web3Middleware):
+            return False
+        return self.__hash__() == other.__hash__()
+
     # -- sync -- #
 
     def wrap_make_request(self, make_request: "MakeRequestFn") -> "MakeRequestFn":
@@ -45,10 +57,31 @@ class Web3Middleware:
 
         return middleware
 
+    def wrap_make_batch_request(
+        self, make_batch_request: "MakeBatchRequestFn"
+    ) -> "MakeBatchRequestFn":
+        def middleware(
+            requests_info: List[Tuple["RPCEndpoint", Any]]
+        ) -> List["RPCResponse"]:
+            req_processed = [
+                self.request_processor(method, params)
+                for (method, params) in requests_info
+            ]
+            responses = make_batch_request(req_processed)
+            methods, _params = zip(*req_processed)
+            formatted_responses = [
+                self.response_processor(m, r) for m, r in zip(methods, responses)
+            ]
+            return formatted_responses
+
+        return middleware
+
     def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         return method, params
 
-    def response_processor(self, method: "RPCEndpoint", response: "RPCResponse") -> Any:
+    def response_processor(
+        self, method: "RPCEndpoint", response: "RPCResponse"
+    ) -> "RPCResponse":
         return response
 
     # -- async -- #
@@ -65,6 +98,26 @@ class Web3Middleware:
 
         return middleware
 
+    async def async_wrap_make_batch_request(
+        self, make_batch_request: "AsyncMakeBatchRequestFn"
+    ) -> "AsyncMakeBatchRequestFn":
+        async def middleware(
+            requests_info: List[Tuple["RPCEndpoint", Any]]
+        ) -> List["RPCResponse"]:
+            req_processed = [
+                await self.async_request_processor(method, params)
+                for (method, params) in requests_info
+            ]
+            responses = await make_batch_request(req_processed)
+            methods, _params = zip(*req_processed)
+            formatted_responses = [
+                await self.async_response_processor(m, r)
+                for m, r in zip(methods, responses)
+            ]
+            return formatted_responses
+
+        return middleware
+
     async def async_request_processor(
         self,
         method: "RPCEndpoint",
@@ -76,7 +129,7 @@ class Web3Middleware:
         self,
         method: "RPCEndpoint",
         response: "RPCResponse",
-    ) -> Any:
+    ) -> "RPCResponse":
         return response
 
 

web3/middleware/filter.py

@@ -42,6 +42,9 @@ from web3._utils.formatters import (
 from web3._utils.rpc_abi import (
     RPC,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3Middleware,
 )
@@ -71,7 +74,8 @@ else:
 
 
 def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, int]]:
-    """Creates a segment counting generator
+    """
+    Creates a segment counting generator
 
     The generator returns tuple pairs of integers
     that correspond to segments in the provided range.
@@ -84,6 +88,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
 
 
     Example:
+    -------
 
     >>> segment_counter = segment_count(start=0, stop=10, step=3)
     >>> next(segment_counter)
@@ -94,6 +99,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
     (6, 9)
     >>> next(segment_counter) #  Remainder is also returned
     (9, 10)
+
     """
     return gen_bounded_segments(start, stop, step)
 
@@ -104,10 +110,9 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
     if start + step >= stop:
         yield (start, stop)
         return
-    for segment in zip(
+    yield from zip(
         range(start, stop - step + 1, step), range(start + step, stop + 1, step)
-    ):
-        yield segment
+    )
 
     remainder = (stop - start) % step
     #  Handle the remainder
@@ -118,13 +123,14 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
 def block_ranges(
     start_block: BlockNumber, last_block: Optional[BlockNumber], step: int = 5
 ) -> Iterable[Tuple[BlockNumber, BlockNumber]]:
-    """Returns 2-tuple ranges describing ranges of block from start_block to last_block
+    """
+    Returns 2-tuple ranges describing ranges of block from start_block to last_block
 
     Ranges do not overlap to facilitate use as ``toBlock``, ``fromBlock``
     json-rpc arguments, which are both inclusive.
     """
     if last_block is not None and start_block > last_block:
-        raise TypeError(
+        raise Web3TypeError(
             "Incompatible start and stop arguments.",
             "Start must be less than or equal to stop.",
         )
@@ -138,7 +144,8 @@ def block_ranges(
 def iter_latest_block(
     w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> Iterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -160,8 +167,7 @@ def iter_latest_block(
 
     while True:
         latest_block = w3.eth.block_number
-        # type ignored b/c is_bounded_range prevents unsupported comparison
-        if is_bounded_range and latest_block > to_block:  # type: ignore
+        if is_bounded_range and latest_block > cast(BlockNumber, to_block):
             yield None
         #  No new blocks since last iteration.
         if _last is not None and _last == latest_block:
@@ -176,7 +182,8 @@ def iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> Iterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `fromBlock` to the latest mined block,
     until reaching toBlock. e.g.:
@@ -212,7 +219,8 @@ def get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> Iterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -247,9 +255,8 @@ class RequestLogs:
         if from_block is None or from_block == "latest":
             self._from_block = BlockNumber(w3.eth.block_number + 1)
         elif is_string(from_block) and is_hex(from_block):
-            self._from_block = BlockNumber(hex_to_integer(from_block))  # type: ignore
+            self._from_block = BlockNumber(hex_to_integer(cast(HexStr, from_block)))
         else:
-            # cast b/c LatestBlockParam is handled above
             self._from_block = from_block
         self._to_block = to_block
         self.filter_changes = self._get_filter_changes()
@@ -265,7 +272,7 @@ class RequestLogs:
         elif self._to_block == "latest":
             to_block = self.w3.eth.block_number
         elif is_string(self._to_block) and is_hex(self._to_block):
-            to_block = BlockNumber(hex_to_integer(self._to_block))  # type: ignore
+            to_block = BlockNumber(hex_to_integer(cast(HexStr, self._to_block)))
         else:
             to_block = self._to_block
 
@@ -352,7 +359,8 @@ def block_hashes_in_range(
 async def async_iter_latest_block(
     w3: "AsyncWeb3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> AsyncIterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -390,7 +398,8 @@ async def async_iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `from_block` to the latest mined block,
     until reaching to_block. e.g.:
@@ -423,7 +432,8 @@ async def async_get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> AsyncIterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -579,6 +589,10 @@ SyncFilter = Union[RequestLogs, RequestBlocks]
 AsyncFilter = Union[AsyncRequestLogs, AsyncRequestBlocks]
 
 
+def _simulate_rpc_response_with_result(filter_id: str) -> "RPCResponse":
+    return {"jsonrpc": "2.0", "id": -1, "result": filter_id}
+
+
 class LocalFilterMiddleware(Web3Middleware):
     def __init__(self, w3: Union["Web3", "AsyncWeb3"]):
         self.filters: Dict[str, SyncFilter] = {}
@@ -605,7 +619,7 @@ class LocalFilterMiddleware(Web3Middleware):
                     raise NotImplementedError(method)
 
                 self.filters[filter_id] = _filter
-                return {"result": filter_id}
+                return _simulate_rpc_response_with_result(filter_id)
 
             elif method in FILTER_CHANGES_METHODS:
                 _filter_id = params[0]
@@ -616,12 +630,16 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 _filter = self.filters[_filter_id]
                 if method == RPC.eth_getFilterChanges:
-                    return {"result": next(_filter.filter_changes)}
+                    return _simulate_rpc_response_with_result(
+                        next(_filter.filter_changes)  # type: ignore
+                    )
 
                 elif method == RPC.eth_getFilterLogs:
                     # type ignored b/c logic prevents RequestBlocks which
                     # doesn't implement get_logs
-                    return {"result": _filter.get_logs()}  # type: ignore
+                    return _simulate_rpc_response_with_result(
+                        _filter.get_logs()  # type: ignore
+                    )
                 else:
                     raise NotImplementedError(method)
             else:
@@ -653,7 +671,7 @@ class LocalFilterMiddleware(Web3Middleware):
                     raise NotImplementedError(method)
 
                 self.async_filters[filter_id] = _filter
-                return {"result": filter_id}
+                return _simulate_rpc_response_with_result(filter_id)
 
             elif method in FILTER_CHANGES_METHODS:
                 _filter_id = params[0]
@@ -664,12 +682,16 @@ class LocalFilterMiddleware(Web3Middleware):
 
                 _filter = self.async_filters[_filter_id]
                 if method == RPC.eth_getFilterChanges:
-                    return {"result": await _filter.filter_changes.__anext__()}
+                    return _simulate_rpc_response_with_result(
+                        await _filter.filter_changes.__anext__()  # type: ignore
+                    )
 
                 elif method == RPC.eth_getFilterLogs:
                     # type ignored b/c logic prevents RequestBlocks which
                     # doesn't implement get_logs
-                    return {"result": await _filter.get_logs()}  # type: ignore
+                    return _simulate_rpc_response_with_result(
+                        await _filter.get_logs()  # type: ignore
+                    )
                 else:
                     raise NotImplementedError(method)
             else:

web3/middleware/formatting.py

@@ -3,6 +3,7 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    Literal,
     Optional,
     Union,
     cast,
@@ -14,6 +15,9 @@ from eth_utils.toolz import (
     merge,
 )
 
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -21,7 +25,6 @@ from web3.types import (
     EthSubscriptionParams,
     Formatters,
     FormattersDict,
-    Literal,
     RPCEndpoint,
     RPCResponse,
 )
@@ -118,7 +121,7 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
         if (
             sync_formatters_builder is None and async_formatters_builder is not None
         ) or (sync_formatters_builder is not None and async_formatters_builder is None):
-            raise ValueError(
+            raise Web3ValueError(
                 "Must specify both sync_formatters_builder and async_formatters_builder"
             )
 
@@ -128,7 +131,7 @@ class FormattingMiddlewareBuilder(Web3MiddlewareBuilder):
                 or result_formatters is not None
                 or error_formatters is not None
             ):
-                raise ValueError(
+                raise Web3ValueError(
                     "Cannot specify formatters_builder and formatters at the same time"
                 )
 

web3/middleware/names.py

@@ -31,6 +31,9 @@ from .._utils.abi import (
 from .._utils.formatters import (
     recursive_map,
 )
+from ..exceptions import (
+    Web3TypeError,
+)
 from .base import (
     Web3Middleware,
 )
@@ -92,7 +95,7 @@ async def async_apply_ens_to_address_conversion(
         return (formatted_params_dict, *params[1:])
 
     else:
-        raise TypeError(
+        raise Web3TypeError(
             f"ABI definitions must be a list or dictionary, "
             f"got {abi_types_for_method!r}"
         )

web3/middleware/signing.py

@@ -19,6 +19,9 @@ from eth_account import (
 from eth_account.signers.local import (
     LocalAccount,
 )
+from eth_account.types import (
+    TransactionDictType as EthAccountTxParams,
+)
 from eth_keys.datatypes import (
     PrivateKey,
 )
@@ -55,6 +58,9 @@ from web3._utils.transactions import (
     fill_nonce,
     fill_transaction_defaults,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
 from web3.middleware.base import (
     Web3MiddlewareBuilder,
 )
@@ -108,7 +114,7 @@ def gen_normalized_accounts(
 
 @singledispatch
 def to_account(val: Any) -> LocalAccount:
-    raise TypeError(
+    raise Web3TypeError(
         "key must be one of the types: "
         "eth_keys.datatype.PrivateKey, eth_account.signers.local.LocalAccount, "
         "or raw private key as a hex string or byte string. "
@@ -132,7 +138,8 @@ to_account.register(bytes, private_key_to_account)
 
 
 def format_transaction(transaction: TxParams) -> TxParams:
-    """Format transaction so that it can be used correctly in the signing middleware.
+    """
+    Format transaction so that it can be used correctly in the signing middleware.
 
     Converts bytes to hex strings and other types that can be passed to
     the underlying layers. Also has the effect of normalizing 'from' for
@@ -178,11 +185,11 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
                 return method, params
             else:
                 account = self._accounts[to_checksum_address(tx_from)]
-                raw_tx = account.sign_transaction(filled_transaction).rawTransaction
+                raw_tx = account.sign_transaction(filled_transaction).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
-                    [raw_tx.hex()],
+                    [raw_tx.to_0x_hex()],
                 )
 
     # -- async -- #
@@ -207,9 +214,11 @@ class SignAndSendRawMiddlewareBuilder(Web3MiddlewareBuilder):
                 return method, params
             else:
                 account = self._accounts[to_checksum_address(tx_from)]
-                raw_tx = account.sign_transaction(filled_transaction).rawTransaction
+                raw_tx = account.sign_transaction(
+                    cast(EthAccountTxParams, filled_transaction)
+                ).raw_transaction
 
                 return (
                     RPCEndpoint("eth_sendRawTransaction"),
-                    [raw_tx.hex()],
+                    [raw_tx.to_0x_hex()],
                 )

web3/middleware/stalecheck.py

@@ -16,6 +16,7 @@ from toolz import (
 
 from web3.exceptions import (
     StaleBlockchain,
+    Web3ValueError,
 )
 from web3.middleware.base import (
     Web3Middleware,
@@ -54,7 +55,7 @@ class StalecheckMiddlewareBuilder(Web3MiddlewareBuilder):
         skip_stalecheck_for_methods: Collection[str] = SKIP_STALECHECK_FOR_METHODS,
     ) -> Web3Middleware:
         if allowable_delay <= 0:
-            raise ValueError(
+            raise Web3ValueError(
                 "You must set a positive allowable_delay in seconds for this middleware"
             )
         middleware = StalecheckMiddlewareBuilder(w3)