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

web3/contract/base_contract.py

@@ -204,9 +204,9 @@ class BaseContractEvent:
         self,
         abi: ABIEvent,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
-        blockHash: Optional[HexBytes] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
+        block_hash: Optional[HexBytes] = None,
     ) -> FilterParams:
         if not self.address:
             raise Web3TypeError(
@@ -219,11 +219,12 @@ class BaseContractEvent:
 
         _filters = dict(**argument_filters)
 
-        blkhash_set = blockHash is not None
-        blknum_set = fromBlock is not None or toBlock is not None
+        blkhash_set = block_hash is not None
+        blknum_set = from_block is not None or to_block is not None
         if blkhash_set and blknum_set:
             raise Web3ValidationError(
-                "blockHash cannot be set at the same time as fromBlock or toBlock"
+                "`block_hash` cannot be set at the same time as "
+                "`from_block` or `to_block`"
             )
 
         # Construct JSON-RPC raw filter presentation based on human readable
@@ -233,13 +234,13 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=self.address,
         )
 
-        if blockHash is not None:
-            event_filter_params["blockHash"] = blockHash
+        if block_hash is not None:
+            event_filter_params["blockHash"] = block_hash
 
         return event_filter_params
 
@@ -319,15 +320,15 @@ class BaseContractEvent:
     def _set_up_filter_builder(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
         filter_builder: Union[EventFilterBuilder, AsyncEventFilterBuilder] = None,
     ) -> None:
-        if fromBlock is None:
+        if from_block is None:
             raise Web3TypeError(
-                "Missing mandatory keyword argument to create_filter: fromBlock"
+                "Missing mandatory keyword argument to create_filter: `from_block`"
             )
 
         if argument_filters is None:
@@ -344,8 +345,8 @@ class BaseContractEvent:
             self.w3.codec,
             contract_address=self.address,
             argument_filters=_filters,
-            fromBlock=fromBlock,
-            toBlock=toBlock,
+            from_block=from_block,
+            to_block=to_block,
             address=address,
             topics=topics,
         )
@@ -353,8 +354,8 @@ class BaseContractEvent:
         filter_builder.address = cast(
             ChecksumAddress, event_filter_params.get("address")
         )
-        filter_builder.fromBlock = event_filter_params.get("fromBlock")
-        filter_builder.toBlock = event_filter_params.get("toBlock")
+        filter_builder.from_block = event_filter_params.get("fromBlock")
+        filter_builder.to_block = event_filter_params.get("toBlock")
         match_any_vals = {
             arg: value
             for arg, value in _filters.items()

web3/contract/contract.py

@@ -110,8 +110,8 @@ class ContractEvent(BaseContractEvent):
     def get_logs(
         self,
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: Optional[BlockIdentifier] = None,
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: Optional[BlockIdentifier] = None,
         block_hash: Optional[HexBytes] = None,
     ) -> Iterable[EventData]:
         """
@@ -131,10 +131,10 @@ class ContractEvent(BaseContractEvent):
 
         .. code-block:: python
 
-            from = max(mycontract.web3.eth.block_number - 10, 1)
-            to = mycontract.web3.eth.block_number
+            from = max(my_contract.web3.eth.block_number - 10, 1)
+            to = my_contract.web3.eth.block_number
 
-            events = mycontract.events.Transfer.get_logs(fromBlock=from, toBlock=to)
+            events = my_contract.events.Transfer.get_logs(from_block=from, to_block=to)
 
             for e in events:
                 print(e["args"]["from"],
@@ -164,10 +164,10 @@ class ContractEvent(BaseContractEvent):
 
         :param argument_filters: Filter by argument values. Indexed arguments are
           filtered by the node while non-indexed arguments are filtered by the library.
-        :param fromBlock: block number or "latest", defaults to "latest"
-        :param toBlock: block number or "latest". Defaults to "latest"
+        :param from_block: block number or "latest", defaults to "latest"
+        :param to_block: block number or "latest". Defaults to "latest"
         :param block_hash: block hash. block_hash cannot be set at the
-          same time as fromBlock or toBlock
+          same time as ``from_block`` or ``to_block``
         :yield: Tuple of :class:`AttributeDict` instances
         """
         event_abi = self._get_event_abi()
@@ -182,7 +182,7 @@ class ContractEvent(BaseContractEvent):
                 )
 
         _filter_params = self._get_event_filter_params(
-            event_abi, argument_filters, fromBlock, toBlock, block_hash
+            event_abi, argument_filters, from_block, to_block, block_hash
         )
         # call JSON-RPC API
         logs = self.w3.eth.get_logs(_filter_params)
@@ -205,8 +205,8 @@ class ContractEvent(BaseContractEvent):
         self,
         *,  # PEP 3102
         argument_filters: Optional[Dict[str, Any]] = None,
