web3 7.7.0__tar.gz → 7.8.0__tar.gz

{web3-7.7.0 → web3-7.8.0}/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2024 The Ethereum Foundation
+Copyright (c) 2016-2025 The Ethereum Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{web3-7.7.0/web3.egg-info → web3-7.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: web3
-Version: 7.7.0
+Version: 7.8.0
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation

{web3-7.7.0 → web3-7.8.0}/ens/async_ens.py

@@ -152,12 +152,12 @@ class AsyncENS(BaseENS):
         :param int coin_type: if provided, look up the address for this coin type
         :raises InvalidName: if `name` has invalid syntax
         """
-        r = await self.resolver(name)
         if coin_type is None:
             # don't validate `addr(bytes32)` interface id since extended resolvers
             # can implement a "resolve" function as of ENSIP-10
             return cast(ChecksumAddress, await self._resolve(name, "addr"))
         else:
+            r = await self.resolver(name)
             await _async_validate_resolver_and_interface_id(
                 name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
             )

{web3-7.7.0 → web3-7.8.0}/ens/ens.py

@@ -154,12 +154,12 @@ class ENS(BaseENS):
         :raises UnsupportedFunction: if the resolver does not support the ``addr()``
                 function
         """
-        r = self.resolver(name)
         if coin_type is None:
             # don't validate `addr(bytes32)` interface id since extended resolvers
             # can implement a "resolve" function as of ENSIP-10
             return cast(ChecksumAddress, self._resolve(name, "addr"))
         else:
+            r = self.resolver(name)
             _validate_resolver_and_interface_id(
                 name, r, ENS_MULTICHAIN_ADDRESS_INTERFACE_ID, "addr(bytes32,uint256)"
             )

{web3-7.7.0 → web3-7.8.0}/setup.py

@@ -55,7 +55,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. Use `make bump`, as described in readme
-    version="7.7.0",
+    version="7.8.0",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.7.0 → web3-7.8.0}/tests/beacon/test_async_beacon.py

@@ -256,6 +256,12 @@ async def test_async_cl_node_get_peer(async_beacon):
     _assert_valid_response(response)
 
 
+@pytest.mark.asyncio
+async def test_async_cl_node_get_peer_count(async_beacon):
+    response = await async_beacon.get_peer_count()
+    _assert_valid_response(response)
+
+
 @pytest.mark.asyncio
 async def test_async_cl_node_get_health(async_beacon):
     response = await async_beacon.get_health()
@@ -285,3 +291,82 @@ async def test_async_cl_node_get_blob_sidecars(async_beacon):
     # test with indices
     with_indices = await async_beacon.get_blob_sidecars("head", [0, 1])
     _assert_valid_response(with_indices)
+
+
+# Validator endpoint tests:
+
+
+@pytest.mark.asyncio
+async def test_async_cl_validator_get_attester_duties(async_beacon):
+    finality_checkpoint_response = await async_beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    validators_response = await async_beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_index = random_validator["index"]
+
+    response = await async_beacon.get_attester_duties(epoch, [random_validator_index])
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_validator_get_block_proposer_duties(async_beacon):
+    finality_checkpoint_response = await async_beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    response = await async_beacon.get_block_proposer_duties(epoch)
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_validator_get_sync_committee_duties(async_beacon):
+    finality_checkpoint_response = await async_beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    validators_response = await async_beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_index = random_validator["index"]
+
+    response = await async_beacon.get_sync_committee_duties(
+        epoch, [random_validator_index]
+    )
+    _assert_valid_response(response)
+
+
+# Rewards endpoint tests:
+
+
+@pytest.mark.asyncio
+async def test_async_cl_validator_get_attestations_rewards(async_beacon):
+    finality_checkpoint_response = await async_beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    validators_response = await async_beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_index = random_validator["index"]
+
+    response = await async_beacon.get_attestations_rewards(
+        epoch, [random_validator_index]
+    )
+    _assert_valid_response(response)

{web3-7.7.0 → web3-7.8.0}/tests/beacon/test_beacon.py

@@ -214,6 +214,11 @@ def test_cl_node_get_peer(beacon):
     _assert_valid_response(response)
 
 
