web3 7.0.0b2__py3-none-any.whl → 7.0.0b3__py3-none-any.whl

ens/async_ens.py

@@ -89,7 +89,7 @@ class AsyncENS(BaseENS):
     like getting the address for a name.
 
     Unless otherwise specified, all addresses are assumed to be a `str` in
-    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,
+    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,  # blocklint: pragma # noqa: E501
     like: ``"0x314159265dD8dbb310642f98f50C066173C1259b"``
     """
 
@@ -490,7 +490,7 @@ class AsyncENS(BaseENS):
         ):
             contract_func_with_args = (fn_name, [node])
 
-            calldata = resolver.encodeABI(*contract_func_with_args)
+            calldata = resolver.encode_abi(*contract_func_with_args)
             contract_call_result = await resolver.caller.resolve(
                 ens_encode_name(normal_name),
                 calldata,

ens/ens.py

@@ -88,7 +88,7 @@ class ENS(BaseENS):
     like getting the address for a name.
 
     Unless otherwise specified, all addresses are assumed to be a `str` in
-    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,
+    `checksum format <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md>`_,  # blocklint: pragma # noqa: E501
     like: ``"0x314159265dD8dbb310642f98f50C066173C1259b"``
     """
 
@@ -477,7 +477,7 @@ class ENS(BaseENS):
         if _resolver_supports_interface(resolver, ENS_EXTENDED_RESOLVER_INTERFACE_ID):
             contract_func_with_args = (fn_name, [node])
 
