web3 7.0.0b4__py3-none-any.whl → 7.0.0b6__py3-none-any.whl

web3/_utils/batching.py

@@ -0,0 +1,217 @@
+from copy import (
+    copy,
+)
+from types import (
+    TracebackType,
+)
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generic,
+    List,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+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 (
+    TFunc,
+    TReturn,
+)
+
+if TYPE_CHECKING:
+    from web3 import (  # noqa: F401
+        AsyncWeb3,
+        Web3,
+    )
+    from web3.method import (  # noqa: F401
+        Method,
+    )
+    from web3.providers import (  # noqa: F401
+        PersistentConnectionProvider,
+    )
+    from web3.providers.async_base import (  # noqa: F401
+        AsyncJSONBaseProvider,
+    )
+    from web3.providers.base import (  # noqa: F401
+        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]]
+RPC_METHODS_UNSUPPORTED_DURING_BATCH = {
+    "eth_subscribe",
+    "eth_unsubscribe",
+    "eth_sendRawTransaction",
+    "eth_sendTransaction",
+    "eth_signTransaction",
+    "eth_sign",
+    "eth_signTypedData",
+}
+
+
+class RequestBatcher(Generic[TFunc]):
+    def __init__(self, web3: Union["AsyncWeb3", "Web3"]) -> None:
+        self.web3 = web3
+        self._requests_info: List[BatchRequestInformation] = []
+        self._async_requests_info: List[
+            Coroutine[Any, Any, BatchRequestInformation]
+        ] = []
+        self._initialize_batching()
+
+    @property
+    def _provider(self) -> Union["JSONBaseProvider", "AsyncJSONBaseProvider"]:
+        return (
+            cast("AsyncJSONBaseProvider", self.web3.provider)
+            if self.web3.provider.is_async
+            else cast("JSONBaseProvider", self.web3.provider)
+        )
+
+    def _validate_is_batching(self) -> None:
+        if not self._provider._is_batching:
+            raise Web3ValueError(
+                "Batch has already been executed or cancelled. Create a new batch to "
+                "issue batched requests."
+            )
+
+    def _initialize_batching(self) -> None:
+        self._provider._is_batching = True
+        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
+
+    def add(self, batch_payload: TReturn) -> None:
+        self._validate_is_batching()
+
+        if isinstance(batch_payload, (ContractFunction, AsyncContractFunction)):
+            batch_payload = batch_payload.call()  # type: ignore
+
+        # 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
+        # apparent "request" into the BatchRequestInformation type.
+        if self._provider.is_async:
+            self._async_requests_info.append(
+                cast(Coroutine[Any, Any, BatchRequestInformation], batch_payload)
+            )
+        else:
+            self._requests_info.append(cast(BatchRequestInformation, batch_payload))
+
+    def add_mapping(
+        self,
+        batch_payload: Dict[
+            Union[
+                "Method[Callable[..., Any]]",
+                Callable[..., Any],
+                ContractFunction,
+                AsyncContractFunction,
+            ],
+            List[Any],
+        ],
+    ) -> None:
+        self._validate_is_batching()
+        for method, params in batch_payload.items():
+            for param in params:
+                self.add(method(param))
+
+    def execute(self) -> List["RPCResponse"]:
+        self._validate_is_batching()
+        responses = self.web3.manager._make_batch_request(self._requests_info)
+        self._end_batching()
+        return responses
+
+    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()
+
+    # -- context manager -- #
+
+    def __enter__(self) -> Self:
+        self._initialize_batching()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._end_batching()
+
+    # -- async -- #
+
+    async def async_execute(self) -> List["RPCResponse"]:
+        self._validate_is_batching()
+        responses = await self.web3.manager._async_make_batch_request(
+            self._async_requests_info
+        )
+        self._end_batching()
+        return responses
+
+    # -- async context manager -- #
+
+    async def __aenter__(self) -> Self:
+        self._initialize_batching()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Type[BaseException],
+        exc_val: BaseException,
+        exc_tb: TracebackType,
+    ) -> None:
+        self._end_batching()
+
+
+def sort_batch_response_by_response_ids(
+    responses: List["RPCResponse"],
+) -> List["RPCResponse"]:
+    if all(response.get("id") is not None for response in responses):
+        # If all responses have an `id`, sort them by `id, since the JSON-RPC 2.0 spec
+        # doesn't guarantee order.
+        return sorted(responses, key=lambda response: response["id"])
+    else:
+        # If any response is missing an `id`, which should only happen on particular
+        # errors, return them in the order they were received and hope that the
+        # provider is returning them in order. Issue a warning.
+        warnings.warn(
+            "Received batch response with missing `id` for one or more responses. "
+            "Relying on provider to return these responses in order.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        return responses

web3/_utils/caching.py

@@ -6,10 +6,13 @@ from typing import (
     Any,
     Callable,
     Coroutine,
+    Dict,
     List,
+    Set,
     Tuple,
     TypeVar,
     Union,
+    cast,
 )
 
 from eth_utils import (
@@ -69,7 +72,11 @@ class RequestInformation:
         self,
         method: "RPCEndpoint",
         params: Any,
-        response_formatters: Tuple[Callable[..., Any], ...],
+        response_formatters: Tuple[
+            Union[Dict[str, Callable[..., Any]], Callable[..., Any]],
+            Callable[..., Any],
+            Callable[..., Any],
+        ],
         subscription_id: str = None,
     ):
         self.method = method
@@ -87,7 +94,24 @@ def is_cacheable_request(
     return False
 
 
-# -- request caching decorators -- #
+# -- request caching -- #
+
+
+CACHEABLE_REQUESTS = cast(
+    Set["RPCEndpoint"],
+    (
+        "eth_chainId",
+        "eth_getBlockByHash",
+        "eth_getBlockTransactionCountByHash",
+        "eth_getRawTransactionByHash",
+        "eth_getTransactionByBlockHashAndIndex",
+        "eth_getTransactionByHash",
+        "eth_getUncleByBlockHashAndIndex",
+        "eth_getUncleCountByBlockHash",
+        "net_version",
+        "web3_clientVersion",
+    ),
+)
 
 
 def _should_cache_response(response: "RPCResponse") -> bool:

web3/_utils/compat/__init__.py

@@ -11,4 +11,5 @@
 from typing_extensions import (
     NotRequired,  # py311
     Self,  # py311
+    Unpack,  # py311
 )

web3/_utils/contracts.py

@@ -75,7 +75,7 @@ from web3._utils.normalizers import (
     abi_string_to_text,
 )
 from web3.exceptions import (
-    BlockNumberOutofRange,
+    BlockNumberOutOfRange,
     Web3TypeError,
     Web3ValidationError,
     Web3ValueError,
@@ -424,7 +424,7 @@ def parse_block_identifier(
     ):
         return w3.eth.get_block(block_identifier)["number"]
     else:
-        raise BlockNumberOutofRange
+        raise BlockNumberOutOfRange
 
 
 def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNumber:
@@ -434,7 +434,7 @@ def parse_block_identifier_int(w3: "Web3", block_identifier_int: int) -> BlockNu
         last_block = w3.eth.get_block("latest")["number"]
         block_num = last_block + block_identifier_int + 1
         if block_num < 0:
-            raise BlockNumberOutofRange
+            raise BlockNumberOutOfRange
     return BlockNumber(block_num)
 
 
@@ -453,7 +453,7 @@ async def async_parse_block_identifier(
         requested_block = await async_w3.eth.get_block(block_identifier)
         return requested_block["number"]
     else:
-        raise BlockNumberOutofRange
+        raise BlockNumberOutOfRange
 
 
 async def async_parse_block_identifier_int(
@@ -466,5 +466,5 @@ async def async_parse_block_identifier_int(
         last_block_num = last_block["number"]
         block_num = last_block_num + block_identifier_int + 1
         if block_num < 0:
-            raise BlockNumberOutofRange
+            raise BlockNumberOutOfRange
     return BlockNumber(block_num)

web3/_utils/events.py

@@ -340,8 +340,8 @@ is_not_indexed = complement(is_indexed)
 
 class BaseEventFilterBuilder:
     formatter = None
-    _fromBlock = None
-    _toBlock = None
+    _from_block = None
+    _to_block = None
     _address = None
     _immutable = False
 
@@ -361,30 +361,30 @@ class BaseEventFilterBuilder:
         self._ordered_arg_names = tuple(arg["name"] for arg in event_abi["inputs"])
 
     @property
-    def fromBlock(self) -> BlockIdentifier:
-        return self._fromBlock
+    def from_block(self) -> BlockIdentifier:
+        return self._from_block
 
-    @fromBlock.setter
-    def fromBlock(self, value: BlockIdentifier) -> None:
-        if self._fromBlock is None and not self._immutable:
-            self._fromBlock = value
+    @from_block.setter
+    def from_block(self, value: BlockIdentifier) -> None:
+        if self._from_block is None and not self._immutable:
+            self._from_block = value
         else:
             raise Web3ValueError(
-                f"fromBlock is already set to {self._fromBlock!r}. "
+                f"from_block is already set to {self._from_block!r}. "
                 "Resetting filter parameters is not permitted"
             )
 
     @property
-    def toBlock(self) -> BlockIdentifier:
-        return self._toBlock
+    def to_block(self) -> BlockIdentifier:
+        return self._to_block
 
-    @toBlock.setter
-    def toBlock(self, value: BlockIdentifier) -> None:
-        if self._toBlock is None and not self._immutable:
-            self._toBlock = value
+    @to_block.setter
+    def to_block(self, value: BlockIdentifier) -> None:
+        if self._to_block is None and not self._immutable:
+            self._to_block = value
         else:
             raise Web3ValueError(
-                f"toBlock is already set to {self._toBlock!r}. "
+                f"toBlock is already set to {self._to_block!r}. "
                 "Resetting filter parameters is not permitted"
             )
 
@@ -432,8 +432,8 @@ class BaseEventFilterBuilder:
     def filter_params(self) -> FilterParams:
         params = {
             "topics": self.topics,
-            "fromBlock": self.fromBlock,
-            "toBlock": self.toBlock,
+            "fromBlock": self.from_block,
+            "toBlock": self.to_block,
             "address": self.address,
         }
         return valfilter(lambda x: x is not None, params)
@@ -444,8 +444,8 @@ class EventFilterBuilder(BaseEventFilterBuilder):
         if not isinstance(w3, web3.Web3):
             raise Web3ValueError(f"Invalid web3 argument: got: {w3!r}")
 
-        for arg in AttributeDict.values(self.args):
-            arg._immutable = True  # type: ignore[attr-defined]
+        for arg in self.args.values():
+            arg._immutable = True
         self._immutable = True
 
         log_filter = cast("LogFilter", w3.eth.filter(self.filter_params))

web3/_utils/filters.py

@@ -73,8 +73,8 @@ def construct_event_filter_params(
     contract_address: Optional[ChecksumAddress] = None,
     argument_filters: Optional[Dict[str, Any]] = None,
     topics: Optional[Sequence[HexStr]] = None,
-    fromBlock: Optional[BlockIdentifier] = None,
-    toBlock: Optional[BlockIdentifier] = None,
+    from_block: Optional[BlockIdentifier] = None,
+    to_block: Optional[BlockIdentifier] = None,
     address: Optional[ChecksumAddress] = None,
 ) -> Tuple[List[List[Optional[HexStr]]], FilterParams]:
     filter_params: FilterParams = {}
@@ -121,11 +121,11 @@ def construct_event_filter_params(
     else:
         validate_address(filter_params["address"])
 
-    if fromBlock is not None:
-        filter_params["fromBlock"] = fromBlock
+    if from_block is not None:
+        filter_params["fromBlock"] = from_block
 
-    if toBlock is not None:
-        filter_params["toBlock"] = toBlock
+    if to_block is not None:
+        filter_params["toBlock"] = to_block
 
     data_filters_set = construct_event_data_set(event_abi, abi_codec, argument_filters)
 

web3/_utils/method_formatters.py

@@ -32,8 +32,6 @@ from eth_utils.curried import (
     is_integer,
     is_null,
     is_string,
-    remove_0x_prefix,
-    text_if_str,
     to_checksum_address,
     to_list,
     to_tuple,
@@ -52,10 +50,6 @@ from hexbytes import (
 from web3._utils.abi import (
     is_length,
 )
-from web3._utils.encoding import (
-    hexstr_if_str,
-    to_hex,
-)
 from web3._utils.error_formatters_utils import (
     raise_contract_logic_error_on_revert,
     raise_transaction_indexing_error_if_indexing,
@@ -583,16 +577,6 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_sendTransaction: apply_formatter_at_index(transaction_param_formatter, 0),
     RPC.eth_signTransaction: apply_formatter_at_index(transaction_param_formatter, 0),
     RPC.eth_getProof: apply_formatter_at_index(to_hex_if_integer, 2),
-    # personal
-    RPC.personal_importRawKey: apply_formatter_at_index(
-        compose(remove_0x_prefix, hexstr_if_str(to_hex)),
-        0,
-    ),
-    RPC.personal_sign: apply_formatter_at_index(text_if_str(to_hex), 0),
-    RPC.personal_ecRecover: apply_formatter_at_index(text_if_str(to_hex), 0),
-    RPC.personal_sendTransaction: apply_formatter_at_index(
-        transaction_param_formatter, 0
-    ),
     # Snapshot and Revert
     RPC.evm_revert: apply_formatter_at_index(integer_to_hex, 0),
     # tracing
@@ -788,13 +772,6 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_signTransaction: apply_formatter_if(is_not_null, signed_tx_formatter),
     RPC.eth_signTypedData: HexBytes,
     RPC.eth_syncing: apply_formatter_if(is_not_false, syncing_formatter),
-    # personal
-    RPC.personal_importRawKey: to_checksum_address,
-    RPC.personal_listAccounts: apply_list_to_array_formatter(to_checksum_address),
-    RPC.personal_listWallets: apply_list_to_array_formatter(geth_wallets_formatter),
-    RPC.personal_newAccount: to_checksum_address,
-    RPC.personal_sendTransaction: to_hexbytes(32),
-    RPC.personal_signTypedData: HexBytes,
     # Transaction Pool
     RPC.txpool_content: transaction_pool_content_formatter,
     RPC.txpool_inspect: transaction_pool_inspect_formatter,

web3/_utils/module_testing/__init__.py

@@ -5,9 +5,6 @@ from .eth_module import (
 from .go_ethereum_admin_module import (
     GoEthereumAdminModuleTest,
 )
-from .go_ethereum_personal_module import (
-    GoEthereumPersonalModuleTest,
-)
 from .go_ethereum_txpool_module import (
     GoEthereumAsyncTxPoolModuleTest,
     GoEthereumTxPoolModuleTest,