+def test_cl_node_get_peer_count(beacon):
+    response = beacon.get_peer_count()
+    _assert_valid_response(response)
+
+
 def test_cl_node_get_health(beacon):
     response = beacon.get_health()
     assert isinstance(response, int)
@@ -239,3 +244,74 @@ def test_cl_node_get_blob_sidecars(beacon):
     # test with indices
     with_indices = beacon.get_blob_sidecars("head", [0, 1])
     _assert_valid_response(with_indices)
+
+
+# Validator endpoint tests:
+
+
+def test_cl_validator_get_attester_duties(beacon):
+    finality_checkpoint_response = beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    validators_response = beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_index = random_validator["index"]
+
+    response = beacon.get_attester_duties(epoch, [random_validator_index])
+    _assert_valid_response(response)
+
+
+def test_cl_validator_get_block_proposer_duties(beacon):
+    finality_checkpoint_response = beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    response = beacon.get_block_proposer_duties(epoch)
+    _assert_valid_response(response)
+
+
+def test_cl_validator_get_sync_committee_duties(beacon):
+    finality_checkpoint_response = beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    validators_response = beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_index = random_validator["index"]
+
+    response = beacon.get_sync_committee_duties(epoch, [random_validator_index])
+    _assert_valid_response(response)
+
+
+# Rewards endpoint tests:
+
+
+def test_cl_validator_get_attestations_rewards(beacon):
+    finality_checkpoint_response = beacon.get_finality_checkpoint()
+    _assert_valid_response(finality_checkpoint_response)
+
+    finality_checkpoint = finality_checkpoint_response["data"]
+    epoch = finality_checkpoint["finalized"]["epoch"]
+
+    validators_response = beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_index = random_validator["index"]
+
+    response = beacon.get_attestations_rewards(epoch, [random_validator_index])
+    _assert_valid_response(response)

{web3-7.7.0 → web3-7.8.0}/tests/core/contracts/test_contract_init.py

@@ -85,7 +85,7 @@ def test_init_multiple_contracts_performance(w3, emitter_contract_data):
             abi=emitter_contract_data["abi"], bytecode=emitter_contract_data["bytecode"]
         )
     # assert initializing 500 contracts is within a conservative / reasonable time
-    assert (time.time() - start_time) < 1.5
+    assert (time.time() - start_time) < 1.75
 
 
 # -- async -- #
@@ -98,4 +98,4 @@ def test_async_init_multiple_contracts_performance(async_w3, emitter_contract_da
             abi=emitter_contract_data["abi"], bytecode=emitter_contract_data["bytecode"]
         )
     # assert initializing 500 contracts is within a conservative / reasonable time
-    assert (time.time() - start_time) < 1.5
+    assert (time.time() - start_time) < 1.75

{web3-7.7.0 → web3-7.8.0}/tests/core/datastructures/test_datastructures.py

@@ -4,8 +4,12 @@ import re
 
 from web3.datastructures import (
     AttributeDict,
+    NamedElementOnion,
     tupleize_lists_nested,
 )
+from web3.middleware import (
+    GasPriceStrategyMiddleware,
+)
 
 
 def generate_random_value(depth=0, max_depth=3, key_type=None):
@@ -207,3 +211,11 @@ def test_AttributeDict_hashing_backwards_compatibility(input, error):
             assert hash(tuple(sorted(input.items()))) == hash(input)
     else:
         assert hash(tuple(sorted(input.items()))) == hash(input)
+
+
+def test_NamedElementOnion_values():
+    middleware = GasPriceStrategyMiddleware(None)
+    initial_items = [(middleware, "gas_price_strategy")]
+    named_element_onion = NamedElementOnion(initial_items)
+    actual = [x for x in named_element_onion.values()]
+    assert actual == [middleware]

{web3-7.7.0 → web3-7.8.0}/tests/core/providers/test_async_http_provider.py

@@ -1,4 +1,8 @@
 import pytest
