web3 7.6.1__tar.gz → 7.8.0__tar.gz

{web3-7.6.1 → 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.6.1/web3.egg-info → web3-7.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: web3
-Version: 7.6.1
+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
@@ -78,6 +78,18 @@ Requires-Dist: mypy==1.10.0; extra == "test"
 Requires-Dist: pre-commit>=3.4.0; extra == "test"
 Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "test"
 Requires-Dist: py-geth>=5.1.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # web3.py
 

{web3-7.6.1 → 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.6.1 → 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.6.1 → 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.6.1",
+    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.6.1 → 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.6.1 → 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.6.1 → web3-7.8.0}/tests/core/contracts/conftest.py

@@ -803,6 +803,26 @@ async def async_nested_tuple_contract_with_decode_tuples(
     )
 
 
+@pytest_asyncio.fixture
+async def async_event_contract(
+    async_w3, async_wait_for_transaction, async_wait_for_block, address_conversion_func
+):
+    async_event_contract_factory = async_w3.eth.contract(**EVENT_CONTRACT_DATA)
+
+    await async_wait_for_block(async_w3)
+    deploy_txn_hash = await async_event_contract_factory.constructor().transact(
+        {"gas": 1000000}
+    )
+    deploy_receipt = await async_wait_for_transaction(async_w3, deploy_txn_hash)
+    contract_address = address_conversion_func(deploy_receipt["contractAddress"])
+
+    bytecode = await async_w3.eth.get_code(contract_address)
+    assert bytecode == async_event_contract_factory.bytecode_runtime
+    event_contract = async_event_contract_factory(address=contract_address)
+    assert event_contract.address == contract_address
+    return event_contract
+
+
 @pytest_asyncio.fixture
 async def async_ambiguous_event_contract(async_w3, address_conversion_func):
     async_ambiguous_event_contract_factory = async_w3.eth.contract(

{web3-7.6.1 → web3-7.8.0}/tests/core/contracts/test_contract_events.py

@@ -8,6 +8,9 @@ from typing import (
 from eth_typing import (
     ABIEvent,
 )
+from eth_utils import (
+    encode_hex,
+)
 from eth_utils.toolz import (
     compose,
     curry,
@@ -136,6 +139,95 @@ def test_events_iterator(math_contract):
         assert event.name == expected_event.name
 
 
+def test_contract_event_topic(event_contract):
+    event = event_contract.events.LogSingleArg()
+    assert event.topic == encode_hex(event_contract.w3.keccak(text=event.signature))
+
+
+def test_contract_event_topic_no_parens(event_contract):
+    event = event_contract.events.LogSingleArg
+    assert event.topic == encode_hex(event_contract.w3.keccak(text=event.signature))
+
+
+@pytest.mark.parametrize(
+    "event_abi,expected_signature",
+    (
+        (
+            {
+                "name": "Transfer",
+                "type": "event",
+                "inputs": [
+                    {"type": "address", "name": "from", "indexed": True},
+                    {"type": "address", "name": "to", "indexed": True},
+                    {"type": "uint256", "name": "value", "indexed": False},
+                ],
+            },
+            "Transfer(address,address,uint256)",
+        ),
+        (
+            {
+                "name": "TransferBatch",
+                "type": "event",
+                "inputs": [
+                    {"type": "address", "name": "operator", "indexed": True},
+                    {"type": "address", "name": "from", "indexed": True},
+                    {"type": "address", "name": "to", "indexed": True},
+                    {"type": "uint256[]", "name": "ids", "indexed": False},
+                    {"type": "uint256[]", "name": "values", "indexed": False},
+                ],
+            },
+            "TransferBatch(address,address,address,uint256[],uint256[])",
+        ),
+        (
+            {
+                "name": "Approval",
+                "type": "event",
+                "inputs": [
+                    {"type": "address", "name": "owner", "indexed": True},
+                    {"type": "address", "name": "approved", "indexed": True},
+                    {"type": "uint256", "name": "tokenId", "indexed": True},
+                ],
+            },
+            "Approval(address,address,uint256)",
+        ),
+        (
+            {
+                "name": "ApprovalForAll",
+                "type": "event",
+                "inputs": [
+                    {"type": "address", "name": "owner", "indexed": True},
+                    {"type": "address", "name": "operator", "indexed": True},
+                    {"type": "bool", "name": "approved", "indexed": False},
+                ],
+            },
+            "ApprovalForAll(address,address,bool)",
+        ),
+        (
+            {
+                "name": "OwnershipTransferred",
+                "type": "event",
+                "inputs": [
+                    {"type": "address", "name": "previousOwner", "indexed": True},
+                    {"type": "address", "name": "newOwner", "indexed": True},
+                ],
+            },
+            "OwnershipTransferred(address,address)",
+        ),
+    ),
+)
+def test_contract_event_signatures_and_topics(w3, event_abi, expected_signature):
+    event = ContractEvent(abi=event_abi)
+    assert event.signature == expected_signature
+    assert event.topic == encode_hex(w3.keccak(text=expected_signature))
+
+    async_event = AsyncContractEvent(abi=event_abi)
+    assert async_event.signature == expected_signature
+    assert async_event.topic == encode_hex(w3.keccak(text=expected_signature))
+
+
+# -- async -- #
+
+
 def test_async_events_iterator(async_math_contract):
     all_events = async_math_contract.all_events()
     events_iter = async_math_contract.events
@@ -143,3 +235,19 @@ def test_async_events_iterator(async_math_contract):
     for event, expected_event in zip(iter(events_iter), all_events):
         assert isinstance(event, AsyncContractEvent)
         assert event.name == expected_event.name
+
+
+def test_async_contract_event_topic(async_event_contract):
+    event = async_event_contract.events.LogSingleArg()
+    assert event.signature == "LogSingleArg(uint256)"
+    assert event.topic == encode_hex(
+        async_event_contract.w3.keccak(text=event.signature)
+    )
+
+
+def test_async_contract_event_topic_no_parens(async_event_contract):
+    event = async_event_contract.events.LogSingleArg
+    assert event.signature == "LogSingleArg(uint256)"
+    assert event.topic == encode_hex(
+        async_event_contract.w3.keccak(text=event.signature)
+    )

{web3-7.6.1 → web3-7.8.0}/tests/core/contracts/test_contract_events_build_filter.py

@@ -26,7 +26,7 @@ def test_build_filter_topic_signature(w3, math_contract_abi):
 def test_build_filter_resetting_build_filter_properties(w3, math_contract_abi):
     contract = w3.eth.contract(abi=math_contract_abi)
     filter_builder = contract.events.Increased.build_filter()
-    # Address is setable from undeployed contract class
+    # Address is settable from undeployed contract class
     filter_builder.address = b"\x10" * 40
     filter_builder.from_block = 0
     filter_builder.to_block = "latest"

{web3-7.6.1 → 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.6.1 → 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.6.1 → 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.6.1 → 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,
@@ -180,9 +181,11 @@ async def test_disconnect_cleanup(
     provider._request_processor._request_response_cache.cache("0", "0x1337")
     provider._request_processor._request_information_cache.cache("0", "0x1337")
     provider._request_processor._subscription_response_queue.put_nowait({"id": "0"})
+    provider._request_processor._handler_subscription_queue.put_nowait({"id": "0"})
     assert len(provider._request_processor._request_response_cache) == 1
     assert len(provider._request_processor._request_information_cache) == 1
     assert provider._request_processor._subscription_response_queue.qsize() == 1
+    assert provider._request_processor._handler_subscription_queue.qsize() == 1
 
     await w3.provider.disconnect()
 
@@ -192,6 +195,7 @@ async def test_disconnect_cleanup(
     assert len(provider._request_processor._request_response_cache) == 0
     assert len(provider._request_processor._request_information_cache) == 0
     assert provider._request_processor._subscription_response_queue.empty()
+    assert provider._request_processor._handler_subscription_queue.empty()
 
 
 async def _raise_connection_closed(*_args, **_kwargs):
@@ -361,5 +365,26 @@ async def test_async_ipc_provider_write_messages_end_with_new_line_delimiter(
 
         await w3.provider.make_request("method", [])
 
-        request_data = b'{"jsonrpc": "2.0", "method": "method", "params": [], "id": 0}'
+        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.6.1 → web3-7.8.0}/tests/core/providers/test_auto_provider.py

@@ -55,7 +55,19 @@ def test_load_provider_from_env(monkeypatch, uri, expected_type, expected_attrs)
 
 
 def test_get_dev_ipc_path(monkeypatch, tmp_path):
-    uri = str(tmp_path)
+    # test default path
+    path = get_dev_ipc_path()
+    assert path == "/tmp/geth.ipc"
+
+    uri = str(tmp_path) + "/geth.ipc"
+
+    # test setting the "TMPDIR" environment variable
+    monkeypatch.setenv("TMPDIR", str(tmp_path))
+    path = get_dev_ipc_path()
+    assert path == uri
+    monkeypatch.delenv("TMPDIR")  # reset
+
+    # test with WEB3_PROVIDER_URI set
     monkeypatch.setenv("WEB3_PROVIDER_URI", uri)
     path = get_dev_ipc_path()
     assert path == uri

{web3-7.6.1 → 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.6.1 → web3-7.8.0}/tests/core/providers/test_ipc_provider.py

@@ -97,7 +97,7 @@ def test_get_default_ipc_path(platform, expected_result, expected_error):
     "platform, expected_result, expected_error",
     [
         ("darwin", "/var/path/to/tmp/T/geth.ipc", None),
-        ("linux", "/tmp/geth.ipc", None),
+        ("linux", "/var/path/to/tmp/T/geth.ipc", None),
         ("freebsd", "/tmp/geth.ipc", None),
         ("win32", r"\\.\pipe\geth.ipc", None),
         (
@@ -119,7 +119,7 @@ def test_get_dev_ipc_path_(provider_env_uri, platform, expected_result, expected
             os.environ,
             {
                 "TMPDIR": "/var/path/to/tmp/T/",
-                "WEB3_PROVIDER_URI": provider_env_uri,
+                "WEB3_PROVIDER_URI": provider_env_uri or "",
             },
         ):
             if provider_env_uri:
@@ -130,7 +130,7 @@ def test_get_dev_ipc_path_(provider_env_uri, platform, expected_result, expected
                 ):
                     get_dev_ipc_path()
             else:
-                assert get_dev_ipc_path().endswith(expected_result)
+                assert get_dev_ipc_path() == expected_result
 
 
 @pytest.fixture

{web3-7.6.1 → web3-7.8.0}/tests/core/providers/test_tester_provider.py

@@ -77,7 +77,7 @@ def test_eth_tester_provider_properly_handles_eth_tester_key_error_messages():
     assert response["error"]["message"] == "Unknown RPC Endpoint: eth_blockNumber"
 
 
-def test_eth_tester_provider_properly_handles_eth_tester_not_implmented_error_messages(
+def test_eth_tester_provider_properly_handles_eth_tester_not_implemented_error_messages(
     mocker,
 ):
     mocker.patch(