-            calldata = resolver.encodeABI(*contract_func_with_args)
+            calldata = resolver.encode_abi(*contract_func_with_args)
             contract_call_result = resolver.caller.resolve(
                 ens_encode_name(normal_name),
                 calldata,

ens/utils.py

@@ -35,9 +35,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from ._normalization import (
-    normalize_name_ensip15,
-)
 from .constants import (
     ACCEPTABLE_STALE_HOURS,
     AUCTION_START_GAS_CONSTANT,
@@ -117,13 +114,18 @@ def customize_web3(w3: "_Web3") -> "_Web3":
 def normalize_name(name: str) -> str:
     """
     Clean the fully qualified name, as defined in ENS `EIP-137
-    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_
+    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_  # blocklint: pragma # noqa: E501
 
     This does *not* enforce whether ``name`` is a label or fully qualified domain.
 
     :param str name: the dot-separated ENS name
     :raises InvalidName: if ``name`` has invalid syntax
     """
+    # Defer import because module initialization takes > 0.1 ms
+    from ._normalization import (
+        normalize_name_ensip15,
+    )
+
     if is_empty_name(name):
         return ""
     elif isinstance(name, (bytes, bytearray)):
@@ -169,7 +171,7 @@ def ens_encode_name(name: str) -> bytes:
 def is_valid_name(name: str) -> bool:
     """
     Validate whether the fully qualified name is valid, as defined in ENS `EIP-137
-    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_
+    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_  # blocklint: pragma # noqa: E501
 
     :param str name: the dot-separated ENS name
     :returns: True if ``name`` is set, and :meth:`~ens.ENS.nameprep` will not
@@ -229,7 +231,7 @@ def raw_name_to_hash(name: str) -> HexBytes:
     behind the scenes. For advanced usage, it is a helpful utility.
 
     This normalizes the name with `nameprep
-    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_
+    <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-137.md#name-syntax>`_  # blocklint: pragma # noqa: E501
     before hashing.
 
     :param str name: ENS name to hash

web3/_utils/events.py

@@ -29,6 +29,7 @@ from eth_abi.codec import (
 from eth_typing import (
     ChecksumAddress,
     HexStr,
+    Primitives,
     TypeStr,
 )
 from eth_utils import (
@@ -99,6 +100,12 @@ if TYPE_CHECKING:
     )
 
 
+def _log_entry_data_to_bytes(
+    log_entry_data: Union[Primitives, HexStr, str],
+) -> bytes:
+    return hexstr_if_str(to_bytes, log_entry_data)
+
+
 def construct_event_topic_set(
     event_abi: ABIEvent,
     abi_codec: ABICodec,
@@ -228,23 +235,25 @@ def get_event_data(
         log_topics = log_entry["topics"]
     elif not log_entry["topics"]:
         raise MismatchedABI("Expected non-anonymous event to have 1 or more topics")
-    # type ignored b/c event_abi_to_log_topic(event_abi: Dict[str, Any])
-    elif event_abi_to_log_topic(event_abi) != log_entry["topics"][0]:  # type: ignore
+    elif event_abi_to_log_topic(dict(event_abi)) != _log_entry_data_to_bytes(
+        log_entry["topics"][0]
+    ):
         raise MismatchedABI("The event signature did not match the provided ABI")
     else:
         log_topics = log_entry["topics"][1:]
 
+    log_topics_bytes = [_log_entry_data_to_bytes(topic) for topic in log_topics]
     log_topics_abi = get_indexed_event_inputs(event_abi)
     log_topic_normalized_inputs = normalize_event_input_types(log_topics_abi)
     log_topic_types = get_event_abi_types_for_decoding(log_topic_normalized_inputs)
     log_topic_names = get_abi_input_names(ABIEvent({"inputs": log_topics_abi}))
 
-    if len(log_topics) != len(log_topic_types):
+    if len(log_topics_bytes) != len(log_topic_types):
         raise LogTopicError(
-            f"Expected {len(log_topic_types)} log topics.  Got {len(log_topics)}"
+            f"Expected {len(log_topic_types)} log topics.  Got {len(log_topics_bytes)}"
         )
 
-    log_data = hexstr_if_str(to_bytes, log_entry["data"])
+    log_data = _log_entry_data_to_bytes(log_entry["data"])
     log_data_abi = exclude_indexed_event_inputs(event_abi)
     log_data_normalized_inputs = normalize_event_input_types(log_data_abi)
     log_data_types = get_event_abi_types_for_decoding(log_data_normalized_inputs)
@@ -270,7 +279,7 @@ def get_event_data(
 
     decoded_topic_data = [
         abi_codec.decode([topic_type], topic_data)[0]
-        for topic_type, topic_data in zip(log_topic_types, log_topics)
+        for topic_type, topic_data in zip(log_topic_types, log_topics_bytes)
     ]
     normalized_topic_data = map_abi_data(
         BASE_RETURN_NORMALIZERS, log_topic_types, decoded_topic_data

web3/_utils/math.py

@@ -18,22 +18,20 @@ def percentile(
         )
     if percentile is None:
         raise ValueError(f"Expected a percentile choice, got {percentile}")
+    if percentile < 0 or percentile > 100:
+        raise ValueError("percentile must be in the range [0, 100]")
 
     sorted_values = sorted(values)
 
-    rank = len(values) * percentile / 100
-    if rank > 0:
-        index = rank - 1
-        if index < 0:
-            return sorted_values[0]
-    else:
-        index = rank
+    index = len(values) * percentile / 100 - 1
+    if index < 0:
+        return sorted_values[0]
 
-    if index % 1 == 0:
+    fractional = index % 1
+    if fractional == 0:
         return sorted_values[int(index)]
-    else:
-        fractional = index % 1
-        integer = int(index - fractional)
-        lower = sorted_values[integer]
-        higher = sorted_values[integer + 1]
-        return lower + fractional * (higher - lower)
+
+    integer = int(index - fractional)
+    lower = sorted_values[integer]
+    higher = sorted_values[integer + 1]
+    return lower + fractional * (higher - lower)

web3/_utils/method_formatters.py

@@ -233,6 +233,10 @@ TRANSACTION_RESULT_FORMATTERS = {
     ),
     "input": HexBytes,
     "data": HexBytes,  # Nethermind, for example, returns both `input` and `data`
+    "maxFeePerBlobGas": to_integer_if_hex,
+    "blobVersionedHashes": apply_formatter_if(
+        is_not_null, apply_formatter_to_array(to_hexbytes(32))
+    ),
 }
 
 
@@ -516,6 +520,7 @@ PYTHONIC_REQUEST_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     ),
     RPC.eth_getBalance: apply_formatter_at_index(to_hex_if_integer, 1),
     RPC.eth_getBlockByNumber: apply_formatter_at_index(to_hex_if_integer, 0),
+    RPC.eth_getBlockReceipts: apply_formatter_at_index(to_hex_if_integer, 0),
     RPC.eth_getBlockTransactionCountByNumber: apply_formatter_at_index(
         to_hex_if_integer,
         0,
@@ -723,6 +728,7 @@ PYTHONIC_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBalance: to_integer_if_hex,
     RPC.eth_getBlockByHash: apply_formatter_if(is_not_null, block_formatter),
     RPC.eth_getBlockByNumber: apply_formatter_if(is_not_null, block_formatter),
+    RPC.eth_getBlockReceipts: apply_formatter_to_array(receipt_formatter),
     RPC.eth_getBlockTransactionCountByHash: to_integer_if_hex,
     RPC.eth_getBlockTransactionCountByNumber: to_integer_if_hex,
     RPC.eth_getCode: HexBytes,
@@ -900,6 +906,7 @@ def raise_transaction_not_found_with_index(
 NULL_RESULT_FORMATTERS: Dict[RPCEndpoint, Callable[..., Any]] = {
     RPC.eth_getBlockByHash: raise_block_not_found,
     RPC.eth_getBlockByNumber: raise_block_not_found,
+    RPC.eth_getBlockReceipts: raise_block_not_found,
     RPC.eth_getBlockTransactionCountByHash: raise_block_not_found,
     RPC.eth_getBlockTransactionCountByNumber: raise_block_not_found,
     RPC.eth_getUncleCountByBlockHash: raise_block_not_found,

web3/_utils/module_testing/eth_module.py

@@ -977,6 +977,39 @@ class AsyncEthModuleTest:
         assert block is not None
         assert isinstance(block["number"], int)
 
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_hash(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts(async_empty_block["hash"])
+        assert isinstance(receipts, list)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_not_found(self, async_w3: "AsyncWeb3") -> None:
+        with pytest.raises(BlockNotFound):
+            await async_w3.eth.get_block_receipts(UNKNOWN_HASH)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_with_integer(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts(async_empty_block["number"])
+        assert isinstance(receipts, list)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_safe(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts("safe")
+        assert isinstance(receipts, list)
+
+    @pytest.mark.asyncio
+    async def test_eth_getBlockReceipts_finalized(
+        self, async_w3: "AsyncWeb3", async_empty_block: BlockData
+    ) -> None:
+        receipts = await async_w3.eth.get_block_receipts("finalized")
+        assert isinstance(receipts, list)
+
     @pytest.mark.asyncio
     async def test_eth_get_block_by_number_full_transactions(
         self, async_w3: "AsyncWeb3", async_block_with_txn: BlockData
@@ -1303,7 +1336,7 @@ class AsyncEthModuleTest:
         async_revert_contract: "Contract",
         async_unlocked_account: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encodeABI(
+        data = async_revert_contract.encode_abi(
             fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
         )
         txn_params = async_revert_contract._prepare_transaction(
@@ -1323,7 +1356,7 @@ class AsyncEthModuleTest:
         async_revert_contract: "Contract",
         async_unlocked_account: ChecksumAddress,
     ) -> None:
-        data = async_revert_contract.encodeABI(fn_name="Unauthorized")
+        data = async_revert_contract.encode_abi(fn_name="Unauthorized")
         txn_params = async_revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
@@ -3755,7 +3788,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(
+        data = revert_contract.encode_abi(
             fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
         )
         txn_params = revert_contract._prepare_transaction(
@@ -3775,7 +3808,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(fn_name="Unauthorized")
+        data = revert_contract.encode_abi(fn_name="Unauthorized")
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
@@ -4064,7 +4097,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(
+        data = revert_contract.encode_abi(
             fn_name="UnauthorizedWithMessage", args=["You are not authorized"]
         )
         txn_params = revert_contract._prepare_transaction(
@@ -4084,7 +4117,7 @@ class EthModuleTest:
         revert_contract: "Contract",
         unlocked_account: ChecksumAddress,
     ) -> None:
-        data = revert_contract.encodeABI(fn_name="Unauthorized")
+        data = revert_contract.encode_abi(fn_name="Unauthorized")
         txn_params = revert_contract._prepare_transaction(
             fn_name="customErrorWithoutMessage",
             transaction={
@@ -4224,6 +4257,34 @@ class EthModuleTest:
         transaction = block["transactions"][0]
         assert transaction["hash"] == block_with_txn["transactions"][0]  # type: ignore
 
+    def test_eth_getBlockReceipts_hash(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts(empty_block["hash"])
+        assert isinstance(receipts, list)
+
+    def test_eth_getBlockReceipts_not_found(self, w3: "Web3") -> None:
+        with pytest.raises(BlockNotFound):
+            w3.eth.get_block_receipts(UNKNOWN_HASH)
+
+    def test_eth_getBlockReceipts_with_integer(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts(empty_block["number"])
+        assert isinstance(receipts, list)
+
+    def test_eth_getBlockReceipts_safe(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts("safe")
+        assert isinstance(receipts, list)
+
+    def test_eth_getBlockReceipts_finalized(
+        self, w3: "Web3", empty_block: BlockData
+    ) -> None:
+        receipts = w3.eth.get_block_receipts("finalized")
+        assert isinstance(receipts, list)
+
     def test_eth_getTransactionByHash(self, w3: "Web3", mined_txn_hash: HexStr) -> None:
         transaction = w3.eth.get_transaction(mined_txn_hash)
         assert is_dict(transaction)

web3/_utils/rpc_abi.py

@@ -57,6 +57,7 @@ class RPC:
     eth_getBalance = RPCEndpoint("eth_getBalance")
     eth_getBlockByHash = RPCEndpoint("eth_getBlockByHash")
     eth_getBlockByNumber = RPCEndpoint("eth_getBlockByNumber")
+    eth_getBlockReceipts = RPCEndpoint("eth_getBlockReceipts")
     eth_getBlockTransactionCountByHash = RPCEndpoint(
         "eth_getBlockTransactionCountByHash"
     )

web3/_utils/transactions.py

@@ -49,6 +49,8 @@ TX_PARAM_LITERALS = Literal[
     "nonce",
     "chainId",
     "accessList",
+    "maxFeePerBlobGas",
+    "blobVersionedHashes",
 ]
 
 VALID_TRANSACTION_PARAMS: List[TX_PARAM_LITERALS] = [
@@ -64,6 +66,8 @@ VALID_TRANSACTION_PARAMS: List[TX_PARAM_LITERALS] = [
     "data",
     "nonce",
     "chainId",
+    "maxFeePerBlobGas",
+    "blobVersionedHashes",
 ]
 
 TRANSACTION_DEFAULTS = {

web3/contract/base_contract.py

@@ -723,7 +723,7 @@ class BaseContract:
     #  Public API
     #
     @combomethod
-    def encodeABI(
+    def encode_abi(
         cls,
         fn_name: str,
         args: Optional[Any] = None,

web3/eth/async_eth.py

@@ -4,6 +4,7 @@ from typing import (
     Any,
     Awaitable,
     Callable,
+    Dict,
     List,
     Optional,
     Tuple,
@@ -75,6 +76,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -440,6 +442,20 @@ class AsyncEth(BaseEth):
     ) -> BlockData:
         return await self._get_block(block_identifier, full_transactions)
 
+    # eth_getBlockReceipts
+
+    _get_block_receipts: Method[
+        Callable[[BlockIdentifier], Awaitable[BlockReceipts]]
+    ] = Method(
+        RPC.eth_getBlockReceipts,
+        mungers=[default_root_munger],
+    )
+
+    async def get_block_receipts(
+        self, block_identifier: BlockIdentifier
+    ) -> BlockReceipts:
+        return await self._get_block_receipts(block_identifier)
+
     # eth_getBalance
 
     _get_balance: Method[
@@ -622,14 +638,16 @@ class AsyncEth(BaseEth):
     # eth_signTypedData
 
     _sign_typed_data: Method[
-        Callable[[Union[Address, ChecksumAddress, ENS], str], Awaitable[HexStr]]
+        Callable[
+            [Union[Address, ChecksumAddress, ENS], Dict[str, Any]], Awaitable[HexStr]
+        ]
     ] = Method(
         RPC.eth_signTypedData,
         mungers=[default_root_munger],
     )
 
     async def sign_typed_data(
-        self, account: Union[Address, ChecksumAddress, ENS], data: str
+        self, account: Union[Address, ChecksumAddress, ENS], data: Dict[str, Any]
     ) -> HexStr:
         return await self._sign_typed_data(account, data)
 

web3/eth/eth.py

@@ -2,6 +2,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Sequence,
@@ -72,6 +73,7 @@ from web3.types import (
     BlockData,
     BlockIdentifier,
     BlockParams,
+    BlockReceipts,
     CreateAccessListResponse,
     FeeHistory,
     FilterParams,
@@ -411,6 +413,16 @@ class Eth(BaseEth):
     ) -> BlockData:
         return self._get_block(block_identifier, full_transactions)
 
+    # eth_getBlockReceipts
+
+    _get_block_receipts: Method[Callable[[BlockIdentifier], BlockReceipts]] = Method(
+        RPC.eth_getBlockReceipts,
+        mungers=[default_root_munger],
+    )
+
+    def get_block_receipts(self, block_identifier: BlockIdentifier) -> BlockReceipts:
+        return self._get_block_receipts(block_identifier)
+
     # eth_getBalance
 
     _get_balance: Method[
@@ -611,7 +623,7 @@ class Eth(BaseEth):
     # eth_signTypedData
 
     sign_typed_data: Method[
-        Callable[[Union[Address, ChecksumAddress, ENS], str], HexStr]
+        Callable[[Union[Address, ChecksumAddress, ENS], Dict[str, Any]], HexStr]
     ] = Method(
         RPC.eth_signTypedData,
         mungers=[default_root_munger],

web3/exceptions.py

@@ -30,6 +30,16 @@ class Web3Exception(Exception):
             # deal with other exceptions
     """
 
+    def __init__(
+        self,
+        *args: Any,
+        user_message: Optional[str] = None,
+    ):
+        super().__init__(*args)
+
+        # Assign properties of Web3Exception
+        self.user_message = user_message
+
 
 class BadFunctionCallOutput(Web3Exception):
     """
@@ -274,6 +284,7 @@ class ContractLogicError(Web3Exception):
         message: Optional[str] = None,
         data: Optional[Union[str, Dict[str, str]]] = None,
     ):
+        super().__init__(message, data)
         self.message = message
         self.data = data
 

web3/manager.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 from typing import (
     TYPE_CHECKING,
@@ -246,7 +245,11 @@ class RequestManager:
             if not isinstance(code, int):
                 _raise_bad_response_format(response, "error['code'] must be an integer")
             elif code == METHOD_NOT_FOUND:
-                raise MethodUnavailable(error)
+                raise MethodUnavailable(
+                    error,
+                    user_message="Check your node provider's API docs to see what "
+                    "methods are supported",
+                )
 
             # Errors must include a message
             if not isinstance(error.get("message"), str):
@@ -345,11 +348,7 @@ class RequestManager:
             )
 
         while True:
-            # sleep(0) here seems to be the most efficient way to yield control
-            # back to the event loop while waiting for the response in the queue.
-            await asyncio.sleep(0)
-
-            response = self._request_processor.pop_raw_response(subscription=True)
+            response = await self._request_processor.pop_raw_response(subscription=True)
             if (
                 response is not None
                 and response.get("params", {}).get("subscription")

web3/providers/persistent/persistent.py

@@ -78,7 +78,7 @@ class PersistentConnectionProvider(AsyncJSONBaseProvider, ABC):
                     self.logger.debug(
                         f"Popping response for id {request_id} from cache."
                     )
-                    popped_response = self._request_processor.pop_raw_response(
+                    popped_response = await self._request_processor.pop_raw_response(
                         cache_key=request_cache_key,
                     )
                     return popped_response

web3/providers/persistent/request_processor.py

@@ -235,19 +235,17 @@ class RequestProcessor:
             )
             self._request_response_cache.cache(cache_key, raw_response)
 
-    def pop_raw_response(
+    async def pop_raw_response(
         self, cache_key: str = None, subscription: bool = False
     ) -> Any:
         if subscription:
             qsize = self._subscription_response_queue.qsize()
-            if qsize == 0:
-                return None
+            raw_response = await self._subscription_response_queue.get()
 
             if not self._provider._listen_event.is_set():
                 self._provider._listen_event.set()
 
-            raw_response = self._subscription_response_queue.get_nowait()
-            if qsize == 1:
+            if qsize == 0:
                 if not self._subscription_queue_synced_with_ws_stream:
                     self._subscription_queue_synced_with_ws_stream = True
                     self._provider.logger.info(

web3/tools/benchmark/main.py

@@ -0,0 +1,185 @@
+import argparse
+import asyncio
+from collections import (
+    defaultdict,
+)
+import logging
+import sys
+import timeit
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Union,
+)
+
+from web3 import (
+    AsyncHTTPProvider,
+    AsyncWeb3,
+    HTTPProvider,
+    Web3,
+)
+from web3.middleware import (
+    BufferedGasEstimateMiddleware,
+    GasPriceStrategyMiddleware,
+)
+from web3.tools.benchmark.node import (
+    GethBenchmarkFixture,
+)
+from web3.tools.benchmark.reporting import (
+    print_entry,
+    print_footer,
+    print_header,
+)
+from web3.tools.benchmark.utils import (
+    wait_for_aiohttp,
+    wait_for_http,
+)
+from web3.types import (
+    Wei,
+)
+
+KEYFILE_PW = "web3py-test"
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--num-calls",
+    type=int,
+    default=10,
+    help="The number of RPC calls to make",
+)
+
+# TODO - layers to test:
+# contract.functions.method(...).call()
+# w3.eth.call(...)
+# HTTPProvider.make_request(...)
+
+
+def build_web3_http(endpoint_uri: str) -> Web3:
+    wait_for_http(endpoint_uri)
+    _w3 = Web3(
+        HTTPProvider(endpoint_uri),
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
+    )
+    return _w3
+
+
+async def build_async_w3_http(endpoint_uri: str) -> AsyncWeb3:
+    await wait_for_aiohttp(endpoint_uri)
+    _w3 = AsyncWeb3(
+        AsyncHTTPProvider(endpoint_uri),
+        middleware=[GasPriceStrategyMiddleware, BufferedGasEstimateMiddleware],
+    )
+    return _w3
+
+
+def sync_benchmark(func: Callable[..., Any], n: int) -> Union[float, str]:
+    try:
+        starttime = timeit.default_timer()
+        for _ in range(n):
+            func()
+        endtime = timeit.default_timer()
+        execution_time = endtime - starttime
+        return execution_time
+    except Exception:
+        return "N/A"
+
+
+async def async_benchmark(func: Callable[..., Any], n: int) -> Union[float, str]:
+    try:
+        starttime = timeit.default_timer()
+        for result in asyncio.as_completed([func() for _ in range(n)]):
+            await result
+        execution_time = timeit.default_timer() - starttime
+        return execution_time
+    except Exception:
+        return "N/A"
+
+
+def main(logger: logging.Logger, num_calls: int) -> None:
+    fixture = GethBenchmarkFixture()
+    for built_fixture in fixture.build():
+        for _ in built_fixture:
+            w3_http = build_web3_http(fixture.endpoint_uri)
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+
+            # -- sync -- #
+            coinbase = w3_http.eth.coinbase
+
+            # -- async -- #
+            async_w3_http = loop.run_until_complete(
+                build_async_w3_http(fixture.endpoint_uri)
+            )
+            async_coinbase = loop.run_until_complete(async_w3_http.eth.coinbase)
+
+            methods = [
+                {
+                    "name": "eth_gasPrice",
+                    "params": {},
+                    "exec": lambda: w3_http.eth.gas_price,
+                    "async_exec": lambda: async_w3_http.eth.gas_price,
+                },
+                {
+                    "name": "eth_sendTransaction",
+                    "params": {},
+                    "exec": lambda: w3_http.eth.send_transaction(
+                        {
+                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
+                            "from": coinbase,
+                            "value": Wei(1),
+                        }
+                    ),
+                    "async_exec": lambda: async_w3_http.eth.send_transaction(
+                        {
+                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
+                            "from": async_coinbase,
+                            "value": Wei(1),
+                        }
+                    ),
+                },
+                {
+                    "name": "eth_blockNumber",
+                    "params": {},
+                    "exec": lambda: w3_http.eth.block_number,
+                    "async_exec": lambda: async_w3_http.eth.block_number,
+                },
+                {
+                    "name": "eth_getBlock",
+                    "params": {},
+                    "exec": lambda: w3_http.eth.get_block(1),
+                    "async_exec": lambda: async_w3_http.eth.get_block(1),
+                },
+            ]
+
+            def benchmark(method: Dict[str, Any]) -> None:
+                outcomes: Dict[str, Union[str, float]] = defaultdict(lambda: "N/A")
+                outcomes["name"] = method["name"]
+                outcomes["HTTPProvider"] = sync_benchmark(
+                    method["exec"],
+                    num_calls,
+                )
+                outcomes["AsyncHTTPProvider"] = loop.run_until_complete(
+                    async_benchmark(method["async_exec"], num_calls)
+                )
+                print_entry(logger, outcomes)
+
+            print_header(logger, num_calls)
+
+            for method in methods:
+                benchmark(method)
+
+            print_footer(logger)
+
+
+if __name__ == "__main__":
+    args = parser.parse_args()
+
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    logger.addHandler(logging.StreamHandler(sys.stdout))
+
+    main(logger, args.num_calls)

web3/tools/benchmark/node.py

@@ -0,0 +1,126 @@
+import os
+import socket
+from subprocess import (
+    PIPE,
+    Popen,
+    check_output,
+)
+from tempfile import (
+    TemporaryDirectory,
+)
+from typing import (
+    Any,
+    Generator,
+    Sequence,
+)
+import zipfile
+
+from geth.install import (
+    get_executable_path,
+    install_geth,
+)
+
+from web3.tools.benchmark.utils import (
+    kill_proc_gracefully,
+)
+
+GETH_FIXTURE_ZIP = "geth-1.13.11-fixture.zip"
+
+# use same coinbase value as in `web3.py/tests/integration/generate_fixtures/common.py`
+COINBASE = "0xdc544d1aa88ff8bbd2f2aec754b1f1e99e1812fd"
+
+
+class GethBenchmarkFixture:
+    def __init__(self) -> None:
+        self.rpc_port = self._rpc_port()
+        self.endpoint_uri = self._endpoint_uri()
+        self.geth_binary = self._geth_binary()
+
+    def build(self) -> Generator[Any, None, None]:
+        with TemporaryDirectory() as base_dir:
+            zipfile_path = os.path.abspath(
+                os.path.join(
+                    os.path.dirname(__file__),
+                    "../../../tests/integration/",
+                    GETH_FIXTURE_ZIP,
+                )
+            )
+            tmp_datadir = os.path.join(str(base_dir), "datadir")
+            with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
+                zip_ref.extractall(tmp_datadir)
+            self.datadir = tmp_datadir
+
+            genesis_file = os.path.join(self.datadir, "genesis.json")
+
+            yield self._geth_process(self.datadir, genesis_file, self.rpc_port)
+
+    def _rpc_port(self) -> str:
+        sock = socket.socket()
+        sock.bind(("127.0.0.1", 0))
+        port = sock.getsockname()[1]
+        sock.close()
+        return str(port)
+
+    def _endpoint_uri(self) -> str:
+        return f"http://localhost:{self.rpc_port}"
+
+    def _geth_binary(self) -> str:
+        if "GETH_BINARY" in os.environ:
+            return os.environ["GETH_BINARY"]
+        elif "GETH_VERSION" in os.environ:
+            geth_version = os.environ["GETH_VERSION"]
+            _geth_binary = get_executable_path(geth_version)
+            if not os.path.exists(_geth_binary):
+                install_geth(geth_version)
+            assert os.path.exists(_geth_binary)
+            return _geth_binary
+        else:
+            return "geth"
+
+    def _geth_command_arguments(self, datadir: str) -> Sequence[str]:
+        return (
+            self.geth_binary,
+            "--dev",
+            "--dev.period",
+            "100",
+            "--datadir",
+            str(datadir),
+            "--nodiscover",
+            "--http",
+            "--http.port",
+            self.rpc_port,
+            "--http.api",
+            "admin,eth,net,web3",
+            "--ipcdisable",
+            "--allow-insecure-unlock",
+            "--miner.etherbase",
+            COINBASE[2:],
+            "--password",
+            os.path.join(datadir, "keystore", "pw.txt"),
+        )
+
+    def _geth_process(
+        self, datadir: str, genesis_file: str, rpc_port: str
+    ) -> Generator[Any, None, None]:
+        init_datadir_command = (
+            self.geth_binary,
+            "--datadir",
+            str(datadir),
+            "init",
+            str(genesis_file),
+        )
+        check_output(
+            init_datadir_command,
+            stdin=PIPE,
+            stderr=PIPE,
+        )
+        proc = Popen(
+            self._geth_command_arguments(datadir),
+            stdin=PIPE,
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        try:
+            yield proc
+        finally:
+            kill_proc_gracefully(proc)

web3/tools/benchmark/reporting.py

@@ -0,0 +1,39 @@
+from logging import (
+    Logger,
+)
+from typing import (
+    Any,
+    Dict,
+)
+
+
+def print_header(logger: Logger, num_calls: int) -> None:
+    logger.info(
+        "|{:^26}|{:^20}|{:^20}|{:^20}|{:^20}|".format(
+            f"Method ({num_calls} calls)",
+            "HTTPProvider",
+            "AsyncHTTProvider",
+            "IPCProvider",
+            "WebSocketProvider",
+        )
+    )
+    logger.info("-" * 112)
+
+
+def print_entry(
+    logger: Logger,
+    method_benchmarks: Dict[str, Any],
+) -> None:
+    logger.info(
+        "|{:^26}|{:^20.10}|{:^20.10}|{:^20.10}|{:^20.10}|".format(
+            method_benchmarks["name"],
+            method_benchmarks["HTTPProvider"],
+            method_benchmarks["AsyncHTTPProvider"],
+            method_benchmarks["IPCProvider"],
+            method_benchmarks["WebSocketProvider"],
+        )
+    )
+
+
+def print_footer(logger: Logger) -> None:
+    logger.info("-" * 112)

web3/tools/benchmark/utils.py

@@ -0,0 +1,69 @@
+import asyncio
+import signal
+import socket
+import time
+from typing import (
+    Any,
+)
+
+import aiohttp
+import requests
+
+
+def wait_for_socket(ipc_path: str, timeout: int = 30) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        try:
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            sock.connect(ipc_path)
+            sock.settimeout(timeout)
+        except (FileNotFoundError, socket.error):
+            time.sleep(0.01)
+        else:
+            break
+
+
+def wait_for_http(endpoint_uri: str, timeout: int = 60) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        try:
+            requests.get(endpoint_uri)
+        except requests.ConnectionError:
+            time.sleep(0.01)
+        else:
+            break
+
+
+async def wait_for_aiohttp(endpoint_uri: str, timeout: int = 60) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        try:
+            async with aiohttp.ClientSession() as session:
+                await session.get(endpoint_uri)
+        except aiohttp.client_exceptions.ClientConnectorError:
+            await asyncio.sleep(0.01)
+        else:
+            break
+
+
+def wait_for_popen(proc: Any, timeout: int) -> None:
+    start = time.time()
+    while time.time() < start + timeout:
+        if proc.poll() is None:
+            time.sleep(0.01)
+        else:
+            break
+
+
+def kill_proc_gracefully(proc: Any) -> None:
+    if proc.poll() is None:
+        proc.send_signal(signal.SIGINT)
+        wait_for_popen(proc, 13)
+
+    if proc.poll() is None:
+        proc.terminate()
+        wait_for_popen(proc, 5)
+
+    if proc.poll() is None:
+        proc.kill()
+        wait_for_popen(proc, 2)

web3/types.py

@@ -135,6 +135,7 @@ TxData = TypedDict(
     "TxData",
     {
         "accessList": AccessList,
+        "blobVersionedHashes": Sequence[HexBytes],
         "blockHash": HexBytes,
         "blockNumber": BlockNumber,
         "chainId": int,
@@ -142,6 +143,7 @@ TxData = TypedDict(
         "from": ChecksumAddress,
         "gas": int,
         "gasPrice": Wei,
+        "maxFeePerBlobGas": Wei,
         "maxFeePerGas": Wei,
         "maxPriorityFeePerGas": Wei,
         "hash": HexBytes,
@@ -381,6 +383,8 @@ TxReceipt = TypedDict(
     },
 )
 
+BlockReceipts = List[TxReceipt]
+
 
 class SignedTx(TypedDict, total=False):
     raw: bytes

web3/utils/caching.py

@@ -16,22 +16,20 @@ class SimpleCache:
         self._data: OrderedDict[str, Any] = OrderedDict()
 
     def cache(self, key: str, value: Any) -> Tuple[Any, Dict[str, Any]]:
-        evicted_items = None
+        evicted_items = {}
         # If the key is already in the OrderedDict just update it
         # and don't evict any values. Ideally, we could still check to see
         # if there are too many items in the OrderedDict but that may rearrange
         # the order it should be unlikely that the size could grow over the limit
         if key not in self._data:
             while len(self._data) >= self._size:
-                if evicted_items is None:
-                    evicted_items = {}
                 k, v = self._data.popitem(last=False)
                 evicted_items[k] = v
         self._data[key] = value
 
         # Return the cached value along with the evicted items at the same time. No
         # need to reach back into the cache to grab the value.
-        return value, evicted_items
+        return value, evicted_items or None
 
     def get_cache_entry(self, key: str) -> Optional[Any]:
         return self._data[key] if key in self._data else None

{web3-7.0.0b2.dist-info → web3-7.0.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b2
+Version: 7.0.0b3
 Summary: web3.py
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -36,6 +36,7 @@ Provides-Extra: dev
 Requires-Dist: eth-tester[py-evm] ==v0.10.0-b.3 ; extra == 'dev'
 Requires-Dist: py-geth >=4.1.0 ; extra == 'dev'
 Requires-Dist: black >=22.1.0 ; extra == 'dev'
+Requires-Dist: blocklint >=0.2.4 ; extra == 'dev'
 Requires-Dist: flake8 ==3.8.3 ; extra == 'dev'
 Requires-Dist: isort >=5.11.0 ; extra == 'dev'
 Requires-Dist: mypy ==1.4.1 ; extra == 'dev'
@@ -64,6 +65,7 @@ Requires-Dist: sphinx-rtd-theme >=1.0.0 ; extra == 'docs'
 Requires-Dist: towncrier <22,>=21 ; extra == 'docs'
 Provides-Extra: linter
 Requires-Dist: black >=22.1.0 ; extra == 'linter'
+Requires-Dist: blocklint >=0.2.4 ; extra == 'linter'
 Requires-Dist: flake8 ==3.8.3 ; extra == 'linter'
 Requires-Dist: isort >=5.11.0 ; extra == 'linter'
 Requires-Dist: mypy ==1.4.1 ; extra == 'linter'

{web3-7.0.0b2.dist-info → web3-7.0.0b3.dist-info}/RECORD

@@ -1,31 +1,31 @@
 ens/__init__.py,sha256=Dtb57dzb4nLJbtR-XCziJs075vqNpmNfiDSIVe5EPnE,285
 ens/_normalization.py,sha256=cj9EWUFtKwiYEoX-2PfrcVv5VRYm-oy-CX9cDjegZrE,16788
 ens/abis.py,sha256=0Ec_lqe7HBsVpQrID3ccFMhx8Vb7S0TGFbeuRdXhuCE,34745
-ens/async_ens.py,sha256=Nns377sjU9RwsbnkjSLaaXp6r9VbXBxSgNrTbc9h4rY,22298
+ens/async_ens.py,sha256=j0BoBfik1FeLui26GI9S-rUBE1zPpeBnBZL5bDDTwWU,22333
 ens/auto.py,sha256=w_E6Ua5ZmJVxfdii2aG5I_kQG5B9U5Y2qIFKVNhXo98,41
 ens/base_ens.py,sha256=BTYB5SCkif5r08Aou7haMhJABaggOHn3S4tUW4MLsVo,3477
 ens/constants.py,sha256=XCO4Pntwdnw10K_AZ86V0cqcvdUoOkEZvRqoDdFPE_w,913
 ens/contract_data.py,sha256=ZF8wMZDXbhd3q1Qn5ishjbASQf4QoDAMUet9ySTwmVU,148604
-ens/ens.py,sha256=GJSbTD64-X7Uf06OikeutuRcx4pZaHzOIY-7XxJMmII,21570
+ens/ens.py,sha256=XlVZ7k9hC_HOiOFD7LCZQ-rroVfq2TTle_oSfrXSbmc,21605
 ens/exceptions.py,sha256=g15oQhT3cbhniGjAmboC2M7xKGGNDfMutSnfK0LMqvs,2326
-ens/utils.py,sha256=9tl1mH2c3VHxubQkCcNRc4yMKx7dLNm8vgpJ89OMUAQ,9138
+ens/utils.py,sha256=Ah9EVu-ch8nWMzMoFSYrkGMzJA61-zwT5Qc5Homs1JI,9317
 ens/specs/nf.json,sha256=EnLJQWU7usNO-EBe1SessY2CioM4H_HXTRvxU__0Ufw,48402
 ens/specs/normalization_spec.json,sha256=liMWlkVT_OYYjiWlFmpMHpBjM631O98pZMcd7cD44sg,3115333
 web3/__init__.py,sha256=ZKNvCbdKGK7fBlUIGBOiIoBaEsvnKIjF0GpZZpNF5h4,1068
 web3/constants.py,sha256=eQLRQVMFPbgpOjjkPTMHkY-syncJuO-sPX5UrCSRjzQ,564
 web3/datastructures.py,sha256=ylvV3sgXsovIwbg9cXiHXdIZHdCIMzPwxMY1SeJVUSM,10716
-web3/exceptions.py,sha256=vJsP5sXeUeeUUFd7GaodGh-k1YH6CfwFTWyT-EZFMu0,6641
+web3/exceptions.py,sha256=u0qTr7mS9wEmh-0jSfXNlEzJ-Sfigr4MwF6HxE7_wUw,6904
 web3/geth.py,sha256=1DRMSCErpCxL7l0406z5K46P8ORmtS87ZMyLowwK9LI,11329
 web3/logs.py,sha256=ROs-mDMH_ZOecE7hfbWA5yp27G38FbLjX4lO_WtlZxQ,198
 web3/main.py,sha256=-75d38t4aGjJNbbcUOnlE2s0jdIw34UDODHjVVzaBTo,13987
-web3/manager.py,sha256=-0Ce0zO9HZr3XenPYhATscrkrCmow8p60vPM5nBquTc,15069
+web3/manager.py,sha256=Sz2xseY3WxppPXLPpBoIvK51FqiN9VstY1UK69LlTgU,15030
 web3/method.py,sha256=3q8SnB6z3KKVfYYlDHoPCuQd-gYdjYkQWy8Q4Y5_L0U,7766
 web3/module.py,sha256=zonvW0meqdfG82-KgtYTF9ketsCShK2m9b-HYRBJRZg,4793
 web3/net.py,sha256=Y3vPzHWVFkfHEZoJxjDOt4tp5ERmZrMuyi4ZFOLmIeA,1562
 web3/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/testing.py,sha256=X7rKGcuEbRCvwXlWuJOfzZvXHboIEeoK-bIWnF_zn1A,951
 web3/tracing.py,sha256=OBRKLfoSSstzUrk-oqkrbPYPTNGTaPX7-VO5iEt1FwY,2968
-web3/types.py,sha256=Eq5MeHp497dx_I4kbdZMvy91zBdsy4XdgHWMBphYzEw,12417
+web3/types.py,sha256=Cf-YKolEoS39PQxahxccyhdUcPYHFq6-S06KXn26cDk,12534
 web3/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/_utils/abi.py,sha256=OOnpQSGVAPgbgCXcxGypmhMMj1tq27HXyqPYrTqkchU,30587
 web3/_utils/async_caching.py,sha256=2XnaKCHBTTDK6B2R_YZvjJqIRUpbMDIU1uYrq-Lcyp8,486
@@ -39,21 +39,21 @@ web3/_utils/empty.py,sha256=jd7-bwIhNLfBjns5WRDCeN1aT1reGgTZ1XlT6olTs3U,144
 web3/_utils/encoding.py,sha256=VW_-lDqQsEjqrA34Ea8v4Lj8_y3ZHL6EnTGJK-jt5rw,9117
 web3/_utils/ens.py,sha256=2BvzfegBkR7vH3Fq7lo_LsgfT912Zj-mR8eUt6o_lBA,2434
 web3/_utils/error_formatters_utils.py,sha256=0D1Dc6QojWgG2JSJmdjnFjs3k-ylKItygTulI7XZXco,6809
-web3/_utils/events.py,sha256=yDkzxWqT--KZN2MFo4F_ERsgOHRvUuc0z1vr4GH6uj0,17278
+web3/_utils/events.py,sha256=6vebSk4klDRHykZ_9Dv0N9omam8OQOU8EWUdVEv2TAY,17498
 web3/_utils/fee_utils.py,sha256=65Z6pPaPz39gsCVIyQwM2y1qfOUNc-4hlGbYAqAteVA,2145
 web3/_utils/filters.py,sha256=MTgJGMw2hHmrxtaJmWO-0DjQ5OCbwY0kOoT-OglgPDc,11996
 web3/_utils/formatters.py,sha256=xcLQIRxL07vHHTwfsdGEGS7LGzY1_tf5mSnTS9KTfoM,3071
 web3/_utils/function_identifiers.py,sha256=m305lsvUZk-jkPixT0IJd9P5sXqMvmwlwlLeBgEAnBQ,55
 web3/_utils/http.py,sha256=GDHmbeWt7UoHkRBvFt9Py5Vzr2ZLzH9WxAqEYZCJ53s,205
 web3/_utils/hypothesis.py,sha256=4Cm4iOWv-uP9irg_Pv63kYNDYUAGhnUH6fOPWRw3A0g,209
-web3/_utils/math.py,sha256=Tl-EhmKXtPM7t5tkj2VKrJYTtl5DJoTHiKIL95kzQHc,1047
-web3/_utils/method_formatters.py,sha256=Dl6TbwkuL-5LhRpUdjQG6XVNJ2p-o5sA93WQJedJdZo,33552
+web3/_utils/math.py,sha256=g6iSVKaKgCofjAC60MC2yTtlhNoezHQppJ3EAbpLwXs,1055
+web3/_utils/method_formatters.py,sha256=kg4xkDXyH-a4CnB-vXL1pYgQWhanVudSNYjVFmkdGC4,33918
 web3/_utils/module.py,sha256=s3oqAZpR5hlbGrHkFNNtqavNqciAQjNkMrMYke-mYlg,3147
 web3/_utils/normalizers.py,sha256=jb-tMhWyNKWv1TJyrECwOeyDGAGON67jKb0Iz-Rxlcw,7447
 web3/_utils/request.py,sha256=PC_UMluqlaJECfiqEyLAiLKff_lz49sOqK0-77iVpw8,8881
-web3/_utils/rpc_abi.py,sha256=6-6r7oybsB7delHgZ2w0CXWayYYFIjR0qb7b2X6o98I,9294
+web3/_utils/rpc_abi.py,sha256=IYKHWrHOHpEajZP0mAx4xE5Qr-UzVlF-8SbFzsXBCwg,9357
 web3/_utils/threads.py,sha256=ZaBg_daNU_eI3nWtyAR8aQYM-ETTSoNchpfRyw6lEbQ,4208
-web3/_utils/transactions.py,sha256=5bWHkXvA1RYQlgSOEEZN6QbAl7AqoNQPVp6m3lA8bV0,8737
+web3/_utils/transactions.py,sha256=YaFDLXS69F75WJ9ccXkUJHZLebAJactHFpWR12y7jFk,8839
 web3/_utils/type_conversion.py,sha256=P9ojTqFASnlFEIA_Pf_BA3YJB4Ok4P0E_aGJw7FinNc,816
 web3/_utils/utility_methods.py,sha256=7VCpo5ysvPoGjFuDj5gT1Niva2l3BADUvNeJFlL3Yvg,2559
 web3/_utils/validation.py,sha256=5JBDbu8Azw4bgmN-QARRh6WFiZiX2VABl2zVsv9z0rc,6291
@@ -86,7 +86,7 @@ web3/_utils/contract_sources/contract_data/storage_contract.py,sha256=NhoWNlWltN
 web3/_utils/contract_sources/contract_data/string_contract.py,sha256=zZdglZ6se_aqMIUKN3-3zR57h8zyDyUQIgtSIXtdSzg,11586
 web3/_utils/contract_sources/contract_data/tuple_contracts.py,sha256=qt0cGM1Kh-LlRYn04-fpSPQJAWcGrvP8EKPCJvsrnvE,23180
 web3/_utils/module_testing/__init__.py,sha256=_AuZ0S4xesS7ocRdMHeTN6zju7KqpSsG4NXgmccJonU,455
-web3/_utils/module_testing/eth_module.py,sha256=tY5ei3oE0x-kttHXxorYgu_Vr6Qo6ZmzbQRWSL7TcDA,181815
+web3/_utils/module_testing/eth_module.py,sha256=yEYd-at1TFPOWMw2yFd2sRQidkCeMUuwfyjcAoEOeBU,184153
 web3/_utils/module_testing/go_ethereum_admin_module.py,sha256=_c-6SyzZkfAJ-7ySXUpw9FEr4cg-ShRdAGSAHWanCtY,3406
 web3/_utils/module_testing/go_ethereum_personal_module.py,sha256=PRX1dxqxGydHWyzcGVa0EP0IUoiSQyDYaszbmmXDKTU,10432
 web3/_utils/module_testing/go_ethereum_txpool_module.py,sha256=5f8XL8-2x3keyGRaITxMQYl9oQzjgqGn8zobB-j9BPs,1176
@@ -103,13 +103,13 @@ web3/beacon/async_beacon.py,sha256=y7cvbsDYjRNDZftzcJyXaSLCsRrASAGxfyCwE53oCG4,7
 web3/beacon/beacon.py,sha256=wgSmF-5hu_95L6onnlA33ADDoASFf9OZf-YWnqnY0VY,6640
 web3/contract/__init__.py,sha256=EX_RmT8D2DDKKsk1U8grCNdLq9b1rF-8xWaR53CBiew,187
 web3/contract/async_contract.py,sha256=oxxq5Pse4JkrRvPnecbF5eYwKg_FX17ltiHLvxiRj6Q,20392
-web3/contract/base_contract.py,sha256=TmG2l61YkX4lFN8u1e4PoqpNp5irx2HA3BfiX_LSVaA,37551
+web3/contract/base_contract.py,sha256=KuexzVWApCVL5c1VTMPZHDI40K20SR_JrqHWfjZJd0o,37552
 web3/contract/contract.py,sha256=mNrGoMvxdKHRecoMxT7KDEWK0hCKqPoH6DX7yqD78As,19997
 web3/contract/utils.py,sha256=ozHDwk1JoCYlFV6LX2upYlgQhcW6zOP4eQ0jOHJzboA,12462
 web3/eth/__init__.py,sha256=CrYZXIlIdKTmznnLNUaA-C3eLvftBnmlVt9uxm-dwAI,124
-web3/eth/async_eth.py,sha256=peNTqwrN3whyWQdYJQR6P9oGz8tlriEVWbbctzTOLag,23466
+web3/eth/async_eth.py,sha256=4Ook7jJD93KAk-qs4QNOR-R6ct5F7AvQx3fqQhoMBIY,23929
 web3/eth/base_eth.py,sha256=WC1BRE1QOhPV417Od2NSu28fnyXTjKQ9YVqTU3W3N0A,6822
-web3/eth/eth.py,sha256=MLReiFi2VeFMrgYU706CPXRArsReMuZsD38p1cvWDNw,20460
+web3/eth/eth.py,sha256=4hSSI0bIoGnOdc4yJz2dMH_Wrt3jxcB-3hMqlwU7xI4,20839
 web3/gas_strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/gas_strategies/rpc.py,sha256=3Va-32jdmHkX7tzQCmh17ms2D6te5zZcqHP1326BdpY,352
 web3/gas_strategies/time_based.py,sha256=xWj3WyA8UL76KTNAbMWLiWwD-UYuWyFttclHoXuP1gg,9169
@@ -138,9 +138,9 @@ web3/providers/eth_tester/main.py,sha256=I7NuZT8fA2CoSN-I-3UekcXrY-P1wb7sa6tzeQy
 web3/providers/eth_tester/middleware.py,sha256=ZV8JFObcCzIKi_Xkne00qW-ttDmp30iTveXJps5IOvU,12882
 web3/providers/persistent/__init__.py,sha256=S1s8m1cjPOjD-CCrWrLDP0PGlP1FUqgEw2KdrDeMPgk,283
 web3/providers/persistent/async_ipc.py,sha256=FW01Z5hzT0NE0izCN5AVMZIYbHxpqCR62tzt2xNO6Dw,7277
-web3/providers/persistent/persistent.py,sha256=wQpQC-7c268KrUqopgX2EAvwJmt-grHQHjbmKrTyDlA,3550
+web3/providers/persistent/persistent.py,sha256=qvozc8VX8Xv0JFPUcHdHsi6FpdD-QrAirKFinSl2i_I,3556
 web3/providers/persistent/persistent_connection.py,sha256=56yjpwDMM2phkJ_M5_QB-A6_CjZc5VrkWhNDweA70d0,1109
-web3/providers/persistent/request_processor.py,sha256=SLrclcWs7QKL8Cx4K3amGjneB836qYszapmvMyBZwWM,11545
+web3/providers/persistent/request_processor.py,sha256=zneKvSK7nopN0V2qo7O5halnXTUgneJteSibss06YSI,11495
 web3/providers/persistent/utils.py,sha256=gfY7w1HB8xuE7OujSrbwWYjQuQ8nzRBoxoL8ESinqWM,1140
 web3/providers/persistent/websocket.py,sha256=N70-qqitPT5eqNdlQrvZXgETabG3ZImTv99111LkgX8,6914
 web3/providers/rpc/__init__.py,sha256=d20CaZ6vOXlud5sh6I5JnT_zEGBMpbXl-vCDFMxBNoY,89
@@ -150,14 +150,19 @@ web3/providers/rpc/utils.py,sha256=hjw0_tzBvJ6eBsQak9xzo37ODMGhKTAlLjeSoSZk39k,2
 web3/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/release/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web3/scripts/release/test_package.py,sha256=DH0AryllcF4zfpWSd0NLPSQGHNoC-Qng5WYYbS5_4c8,1534
+web3/tools/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+web3/tools/benchmark/main.py,sha256=OAT7klotT1vnFO5AKo4PB9D9nRTb4BeLl7Lcj55yzcw,5356
+web3/tools/benchmark/node.py,sha256=IYyXmVyACF6R0xch9_9Ow24a7HuH8aOcZ2iA2sxOYvo,3501
+web3/tools/benchmark/reporting.py,sha256=G2bj_Eo2kBV06GARDYK9zr0VqesiR0_5JLKvhAo6zRM,912
+web3/tools/benchmark/utils.py,sha256=GjSofFEq3ugFtpyBlAx7n6cgZrQ5Xu4-hN_36bQBwnA,1722
 web3/utils/__init__.py,sha256=pswH3MW_mro5zrHn_q8Pto-iS1jrbtEH3UtQ9qioiKM,455
 web3/utils/abi.py,sha256=naNkD7_XQGV8hd4CkxytLKWCcgzUjkb7q3ERwRVNICI,498
 web3/utils/address.py,sha256=KC_IpEbixSCuMhaW6V2QCyyJTYKYGS9c8QtI9_aH7zQ,967
 web3/utils/async_exception_handling.py,sha256=gfLuzP7Y5rc21jZVjWEYAOZUMJkJd9CmsL297UKReow,3096
-web3/utils/caching.py,sha256=udHytI9q1i0UdELR5B4DB95yNn1Hzu3AL0Skz2Zul0I,1693
+web3/utils/caching.py,sha256=4U-vh61m1dlslwEn_Nl7ybIlMF4W2IAcvMTH-iFzrNM,1618
 web3/utils/exception_handling.py,sha256=12xkzIqMAOx0Jcm6PYL98PmWlLPKFll0p9YoLGS_ZNg,3052
-web3-7.0.0b2.dist-info/LICENSE,sha256=ulnXiEqqFp9VyWe8yMFdtDi70RMBJk3mpY3FKujv6l8,1090
-web3-7.0.0b2.dist-info/METADATA,sha256=icThzoL5lnZpzD97-_-ljvg7XJS6P1TvjhnBWNjcsTw,4502
-web3-7.0.0b2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-web3-7.0.0b2.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
-web3-7.0.0b2.dist-info/RECORD,,
+web3-7.0.0b3.dist-info/LICENSE,sha256=ulnXiEqqFp9VyWe8yMFdtDi70RMBJk3mpY3FKujv6l8,1090
+web3-7.0.0b3.dist-info/METADATA,sha256=thR0SIhg9znLbCimjfWjHS2iwW5OodxYkbSh-8PqV6c,4605
+web3-7.0.0b3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+web3-7.0.0b3.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
+web3-7.0.0b3.dist-info/RECORD,,