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

web3/_utils/async_transactions.py

@@ -1,6 +1,8 @@
 from typing import (
     TYPE_CHECKING,
+    Dict,
     Optional,
+    Union,
     cast,
 )
 
@@ -24,6 +26,9 @@ from web3._utils.utility_methods import (
 from web3.constants import (
     DYNAMIC_FEE_TXN_PARAMS,
 )
+from web3.exceptions import (
+    Web3ValueError,
+)
 from web3.types import (
     BlockIdentifier,
     TxData,
@@ -39,21 +44,32 @@ if TYPE_CHECKING:
     )
 
 
-async def _estimate_gas(async_w3: "AsyncWeb3", tx: TxParams) -> int:
+# unused vars present in these funcs because they all need to have the same signature
+async def _estimate_gas(
+    async_w3: "AsyncWeb3", tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+) -> int:
     return await async_w3.eth.estimate_gas(tx)
 
 
-async def _max_fee_per_gas(async_w3: "AsyncWeb3", _tx: TxParams) -> Wei:
+async def _max_fee_per_gas(
+    async_w3: "AsyncWeb3", tx: TxParams, defaults: Dict[str, Union[bytes, int]]
+) -> Wei:
     block = await async_w3.eth.get_block("latest")
-    max_priority_fee = await async_w3.eth.max_priority_fee
-    return Wei(max_priority_fee + (2 * block["baseFeePerGas"]))
+    max_priority_fee = tx.get(
+        "maxPriorityFeePerGas", defaults.get("maxPriorityFeePerGas")
+    )
+    return Wei(int(max_priority_fee) + (2 * int(block["baseFeePerGas"])))
 
 
-async def _max_priority_fee_gas(async_w3: "AsyncWeb3", _tx: TxParams) -> Wei:
+async def _max_priority_fee_gas(
+    async_w3: "AsyncWeb3", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+) -> Wei:
     return await async_w3.eth.max_priority_fee
 
 
-async def _chain_id(async_w3: "AsyncWeb3", _tx: TxParams) -> int:
+async def _chain_id(
+    async_w3: "AsyncWeb3", _tx: TxParams, _defaults: Dict[str, Union[bytes, int]]
+) -> int:
     return await async_w3.eth.chain_id
 
 
@@ -61,9 +77,9 @@ TRANSACTION_DEFAULTS = {
     "value": 0,
     "data": b"",
     "gas": _estimate_gas,
-    "gasPrice": lambda async_w3, tx: async_w3.eth.generate_gas_price(tx),
-    "maxFeePerGas": _max_fee_per_gas,
+    "gasPrice": lambda async_w3, tx, _defaults: async_w3.eth.generate_gas_price(tx),
     "maxPriorityFeePerGas": _max_priority_fee_gas,
+    "maxFeePerGas": _max_fee_per_gas,
     "chainId": _chain_id,
 }
 
@@ -71,9 +87,7 @@ TRANSACTION_DEFAULTS = {
 async def get_block_gas_limit(
     web3_eth: "AsyncEth", block_identifier: Optional[BlockIdentifier] = None
 ) -> int:
-    if block_identifier is None:
-        block_identifier = await web3_eth.block_number
-    block = await web3_eth.get_block(block_identifier)
+    block = await web3_eth.get_block(block_identifier or "latest")
     return block["gasLimit"]
 
 
@@ -87,9 +101,9 @@ async def get_buffered_gas_estimate(
     gas_limit = await get_block_gas_limit(async_w3.eth)
 
     if gas_estimate > gas_limit:
-        raise ValueError(
-            "Contract does not appear to be deployable within the "
-            f"current network gas limits.  Estimated: {gas_estimate}. "
+        raise Web3ValueError(
+            "Gas estimate for transaction is higher than current network gas limits. "
+            f"Transaction could not be sent. Estimated: {gas_estimate}. "
             f"Current gas limit: {gas_limit}"
         )
 
@@ -110,7 +124,7 @@ async def async_fill_transaction_defaults(
     async_w3: "AsyncWeb3", transaction: TxParams
 ) -> TxParams:
     """
-    if async_w3 is None, fill as much as possible while offline
+    If async_w3 is None, fill as much as possible while offline
     """
     strategy_based_gas_price = async_w3.eth.generate_gas_price(transaction)
 
@@ -119,7 +133,7 @@ async def async_fill_transaction_defaults(
         or any_in_dict(DYNAMIC_FEE_TXN_PARAMS, transaction)
     )
 
-    defaults = {}
+    defaults: Dict[str, Union[bytes, int]] = {}
     for key, default_getter in TRANSACTION_DEFAULTS.items():
         if key not in transaction:
             if (
@@ -134,15 +148,15 @@ async def async_fill_transaction_defaults(
 
             if callable(default_getter):
                 if async_w3 is None:
-                    raise ValueError(
+                    raise Web3ValueError(
                         f"You must specify a '{key}' value in the transaction"
                     )
                 if key == "gasPrice":
                     # `generate_gas_price()` is on the `BaseEth` class and does not
                     # need to be awaited
-                    default_val = default_getter(async_w3, transaction)
+                    default_val = default_getter(async_w3, transaction, defaults)
                 else:
-                    default_val = await default_getter(async_w3, transaction)
+                    default_val = await default_getter(async_w3, transaction, defaults)
             else:
                 default_val = default_getter
 
@@ -155,7 +169,7 @@ async def async_get_required_transaction(
 ) -> TxData:
     current_transaction = await async_w3.eth.get_transaction(transaction_hash)
     if not current_transaction:
-        raise ValueError(
+        raise Web3ValueError(
             f"Supplied transaction with hash {transaction_hash!r} does not exist"
         )
     return current_transaction

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/blocks.py

@@ -15,6 +15,10 @@ from eth_utils.toolz import (
     curry,
 )
 
+from web3.exceptions import (
+    Web3TypeError,
+    Web3ValueError,
+)
 from web3.types import (
     RPCEndpoint,
 )
@@ -32,7 +36,7 @@ def is_predefined_block_number(value: Any) -> bool:
     elif is_integer(value):
         return False
     else:
-        raise TypeError(f"unrecognized block reference: {value!r}")
+        raise Web3TypeError(f"unrecognized block reference: {value!r}")
 
     return value_text in {"latest", "pending", "earliest", "safe", "finalized"}
 
@@ -70,6 +74,6 @@ def select_method_for_block_identifier(
     elif is_hex_encoded_block_number(value):
         return if_number
     else:
-        raise ValueError(
+        raise Web3ValueError(
             f"Value did not match any of the recognized block identifiers: {value}"
         )

web3/_utils/caching/__init__.py

@@ -0,0 +1,12 @@
+from .request_caching_validation import (
+    ASYNC_PROVIDER_TYPE,
+    SYNC_PROVIDER_TYPE,
+)
+from .caching_utils import (
+    CACHEABLE_REQUESTS,
+    async_handle_request_caching,
+    generate_cache_key,
+    handle_request_caching,
+    is_cacheable_request,
+    RequestInformation,
+)