+from unittest.mock import (
+    AsyncMock,
+    patch,
+)
 
 from aiohttp import (
     ClientSession,
@@ -13,6 +17,7 @@ from web3.eth import (
 )
 from web3.exceptions import (
     ProviderConnectionError,
+    Web3RPCError,
 )
 from web3.geth import (
     AsyncGeth,
@@ -107,3 +112,21 @@ def test_get_request_headers(provider):
         headers["User-Agent"] == f"web3.py/{web3py_version}/"
         f"{AsyncHTTPProvider.__module__}.{AsyncHTTPProvider.__qualname__}"
     )
+
+
+@patch(
+    "web3._utils.http_session_manager.HTTPSessionManager.async_make_post_request",
+    new_callable=AsyncMock,
+)
+@pytest.mark.asyncio
+async def test_async_http_empty_batch_response(mock_async_post):
+    mock_async_post.return_value = (
+        b'{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"empty batch"}}'
+    )
+    async_w3 = AsyncWeb3(AsyncHTTPProvider())
+    async with async_w3.batch_requests() as batch:
+        with pytest.raises(Web3RPCError, match="empty batch"):
+            await batch.async_execute()
+
+    # assert that even though there was an error, we have reset the batching state
+    assert not async_w3.provider._is_batching

{web3-7.7.0 → web3-7.8.0}/tests/core/providers/test_async_ipc_provider.py

@@ -25,6 +25,7 @@ from web3.datastructures import (
 )
 from web3.exceptions import (
     ReadBufferLimitReached,
+    Web3RPCError,
 )
 from web3.providers import (
     AsyncIPCProvider,
@@ -366,3 +367,24 @@ async def test_async_ipc_provider_write_messages_end_with_new_line_delimiter(
 
         request_data = b'{"id": 0, "jsonrpc": "2.0", "method": "method", "params": []}'
         w3.provider._writer.write.assert_called_with(request_data + b"\n")
+
+
+@pytest.mark.asyncio
+async def test_persistent_connection_provider_empty_batch_response(
+    simple_ipc_server,
+    jsonrpc_ipc_pipe_path,
+):
+    async with AsyncWeb3(
+        AsyncIPCProvider(pathlib.Path(jsonrpc_ipc_pipe_path))
+    ) as async_w3:
+        async_w3.provider._reader.readline = AsyncMock()
+        async_w3.provider._reader.readline.return_value = (
+            b'{"jsonrpc": "2.0","id":null,"error": {"code": -32600, "message": '
+            b'"empty batch"}}\n'
+        )
+        async with async_w3.batch_requests() as batch:
+            with pytest.raises(Web3RPCError, match="empty batch"):
+                await batch.async_execute()
+
+        # assert that even though there was an error, we have reset the batching state
+        assert not async_w3.provider._is_batching

{web3-7.7.0 → web3-7.8.0}/tests/core/providers/test_http_provider.py

@@ -1,4 +1,8 @@
 import pytest
+from unittest.mock import (
+    Mock,
+    patch,
+)
 
 from requests import (
     Session,
@@ -16,6 +20,7 @@ from web3.eth import (
 )
 from web3.exceptions import (
     ProviderConnectionError,
+    Web3RPCError,
 )
 from web3.geth import (
     Geth,
@@ -110,3 +115,20 @@ def test_get_request_headers(provider):
         headers["User-Agent"] == f"web3.py/{web3py_version}/"
         f"{HTTPProvider.__module__}.{HTTPProvider.__qualname__}"
     )
+
+
+@patch(
+    "web3._utils.http_session_manager.HTTPSessionManager.make_post_request",
+    new_callable=Mock,
+)
+def test_http_empty_batch_response(mock_post):
+    mock_post.return_value = (
+        b'{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"empty batch"}}'
+    )
+    w3 = Web3(HTTPProvider())
+    with w3.batch_requests() as batch:
+        with pytest.raises(Web3RPCError, match="empty batch"):
+            batch.execute()
+
+    # assert that even though there was an error, we have reset the batching state
+    assert not w3.provider._is_batching

{web3-7.7.0 → web3-7.8.0}/tests/core/providers/test_websocket_provider.py

@@ -27,6 +27,7 @@ from web3._utils.module_testing.module_testing_utils import (
 )
 from web3.exceptions import (
     TimeExhausted,
+    Web3RPCError,
 )
 from web3.providers.persistent import (
     WebSocketProvider,
@@ -432,3 +433,24 @@ async def test_listener_task_breaks_out_of_handle_subscriptions_when_cancelled()
     # up the exception.
     with pytest.raises(asyncio.CancelledError):
         await async_w3.subscription_manager.handle_subscriptions(run_forever=True)
+
+
+@pytest.mark.asyncio
+async def test_persistent_connection_provider_empty_batch_response():
+    with patch(
+        "web3.providers.persistent.websocket.connect",
+        new=lambda *_1, **_2: _mocked_ws_conn(),
+    ):
+        async with AsyncWeb3(WebSocketProvider("ws://mocked")) as async_w3:
+            async_w3.provider._ws.recv = AsyncMock()
+            async_w3.provider._ws.recv.return_value = (
+                b'{"jsonrpc": "2.0","id":null,"error": {"code": -32600, "message": '
+                b'"empty batch"}}\n'
+            )
+            async with async_w3.batch_requests() as batch:
+                with pytest.raises(Web3RPCError, match="empty batch"):
+                    await batch.async_execute()
+
+            # assert that even though there was an error, we have reset the batching
+            # state
+            assert not async_w3.provider._is_batching

{web3-7.7.0 → web3-7.8.0}/tests/core/subscriptions/test_subscription_manager.py

@@ -4,6 +4,9 @@ from unittest.mock import (
     AsyncMock,
 )
 
+from eth_typing import (
+    HexStr,
+)
 import pytest_asyncio
 
 from web3 import (
@@ -40,19 +43,43 @@ async def subscription_manager():
 
 
 @pytest.mark.asyncio
-async def test_subscription_manager_raises_for_sub_with_the_same_label(
+async def test_subscription_default_labels_are_unique(subscription_manager):
+    sub1 = NewHeadsSubscription()
+    sub2 = NewHeadsSubscription()
+    sub3 = NewHeadsSubscription()
+    sub4 = NewHeadsSubscription()
+
+    sub_ids = await subscription_manager.subscribe([sub1, sub2, sub3, sub4])
+    assert sub_ids == ["0x0", "0x1", "0x2", "0x3"]
+
+    assert sub1.label != sub2.label != sub3.label != sub4.label
+    assert sub1.label == "NewHeadsSubscription('newHeads',)"
+    assert sub2.label == "NewHeadsSubscription('newHeads',)#2"
+    assert sub3.label == "NewHeadsSubscription('newHeads',)#3"
+    assert sub4.label == "NewHeadsSubscription('newHeads',)#4"
+
+    # assert no issues unsubscribing
+    await subscription_manager.unsubscribe_all()
+
+    assert subscription_manager.subscriptions == []
+    assert subscription_manager._subscription_container.subscriptions == []
+    assert subscription_manager._subscription_container.subscriptions_by_id == {}
+    assert subscription_manager._subscription_container.subscriptions_by_label == {}
+
+
+@pytest.mark.asyncio
+async def test_subscription_manager_raises_for_new_subs_with_the_same_custom_label(
     subscription_manager,
 ):
     sub1 = NewHeadsSubscription(label="foo")
-    await subscription_manager.subscribe(sub1)
+    sub2 = LogsSubscription(label="foo")
 
     with pytest.raises(
         Web3ValueError,
         match="Subscription label already exists. Subscriptions must have unique "
         "labels.\n    label: foo",
     ):
-        sub2 = LogsSubscription(label="foo")
-        await subscription_manager.subscribe(sub2)
+        await subscription_manager.subscribe([sub1, sub2])
 
     # make sure the subscription was subscribed to and not added to the manager
     assert subscription_manager.subscriptions == [sub1]
@@ -110,3 +137,54 @@ async def test_unsubscribe_all_clears_all_subscriptions(subscription_manager):
     assert sub_container.subscriptions == []
     assert sub_container.subscriptions_by_id == {}
     assert sub_container.subscriptions_by_label == {}
+
+
+@pytest.mark.asyncio
+async def test_unsubscribe_with_one_or_multiple(subscription_manager):
+    sub1 = NewHeadsSubscription()
+    sub2 = PendingTxSubscription()
+    sub3 = NewHeadsSubscription()
+    sub4 = LogsSubscription()
+    sub5 = NewHeadsSubscription()
+    sub6 = PendingTxSubscription()
+
+    (
+        sub_id1,
+        sub_id2,
+        sub_id3,
+        sub_id4,
+        sub_id5,
+        sub_id6,
+    ) = await subscription_manager.subscribe([sub1, sub2, sub3, sub4, sub5, sub6])
+    assert sub_id1 == "0x0"
+    assert sub_id2 == "0x1"
+    assert sub_id3 == "0x2"
+    assert sub_id4 == "0x3"
+    assert sub_id5 == "0x4"
+    assert sub_id6 == "0x5"
+
+    assert subscription_manager.subscriptions == [sub1, sub2, sub3, sub4, sub5, sub6]
+
+    # unsubscribe single by hex id
+    assert await subscription_manager.unsubscribe(sub_id1) is True
+    assert subscription_manager.subscriptions == [sub2, sub3, sub4, sub5, sub6]
+
+    # unsubscribe many by hex id
+    assert await subscription_manager.unsubscribe([sub_id2, sub_id3]) is True
+    assert subscription_manager.subscriptions == [sub4, sub5, sub6]
+
+    # unsubscribe non-existent hex id
+    with pytest.raises(Web3ValueError, match=f"Subscription not found|{0x7}"):
+        await subscription_manager.unsubscribe(HexStr("0x7"))
+
+    # unsubscribe by subscription object
+    assert await subscription_manager.unsubscribe(sub4) is True
+    assert subscription_manager.subscriptions == [sub5, sub6]
+
+    # unsubscribe many by subscription object
+    assert await subscription_manager.unsubscribe([sub5, sub6]) is True
+    assert subscription_manager.subscriptions == []
+
+    # unsubscribe non-existent subscription object
+    with pytest.raises(Web3ValueError, match=f"Subscription not found|{sub5.id}"):
+        await subscription_manager.unsubscribe(sub5)

{web3-7.7.0 → web3-7.8.0}/tests/core/utilities/test_http_session_manager.py

@@ -112,6 +112,28 @@ def test_session_manager_json_make_get_request(mocker, http_session_manager):
     assert adapter._pool_maxsize == DEFAULT_POOLSIZE
 
 
+def test_session_manager_json_make_post_request(mocker, http_session_manager):
+    mocker.patch("requests.Session.post", return_value=MockedResponse())
+
+    # Submit a first request to create a session with default parameters
+    assert len(http_session_manager.session_cache) == 0
+    response = http_session_manager.json_make_post_request(
+        TEST_URI, json={"data": "request"}
+    )
+    assert response == json.dumps({"data": "content"})
+    assert len(http_session_manager.session_cache) == 1
+    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    session = http_session_manager.session_cache.get_cache_entry(cache_key)
+    session.post.assert_called_once_with(TEST_URI, json={"data": "request"}, timeout=30)
+
+    # Ensure the adapter was created with default values
+    check_adapters_mounted(session)
+    adapter = session.get_adapter(TEST_URI)
+    assert isinstance(adapter, HTTPAdapter)
+    assert adapter._pool_connections == DEFAULT_POOLSIZE
+    assert adapter._pool_maxsize == DEFAULT_POOLSIZE
+
+
 def test_session_manager_make_post_request_no_args(mocker, http_session_manager):
     mocker.patch("requests.Session.post", return_value=MockedResponse())
 
@@ -332,6 +354,32 @@ async def test_session_manager_async_json_make_get_request(
     await session.close()
 
 
+@pytest.mark.asyncio
+async def test_session_manager_async_json_make_post_request(
+    mocker, http_session_manager
+):
+    mocker.patch("aiohttp.ClientSession.post", return_value=AsyncMockedResponse())
+
+    # Submit a first request to create a session with default parameters
+    assert len(http_session_manager.session_cache) == 0
+    response = await http_session_manager.async_json_make_post_request(
+        TEST_URI, json={"data": "request"}
+    )
+    assert response == json.dumps({"data": "content"})
+    assert len(http_session_manager.session_cache) == 1
+    cache_key = generate_cache_key(f"{threading.get_ident()}:{TEST_URI}")
+    session = http_session_manager.session_cache.get_cache_entry(cache_key)
+    assert isinstance(session, ClientSession)
+    session.post.assert_called_once_with(
+        TEST_URI,
+        json={"data": "request"},
+        timeout=ClientTimeout(
+            total=30, connect=None, sock_read=None, sock_connect=None
+        ),
+    )
+    await session.close()
+
+
 @pytest.mark.asyncio
 async def test_session_manager_async_make_post_request(mocker, http_session_manager):
     mocker.patch("aiohttp.ClientSession.post", return_value=AsyncMockedResponse())