web3 7.0.0b9__py3-none-any.whl → 7.1.0__py3-none-any.whl

web3/beacon/api_endpoints.py

@@ -26,6 +26,9 @@ GET_BLINDED_BLOCKS = "/eth/v1/beacon/blinded_blocks/{0}"
 # rewards
 GET_REWARDS = "/eth/v1/beacon/rewards/blocks/{0}"
 
+# blobs
+GET_BLOB_SIDECARS = "/eth/v1/beacon/blob_sidecars/{0}"
+
 # light client
 GET_LIGHT_CLIENT_BOOTSTRAP_STRUCTURE = "/eth/v1/beacon/light_client/bootstrap/{0}"
 GET_LIGHT_CLIENT_UPDATES = "/eth/v1/beacon/light_client/updates"

web3/beacon/async_beacon.py

@@ -1,6 +1,8 @@
 from typing import (
     Any,
     Dict,
+    List,
+    Optional,
 )
 
 from eth_typing import (
@@ -17,6 +19,7 @@ from web3.beacon.api_endpoints import (
     GET_BEACON_HEADS,
     GET_BEACON_STATE,
     GET_BLINDED_BLOCKS,
+    GET_BLOB_SIDECARS,
     GET_BLOCK,
     GET_BLOCK_ATTESTATIONS,
     GET_BLOCK_HEADER,
@@ -64,10 +67,12 @@ class AsyncBeacon:
         self.request_timeout = request_timeout
         self._request_session_manager = HTTPSessionManager()
 
-    async def _async_make_get_request(self, endpoint_uri: str) -> Dict[str, Any]:
+    async def _async_make_get_request(
+        self, endpoint_uri: str, params: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
         uri = URI(self.base_url + endpoint_uri)
         return await self._request_session_manager.async_json_make_get_request(
-            uri, timeout=self.request_timeout
+            uri, params=params, timeout=self.request_timeout
         )
 
     # [ BEACON endpoints ]
@@ -220,3 +225,14 @@ class AsyncBeacon:
 
     async def get_syncing(self) -> Dict[str, Any]:
         return await self._async_make_get_request(GET_SYNCING)
+
+    # [ BLOB endpoints ]
+
+    async def get_blob_sidecars(
+        self, block_id: str, indices: Optional[List[int]] = None
+    ) -> Dict[str, Any]:
+        indices_param = {"indices": ",".join(map(str, indices))} if indices else None
+        return await self._async_make_get_request(
+            GET_BLOB_SIDECARS.format(block_id),
+            params=indices_param,
+        )

web3/beacon/beacon.py

@@ -1,6 +1,8 @@
 from typing import (
     Any,
     Dict,
+    List,
+    Optional,
 )
 
 from eth_typing import (
@@ -17,6 +19,7 @@ from web3.beacon.api_endpoints import (
     GET_BEACON_HEADS,
     GET_BEACON_STATE,
     GET_BLINDED_BLOCKS,
+    GET_BLOB_SIDECARS,
     GET_BLOCK,
     GET_BLOCK_ATTESTATIONS,
     GET_BLOCK_HEADER,
@@ -62,10 +65,12 @@ class Beacon:
         self.request_timeout = request_timeout
         self._request_session_manager = HTTPSessionManager()
 
-    def _make_get_request(self, endpoint_url: str) -> Dict[str, Any]:
+    def _make_get_request(
+        self, endpoint_url: str, params: Optional[Dict[str, str]] = None
+    ) -> Dict[str, Any]:
         uri = URI(self.base_url + endpoint_url)
         return self._request_session_manager.json_make_get_request(
-            uri, timeout=self.request_timeout
+            uri, params=params, timeout=self.request_timeout
         )
 
     # [ BEACON endpoints ]
@@ -206,3 +211,14 @@ class Beacon:
 
     def get_syncing(self) -> Dict[str, Any]:
         return self._make_get_request(GET_SYNCING)
+
+    # [ BLOB endpoints ]
+
+    def get_blob_sidecars(
+        self, block_id: str, indices: Optional[List[int]] = None
+    ) -> Dict[str, Any]:
+        indices_param = {"indices": ",".join(map(str, indices))} if indices else None
+        return self._make_get_request(
+            GET_BLOB_SIDECARS.format(block_id),
+            params=indices_param,
+        )

web3/contract/async_contract.py

@@ -319,8 +319,8 @@ class AsyncContractFunction(BaseContractFunction):
             state_override,
             ccip_read_enabled,
             self.decode_tuples,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     async def transact(self, transaction: Optional[TxParams] = None) -> HexBytes:
@@ -332,8 +332,8 @@ class AsyncContractFunction(BaseContractFunction):
             setup_transaction,
             self.contract_abi,
             self.abi,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     async def estimate_gas(
@@ -352,8 +352,8 @@ class AsyncContractFunction(BaseContractFunction):
             self.abi,
             block_identifier,
             state_override,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     async def build_transaction(
@@ -367,8 +367,8 @@ class AsyncContractFunction(BaseContractFunction):
             built_transaction,
             self.contract_abi,
             self.abi,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     @staticmethod

web3/contract/contract.py

@@ -318,12 +318,13 @@ class ContractFunction(BaseContractFunction):
             state_override,
             ccip_read_enabled,
             self.decode_tuples,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     def transact(self, transaction: Optional[TxParams] = None) -> HexBytes:
         setup_transaction = self._transact(transaction)
+
         return transact_with_contract_function(
             self.address,
             self.w3,
@@ -331,8 +332,8 @@ class ContractFunction(BaseContractFunction):
             setup_transaction,
             self.contract_abi,
             self.abi,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     def estimate_gas(
@@ -351,12 +352,13 @@ class ContractFunction(BaseContractFunction):
             self.abi,
             block_identifier,
             state_override,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     def build_transaction(self, transaction: Optional[TxParams] = None) -> TxParams:
         built_transaction = self._build_transaction(transaction)
+
         return build_transaction_for_function(
             self.address,
             self.w3,
@@ -364,8 +366,8 @@ class ContractFunction(BaseContractFunction):
             built_transaction,
             self.contract_abi,
             self.abi,
-            *self.args,
-            **self.kwargs,
+            *self.args or (),
+            **self.kwargs or {},
         )
 
     @staticmethod

web3/datastructures.py

@@ -182,7 +182,7 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         if name is None:
             name = cast(TKey, element)
 
-        name = self._repr_if_not_hashable(name)
+        name = self._build_name(name)
 
         if name in self._queue:
             if name is element:
@@ -219,7 +219,7 @@ class NamedElementOnion(Mapping[TKey, TValue]):
             if name is None:
                 name = cast(TKey, element)
 
-            name = self._repr_if_not_hashable(name)
+            name = self._build_name(name)
 
             self._queue.move_to_end(name, last=False)
         elif layer == len(self._queue):
@@ -233,7 +233,7 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         self._queue.clear()
 
     def replace(self, old: TKey, new: TKey) -> TValue:
-        old_name = self._repr_if_not_hashable(old)
+        old_name = self._build_name(old)
 
         if old_name not in self._queue:
             raise Web3ValueError(
@@ -248,15 +248,25 @@ class NamedElementOnion(Mapping[TKey, TValue]):
             self._queue[old_name] = new
         return to_be_replaced
 
-    def _repr_if_not_hashable(self, value: TKey) -> TKey:
+    @staticmethod
+    def _build_name(value: TKey) -> TKey:
         try:
             value.__hash__()
+            return value
         except TypeError:
-            value = cast(TKey, repr(value))
-        return value
+            # unhashable, unnamed elements
+            if not callable(value):
+                raise Web3TypeError(
+                    f"Expected a callable or hashable type, got {type(value)}"
+                )
+            # This will either be ``Web3Middleware`` class or the ``build`` method of a
+            # ``Web3MiddlewareBuilder``. Instantiate with empty ``Web3`` and use a
+            # unique identifier with the ``__hash__()`` as the name.
+            v = value(None)
+            return cast(TKey, f"{v.__class__}<{v.__hash__()}>")
 
     def remove(self, old: TKey) -> None:
-        old_name = self._repr_if_not_hashable(old)
+        old_name = self._build_name(old)
         if old_name not in self._queue:
             raise Web3ValueError("You can only remove something that has been added")
         del self._queue[old_name]
@@ -270,8 +280,8 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         return [(val, key) for key, val in reversed(self._queue.items())]
 
     def _replace_with_new_name(self, old: TKey, new: TKey) -> None:
-        old_name = self._repr_if_not_hashable(old)
-        new_name = self._repr_if_not_hashable(new)
+        old_name = self._build_name(old)
+        new_name = self._build_name(new)
 
         self._queue[new_name] = new
         found_old = False
@@ -293,11 +303,11 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         return NamedElementOnion(cast(List[Any], combined.items()))
 
     def __contains__(self, element: Any) -> bool:
-        element_name = self._repr_if_not_hashable(element)
+        element_name = self._build_name(element)
         return element_name in self._queue
 
     def __getitem__(self, element: TKey) -> TValue:
-        element_name = self._repr_if_not_hashable(element)
+        element_name = self._build_name(element)
         return self._queue[element_name]
 
     def __len__(self) -> int:

web3/middleware/base.py

@@ -40,6 +40,14 @@ class Web3Middleware:
     def __init__(self, w3: Union["AsyncWeb3", "Web3"]) -> None:
         self._w3 = w3
 
+    def __hash__(self) -> int:
+        return hash(f"{self.__class__.__name__}({str(self.__dict__)})")
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, Web3Middleware):
+            return False
+        return self.__hash__() == other.__hash__()
+
     # -- sync -- #
 
     def wrap_make_request(self, make_request: "MakeRequestFn") -> "MakeRequestFn":

web3/scripts/install_pre_releases.py

@@ -0,0 +1,33 @@
+"""
+The goal of this script is to install the latest versions, including pre-releases, for
+libraries that we maintain (and therefore control the release process) during our CI
+runs. This helps us test pre-releases before they cause any issues once stable versions
+are released.
+"""
+
+import subprocess
+import sys
+
+ETHEREUM_LIBRARIES = [
+    "eth-account",
+    "eth-abi",
+    "eth-account",
+    "eth-hash[pycryptodome]",
+    "eth-typing",
+    "eth-utils",
+    "hexbytes",
+    "eth-tester[py-evm]",
+    "py-geth",
+]
+
+
+def install_eth_pre_releases() -> None:
+    for lib in ETHEREUM_LIBRARIES:
+        print(f"Installing {lib} with `--pre` and `-U`")
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "--pre", "-U", lib]
+        )
+
+
+if __name__ == "__main__":
+    install_eth_pre_releases()

web3/scripts/parse_pygeth_version.py

@@ -0,0 +1,16 @@
+import re
+
+
+def get_pygeth_version() -> str:
+    with open("setup.py") as f:
+        setup_contents = f.read()
+    version_match = re.search(r"py-geth\s*([><=~!]+)\s*([\d.]+)", setup_contents)
+    if version_match:
+        return "".join(version_match.group(1, 2))
+    else:
+        raise ValueError("py-geth not found in setup.py")
+
+
+if __name__ == "__main__":
+    version = get_pygeth_version()
+    print(version)

web3/tools/benchmark/main.py

@@ -0,0 +1,190 @@
+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 -- #
+            account = w3_http.eth.accounts[0]
+
+            # -- async -- #
+            async_w3_http = loop.run_until_complete(
+                build_async_w3_http(fixture.endpoint_uri)
+            )
+            async_accounts = loop.run_until_complete(async_w3_http.eth.accounts)
+            async_account = async_accounts[0]
+
+            methods = [
+                {
+                    "name": "eth_gasPrice",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http: w3_http.eth.gas_price,
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.gas_price,  # noqa: E501
+                },
+                {
+                    "name": "eth_sendTransaction",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http, account=account: w3_http.eth.send_transaction(  # noqa: E501
+                        {
+                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
+                            "from": account,
+                            "value": Wei(1),
+                        }
+                    ),
+                    "async_exec": lambda async_w3_http=async_w3_http, async_account=async_account: async_w3_http.eth.send_transaction(  # noqa: E501
+                        {
+                            "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
+                            "from": async_account,
+                            "value": Wei(1),
+                        }
+                    ),
+                },
+                {
+                    "name": "eth_blockNumber",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http: w3_http.eth.block_number,
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.block_number,  # noqa: E501
+                },
+                {
+                    "name": "eth_getBlock",
+                    "params": {},
+                    "exec": lambda w3_http=w3_http: w3_http.eth.get_block(1),
+                    "async_exec": lambda async_w3_http=async_w3_http: async_w3_http.eth.get_block(  # noqa: E501
+                        1
+                    ),
+                },
+            ]
+
+            def benchmark(
+                method: Dict[str, Any], loop: asyncio.AbstractEventLoop = loop
+            ) -> 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,120 @@
+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.14.5-fixture.zip"
+
+
+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",
+            datadir,
+            "--nodiscover",
+            "--http",
+            "--http.port",
+            self.rpc_port,
+            "--http.api",
+            "admin,eth,net,web3",
+            "--ipcdisable",
+            "--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 OSError:
+            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-7.0.0b9.dist-info → web3-7.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b9
+Version: 7.1.0
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -20,13 +20,13 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.8, <4
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aiohttp >=3.7.4.post0
 Requires-Dist: eth-abi >=5.0.1
 Requires-Dist: eth-account >=0.13.1
 Requires-Dist: eth-hash[pycryptodome] >=0.5.1
-Requires-Dist: eth-typing >=5.0.0b3
-Requires-Dist: eth-utils >=5.0.0b1
+Requires-Dist: eth-typing >=5.0.0
+Requires-Dist: eth-utils >=5.0.0
 Requires-Dist: hexbytes >=1.2.0
+Requires-Dist: aiohttp >=3.7.4.post0
 Requires-Dist: pydantic >=2.4.0
 Requires-Dist: requests >=2.23.0
 Requires-Dist: typing-extensions >=4.0.1
@@ -53,9 +53,8 @@ Requires-Dist: sphinx >=6.0.0 ; extra == 'dev'
 Requires-Dist: sphinx-autobuild >=2021.3.14 ; extra == 'dev'
 Requires-Dist: sphinx-rtd-theme >=1.0.0 ; extra == 'dev'
 Requires-Dist: towncrier <22,>=21 ; extra == 'dev'
-Requires-Dist: eth-account >=0.13.0 ; extra == 'dev'
 Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.11.0b1 ; extra == 'dev'
-Requires-Dist: py-geth >=5.0.0b1 ; extra == 'dev'
+Requires-Dist: py-geth >=5.0.0 ; extra == 'dev'
 Requires-Dist: pytest-asyncio <0.23,>=0.18.1 ; extra == 'dev'
 Requires-Dist: pytest-xdist >=2.4.0 ; extra == 'dev'
 Requires-Dist: pytest >=7.0.0 ; extra == 'dev'
@@ -64,10 +63,9 @@ Requires-Dist: sphinx >=6.0.0 ; extra == 'docs'
 Requires-Dist: sphinx-autobuild >=2021.3.14 ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme >=1.0.0 ; extra == 'docs'
 Requires-Dist: towncrier <22,>=21 ; extra == 'docs'
-Requires-Dist: eth-account >=0.13.0 ; extra == 'docs'
 Provides-Extra: test
 Requires-Dist: eth-tester[py-evm] <0.13.0b1,>=0.11.0b1 ; extra == 'test'
-Requires-Dist: py-geth >=5.0.0b1 ; extra == 'test'
+Requires-Dist: py-geth >=5.0.0 ; extra == 'test'
 Requires-Dist: pytest-asyncio <0.23,>=0.18.1 ; extra == 'test'
 Requires-Dist: pytest-mock >=1.10 ; extra == 'test'
 Requires-Dist: pytest-xdist >=2.4.0 ; extra == 'test'

{web3-7.0.0b9.dist-info → web3-7.1.0.dist-info}/RECORD

@@ -13,7 +13,7 @@ ens/specs/nf.json,sha256=kGZcTE_UxTl3WZwMUP6m8KbQQOKdw7PWzmuW7ewQSUs,48403
 ens/specs/normalization_spec.json,sha256=xn3N9a-6KHMLu3MeCBsmOxSzIzUQykzE9EscKK1a3w8,3115334
 web3/__init__.py,sha256=P11QAEV_GYoZq9ij8gDzFx5tKzJY2aMXG-keg2Lg1xs,1277
 web3/constants.py,sha256=eQLRQVMFPbgpOjjkPTMHkY-syncJuO-sPX5UrCSRjzQ,564
-web3/datastructures.py,sha256=Yc45cXgoXvhV0HPvnmkFFOEVDtLr-Pftc_f5q-uQY1M,10939
+web3/datastructures.py,sha256=LbUsfE0icgRRTXsC_LATR-LtmO7MAYwYB5D-6LCX1jE,11366
 web3/exceptions.py,sha256=5Yc-tUdmcnwGv1dxg45iD3Tor3IKMfedA9U_xZ4AR3M,9081
 web3/geth.py,sha256=IQYeqiVSqcskuXWgDR35UBuVsD-whhvTpDltO4vvCvE,5867
 web3/logs.py,sha256=ROs-mDMH_ZOecE7hfbWA5yp27G38FbLjX4lO_WtlZxQ,198
@@ -97,13 +97,13 @@ web3/_utils/module_testing/web3_module.py,sha256=7c6penGbHn381fPTYY6DsXKv56xGQpY
 web3/auto/__init__.py,sha256=ZbzAiCZMdt_tCTTPvH6t8NCVNroKKkt7TSVBBNR74Is,44
 web3/auto/gethdev.py,sha256=MuWD2gxv0xDv_SzPsp9mSkS1oG4P54xFK83qw9NvswA,438
 web3/beacon/__init__.py,sha256=Ac6YiNgU8D8Ynnh5RwSCx2NwPyjnpFjpXeHuSssFbaU,113
-web3/beacon/api_endpoints.py,sha256=dkekSCmkat5QIfwKzwm49CyVcRb-pIbn1nZHB4F8M0U,2208
-web3/beacon/async_beacon.py,sha256=5PErS2VjhNj-GPg3WKxxJv02ZZWyu3m46sWjGMpi33A,7602
-web3/beacon/beacon.py,sha256=NT4ebD53uesPj8I0CpqkBJ_U-o2_QFLRVM7tNnlVY0Q,6758
+web3/beacon/api_endpoints.py,sha256=0mHrYFYAWHfF9OGzrFdg012L_ocU2nGDXUTU1isOo7o,2272
+web3/beacon/async_beacon.py,sha256=9-V-rfPwj-SbksHKSYs2Quk8frE2AJXjH908cbSM8v0,8098
+web3/beacon/beacon.py,sha256=tPA9ABPm6MyzbzutiphkhFzOAxLresmftG5UjWkuNyY,7236
 web3/contract/__init__.py,sha256=qeZRtTw9xriwoD82w6vePDuPBZ35-CMVdkzViBSH3Qs,293
-web3/contract/async_contract.py,sha256=dkYeb4G9qwgSzL6cG0Bzjz915bqVzPCbkViSf0OKAg0,20545
+web3/contract/async_contract.py,sha256=KYB-e1GCTZINTRu0Y1f2IIp4LWg2UvKIRFFSIrsjfUs,20593
 web3/contract/base_contract.py,sha256=qfYzMC-PlefkAQVGplXwdYi5I37DwEe5Slbp5-oOc6U,38053
-web3/contract/contract.py,sha256=BO0Xm6sUo_PxhgUxe6fT1Qh3jR61ZiniTVeZjFGJ05c,20124
+web3/contract/contract.py,sha256=wB5g6H7PoAyp4wN__3GGXMrDCvEYuj6crZL4Q2ipTRE,20174
 web3/contract/utils.py,sha256=bonHXESnb9xhvMzJoi271qppwpy2D6yaHtUwt56wEJc,17853
 web3/eth/__init__.py,sha256=qDLxOcHHIzzPD7xzwy6Wcs0lLPQieB7WN0Ax25ctit8,197
 web3/eth/async_eth.py,sha256=elPH3Atkayk3afwepDRP3ibB7EK8MziK0fPikpKCLxI,23176
@@ -114,7 +114,7 @@ web3/gas_strategies/rpc.py,sha256=3Va-32jdmHkX7tzQCmh17ms2D6te5zZcqHP1326BdpY,35
 web3/gas_strategies/time_based.py,sha256=oGk6nBUD4iMC8wl1vzf-nhURaqyPWYdPvNU0C3RIs8g,9071
 web3/middleware/__init__.py,sha256=fSmPCYJOO8Qp5p-Vm_Z4XPJATu2qN7KJRypYNSO6_uM,2830
 web3/middleware/attrdict.py,sha256=NY5yxlFOfLBBmcIjl8R-uP2dTz9ITIyTttG8-QcJWCI,2259
-web3/middleware/base.py,sha256=AFIRLRxoQ63lEdhsRe-sATyHaYdiwNVklPOGc9ivXrA,5103
+web3/middleware/base.py,sha256=aHBUWc5pSohLUZ7zcCgrVqp_H_1PTqh31x2n6vWqzuY,5376
 web3/middleware/buffered_gas_estimate.py,sha256=EmxUd-uO959UVroPsPKkl7oDa8Tw6N8BQLB6Urng5Eo,1647
 web3/middleware/filter.py,sha256=I09sSE_q_dhWX5_24KVWhVXZNevwViI7wucJBP4TZl4,22221
 web3/middleware/formatting.py,sha256=hqe5XQE1n5Fmj6riJp7i3oIoZkd-4ChQc7UK8f3HB6I,7567
@@ -147,16 +147,23 @@ web3/providers/rpc/async_rpc.py,sha256=hibsCoyrAD199ExAEyHRsEnZ0_rDP_2EC2k5g-D2z
 web3/providers/rpc/rpc.py,sha256=ePlGdlkvQTaf2Wi2khxiY-rRj-OFcPlpDMuTPLKaAyU,5655
 web3/providers/rpc/utils.py,sha256=_mtoZMMIoZpPA8J8U5DfRxaNQmi8bw0ZVUiqn1Nz4co,2154
 web3/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+web3/scripts/install_pre_releases.py,sha256=uVxsZk239640yxiqlPhfXxZKSsh3858pURKppi9kM5U,821
+web3/scripts/parse_pygeth_version.py,sha256=BZjWOsJmYuFbAnFuB1jec9Rl6z0tJJNFFV38sJvDfGo,416
 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=9nBC8yvdiNPoRuNlcqKC6HKWly_iwOYSeG0cOQCjfpg,5810
+web3/tools/benchmark/node.py,sha256=n73GckmBKLm4_urC7HfF_Z3ZURffNMjq6ymzb9HM9c8,3252
+web3/tools/benchmark/reporting.py,sha256=G2bj_Eo2kBV06GARDYK9zr0VqesiR0_5JLKvhAo6zRM,912
+web3/tools/benchmark/utils.py,sha256=7OOdUD71AVWi0cowAE9ekMgqlfcJwk3vrNnMCHtiGdU,1696
 web3/utils/__init__.py,sha256=XwpyVR4EBkfqV5SHBH3maNyNBy624EwqujRgetLc7PU,1781
 web3/utils/abi.py,sha256=iSBaCW41UxB1q1UHDPwJ1QJbdiuYmTWNu8m6E28DqlY,18672
 web3/utils/address.py,sha256=KC_IpEbixSCuMhaW6V2QCyyJTYKYGS9c8QtI9_aH7zQ,967
 web3/utils/async_exception_handling.py,sha256=GZWSBFC0-Wmwz1tpTie-1AKRbIQH7JkmBpf5bXrUTzY,3320
 web3/utils/caching.py,sha256=IG_IxW-jyiRklrIyUgjOj3GQvcXrok0KLDX3ch_6wuA,2390
 web3/utils/exception_handling.py,sha256=k31JROfUyKIm9PoEWOtYSkIq9wL8SOBwQfnSLNQyfnM,3097
-web3-7.0.0b9.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
-web3-7.0.0b9.dist-info/METADATA,sha256=3h7NWNTTSiFvBC020AhFwyeTuENWivxCmfIrBNz8KzY,5103
-web3-7.0.0b9.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-web3-7.0.0b9.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
-web3-7.0.0b9.dist-info/RECORD,,
+web3-7.1.0.dist-info/LICENSE,sha256=ScEyLx1vWrB0ybKiZKKTXm5QhVksHCEUtTp4lwYV45I,1095
+web3-7.1.0.dist-info/METADATA,sha256=p_1iA6mObqMRYbT9SN-0xI9fr_Wh-AN6-fZcOknn1BU,4986
+web3-7.1.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+web3-7.1.0.dist-info/top_level.txt,sha256=iwupuJh7wgypXrpk_awszyri3TahRr5vxSphNyvt1bU,9
+web3-7.1.0.dist-info/RECORD,,

{web3-7.0.0b9.dist-info → web3-7.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (74.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any