-        fromBlock: Optional[BlockIdentifier] = None,
-        toBlock: BlockIdentifier = "latest",
+        from_block: Optional[BlockIdentifier] = None,
+        to_block: BlockIdentifier = "latest",
         address: Optional[ChecksumAddress] = None,
         topics: Optional[Sequence[Any]] = None,
     ) -> LogFilter:
@@ -216,8 +216,8 @@ class ContractEvent(BaseContractEvent):
         filter_builder = EventFilterBuilder(self._get_event_abi(), self.w3.codec)
         self._set_up_filter_builder(
             argument_filters,
-            fromBlock,
-            toBlock,
+            from_block,
+            to_block,
             address,
             topics,
             filter_builder,

web3/contract/utils.py

@@ -9,6 +9,7 @@ from typing import (
     Tuple,
     Type,
     Union,
+    cast,
 )
 
 from eth_abi.exceptions import (
@@ -16,6 +17,11 @@ from eth_abi.exceptions import (
 )
 from eth_typing import (
     ChecksumAddress,
+    TypeStr,
+)
+from eth_utils.toolz import (
+    compose,
+    curry,
 )
 from hexbytes import (
     HexBytes,
@@ -60,10 +66,50 @@ if TYPE_CHECKING:
         AsyncWeb3,
         Web3,
     )
+    from web3.providers.persistent import (  # noqa: F401
+        PersistentConnectionProvider,
+    )
 
 ACCEPTABLE_EMPTY_STRINGS = ["0x", b"0x", "", b""]
 
 
+@curry
+def format_contract_call_return_data_curried(
+    async_w3: Union["AsyncWeb3", "Web3"],
+    decode_tuples: bool,
+    fn_abi: ABIFunction,
+    function_identifier: FunctionIdentifier,
+    normalizers: Tuple[Callable[..., Any], ...],
+    output_types: Sequence[TypeStr],
+    return_data: Any,
+) -> Any:
+    """
+    Helper function for formatting contract call return data for batch requests. Curry
+    with all arguments except `return_data` and process `return_data` once it is
+    available.
+    """
+    try:
+        output_data = async_w3.codec.decode(output_types, return_data)
+    except DecodingError as e:
+        msg = (
+            f"Could not decode contract function call to {function_identifier} "
+            f"with return data: {str(return_data)}, output_types: {output_types}"
+        )
+        raise BadFunctionCallOutput(msg) from e
+
+    _normalizers = itertools.chain(
+        BASE_RETURN_NORMALIZERS,
+        normalizers,
+    )
+    normalized_data = map_abi_data(_normalizers, output_types, output_data)
+
+    if decode_tuples:
+        decoded = named_tree(fn_abi["outputs"], normalized_data)
+        normalized_data = recursive_dict_to_namedtuple(decoded)
+
+    return normalized_data[0] if len(normalized_data) == 1 else normalized_data
+
+
 def call_contract_function(
     w3: "Web3",
     address: ChecksumAddress,
@@ -108,6 +154,34 @@ def call_contract_function(
 
     output_types = get_abi_output_types(fn_abi)
 
+    provider = w3.provider
+    if hasattr(provider, "_is_batching") and provider._is_batching:
+        # request_information == ((method, params), response_formatters)
+        request_information = tuple(return_data)
+        method_and_params = request_information[0]
+
+        # append return data formatting to result formatters
+        current_response_formatters = request_information[1]
+        current_result_formatters = current_response_formatters[0]
+        updated_result_formatters = compose(
+            # contract call return data formatter
+            format_contract_call_return_data_curried(
+                w3,
+                decode_tuples,
+                fn_abi,
+                function_identifier,
+                normalizers,
+                output_types,
+            ),
+            current_result_formatters,
+        )
+        response_formatters = (
+            updated_result_formatters,  # result formatters
+            current_response_formatters[1],  # error formatters
+            current_response_formatters[2],  # null result formatters
+        )
+        return (method_and_params, response_formatters)
+
     try:
         output_data = w3.codec.decode(output_types, return_data)
     except DecodingError as e:
@@ -319,6 +393,43 @@ async def async_call_contract_function(
 
     output_types = get_abi_output_types(fn_abi)
 
+    if async_w3.provider._is_batching:
+        contract_call_return_data_formatter = format_contract_call_return_data_curried(
+            async_w3,
+            decode_tuples,
+            fn_abi,
+            function_identifier,
+            normalizers,
+            output_types,
+        )
+        if async_w3.provider.has_persistent_connection:
+            # get the current request id
+            provider = cast("PersistentConnectionProvider", async_w3.provider)
+            current_request_id = provider._batch_request_counter - 1
+            provider._request_processor.append_result_formatter_for_request(
+                current_request_id, contract_call_return_data_formatter
+            )
+        else:
+            # request_information == ((method, params), response_formatters)
+            request_information = tuple(return_data)
+            method_and_params = request_information[0]
+
+            # append return data formatter to result formatters
+            current_response_formatters = request_information[1]
+            current_result_formatters = current_response_formatters[0]
+            updated_result_formatters = compose(
+                contract_call_return_data_formatter,
+                current_result_formatters,
+            )
+            response_formatters = (
+                updated_result_formatters,  # result formatters
+                current_response_formatters[1],  # error formatters
+                current_response_formatters[2],  # null result formatters
+            )
+            return (method_and_params, response_formatters)
+
+        return return_data
+
     try:
         output_data = async_w3.codec.decode(output_types, return_data)
     except DecodingError as e:
@@ -350,10 +461,7 @@ async def async_call_contract_function(
         decoded = named_tree(fn_abi["outputs"], normalized_data)
         normalized_data = recursive_dict_to_namedtuple(decoded)
 
-    if len(normalized_data) == 1:
-        return normalized_data[0]
-    else:
-        return normalized_data
+    return normalized_data[0] if len(normalized_data) == 1 else normalized_data
 
 
 async def async_transact_with_contract_function(

web3/eth/async_eth.py

@@ -35,6 +35,9 @@ from web3._utils.async_transactions import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     async_fee_history_priority_fee,
 )
@@ -57,12 +60,13 @@ from web3.eth.base_eth import (
     BaseEth,
 )
 from web3.exceptions import (
-    MethodUnavailable,
+    MethodNotSupported,
     OffchainLookup,
     TimeExhausted,
     TooManyRequests,
     TransactionIndexingInProgress,
     TransactionNotFound,
+    Web3RPCError,
     Web3ValueError,
 )
 from web3.method import (
@@ -194,7 +198,7 @@ class AsyncEth(BaseEth):
         """
         try:
             return await self._max_priority_fee()
-        except (ValueError, MethodUnavailable):
+        except Web3RPCError:
             warnings.warn(
                 "There was an issue with the method eth_maxPriorityFeePerGas. "
                 "Calculating using eth_feeHistory.",
@@ -593,10 +597,8 @@ class AsyncEth(BaseEth):
             self.w3, current_transaction, new_transaction
         )
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     async def modify_transaction(
-        self, transaction_hash: _Hash32, **transaction_params: Any
+        self, transaction_hash: _Hash32, **transaction_params: Unpack[TxParams]
     ) -> HexBytes:
         assert_valid_transaction_params(cast(TxParams, transaction_params))
 
@@ -736,7 +738,7 @@ class AsyncEth(BaseEth):
         ] = None,
     ) -> HexStr:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_subscribe is only supported with providers that support "
                 "persistent connections."
             )
@@ -753,7 +755,7 @@ class AsyncEth(BaseEth):
 
     async def unsubscribe(self, subscription_id: HexStr) -> bool:
         if not isinstance(self.w3.provider, PersistentConnectionProvider):
-            raise MethodUnavailable(
+            raise MethodNotSupported(
                 "eth_unsubscribe is only supported with providers that support "
                 "persistent connections."
             )
@@ -764,7 +766,7 @@ class AsyncEth(BaseEth):
 
     @overload
     # mypy error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
-    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[misc]  # noqa: E501
+    def contract(self, address: None = None, **kwargs: Any) -> Type[AsyncContract]:  # type: ignore[overload-overlap]  # noqa: E501
         ...
 
     @overload

web3/eth/eth.py

@@ -30,6 +30,9 @@ from hexbytes import (
 from web3._utils.blocks import (
     select_method_for_block_identifier,
 )
+from web3._utils.compat import (
+    Unpack,
+)
 from web3._utils.fee_utils import (
     fee_history_priority_fee,
 )
@@ -57,12 +60,12 @@ from web3.eth.base_eth import (
     BaseEth,
 )
 from web3.exceptions import (
-    MethodUnavailable,
     OffchainLookup,
     TimeExhausted,
     TooManyRequests,
     TransactionIndexingInProgress,
     TransactionNotFound,
+    Web3RPCError,
     Web3ValueError,
 )
 from web3.method import (
@@ -187,7 +190,7 @@ class Eth(BaseEth):
         """
         try:
             return self._max_priority_fee()
-        except (ValueError, MethodUnavailable):
+        except Web3RPCError:
             warnings.warn(
                 "There was an issue with the method eth_maxPriorityFeePerGas. "
                 "Calculating using eth_feeHistory.",
@@ -596,10 +599,8 @@ class Eth(BaseEth):
         current_transaction = get_required_transaction(self.w3, transaction_hash)
         return replace_transaction(self.w3, current_transaction, new_transaction)
 
-    # todo: Update Any to stricter kwarg checking with TxParams
-    # https://github.com/python/mypy/issues/4441
     def modify_transaction(
-        self, transaction_hash: _Hash32, **transaction_params: Any
+        self, transaction_hash: _Hash32, **transaction_params: Unpack[TxParams]
     ) -> HexBytes:
         assert_valid_transaction_params(cast(TxParams, transaction_params))
         current_transaction = get_required_transaction(self.w3, transaction_hash)
@@ -680,7 +681,7 @@ class Eth(BaseEth):
 
     @overload
     # type error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
-    def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:  # type: ignore[misc]  # noqa: E501
+    def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:  # type: ignore[overload-overlap]  # noqa: E501
         ...
 
     @overload

web3/exceptions.py

@@ -1,6 +1,7 @@
 import datetime
 import time
 from typing import (
+    TYPE_CHECKING,
     Any,
     Dict,
     Optional,
@@ -13,8 +14,12 @@ from eth_utils import (
 
 from web3.types import (
     BlockData,
+    RPCResponse,
 )
 
+if TYPE_CHECKING:
+    import asyncio
+
 
 class Web3Exception(Exception):
     """
@@ -30,6 +35,8 @@ class Web3Exception(Exception):
             # deal with other exceptions
     """
 
+    user_message: Optional[str] = None
+
     def __init__(
         self,
         *args: Any,
@@ -69,6 +76,12 @@ class Web3TypeError(Web3Exception, TypeError):
     """
 
 
+class MethodNotSupported(Web3Exception):
+    """
+    Raised when a method is not supported by the provider.
+    """
+
+
 class BadFunctionCallOutput(Web3Exception):
     """
     We failed to decode ABI output.
@@ -77,7 +90,7 @@ class BadFunctionCallOutput(Web3Exception):
     """
 
 
-class BlockNumberOutofRange(Web3Exception):
+class BlockNumberOutOfRange(Web3Exception):
     """
     block_identifier passed does not match known block.
     """
@@ -216,25 +229,6 @@ class TimeExhausted(Web3Exception):
     """
 
 
-class TransactionNotFound(Web3Exception):
-    """
-    Raised when a tx hash used to lookup a tx in a jsonrpc call cannot be found.
-    """
-
-
-class TransactionIndexingInProgress(Web3Exception):
-    """
-    Raised when a transaction receipt is not yet available due to transaction indexing
-    still being in progress.
-    """
-
-
-class BlockNotFound(Web3Exception):
-    """
-    Raised when the block id used to lookup a block in a jsonrpc call cannot be found.
-    """
-
-
 class InfuraProjectIdNotFound(Web3Exception):
     """
     Raised when there is no Infura Project Id set.
@@ -317,7 +311,67 @@ class BadResponseFormat(Web3Exception):
     """
 
 
-class MethodUnavailable(Web3Exception):
+class TaskNotRunning(Web3Exception):
+    """
+    Used to signal between asyncio contexts that a task that is being awaited
+    is not currently running.
+    """
+
+    def __init__(
+        self, task: "asyncio.Task[Any]", message: Optional[str] = None
+    ) -> None:
+        self.task = task
+        if message is None:
+            message = f"Task {task} is not running."
+        self.message = message
+        super().__init__(message)
+
+
+class Web3RPCError(Web3Exception):
+    """
+    Raised when a JSON-RPC response contains an error field.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        rpc_response: Optional[RPCResponse] = None,
+        user_message: Optional[str] = None,
+    ) -> None:
+        if user_message is None:
+            user_message = (
+                "An RPC error was returned by the node. Check the message provided in "
+                "the error and any available logs for more information."
+            )
+
+        super().__init__(
+            message,
+            user_message=user_message,
+        )
+        self.message = message
+        self.rpc_response = rpc_response
+
+
+class MethodUnavailable(Web3RPCError):
     """
     Raised when the method is not available on the node
     """
+
+
+class TransactionNotFound(Web3RPCError):
+    """
+    Raised when a tx hash used to look up a tx in a jsonrpc call cannot be found.
+    """
+
+
+class TransactionIndexingInProgress(Web3RPCError):
+    """
+    Raised when a transaction receipt is not yet available due to transaction indexing
+    still being in progress.
+    """
+
+
+class BlockNotFound(Web3RPCError):
+    """
+    Raised when the block id used to look up a block in a jsonrpc call cannot be found.
+    """

web3/gas_strategies/time_based.py

@@ -110,11 +110,11 @@ def _aggregate_miner_data(
             # types ignored b/c mypy has trouble inferring gas_prices: Sequence[Wei]
             price_percentile = percentile(gas_prices, percentile=20)  # type: ignore
         except InsufficientData:
-            price_percentile = min(gas_prices)  # type: ignore
+            price_percentile = min(gas_prices)
         yield MinerData(
             miner,
             len(set(block_hashes)),
-            min(gas_prices),  # type: ignore
+            min(gas_prices),
             price_percentile,
         )