web3 6.20.0__tar.gz → 6.20.1__tar.gz

{web3-6.20.0 → web3-6.20.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 6.20.0
+Version: 6.20.1
 Summary: web3.py
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation

{web3-6.20.0 → web3-6.20.1}/setup.py

@@ -51,7 +51,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. Use the 'bumpversion' utility.
-    version="6.20.0",
+    version="6.20.1",
     description="""web3.py""",
     long_description_content_type="text/markdown",
     long_description=long_description,

web3-6.20.1/tests/beacon/test_async_beacon.py

@@ -0,0 +1,267 @@
+import pytest
+from random import (
+    randint,
+)
+
+import pytest_asyncio
+
+from web3._utils.request import (
+    _async_session_cache,
+)
+from web3.beacon import (
+    AsyncBeacon,
+)
+
+# tested against lighthouse which uses port 5052 by default
+BASE_URL = "http://localhost:5052"
+
+
+def _assert_valid_response(response):
+    # assert valid response according to Beacon API spec
+    assert isinstance(response, dict)
+    assert "data" in response
+
+
+@pytest.fixture
+def async_beacon():
+    return AsyncBeacon(base_url=BASE_URL)
+
+
+@pytest_asyncio.fixture(autouse=True)
+async def _cleanup():
+    yield
+    [await session.close() for _, session in _async_session_cache.items()]
+    _async_session_cache.clear()
+
+
+# sanity check to make sure the positive test cases are valid
+@pytest.mark.asyncio
+async def test_async_cl_beacon_raises_exception_on_invalid_url(async_beacon):
+    with pytest.raises(ValueError):
+        await async_beacon._async_make_get_request(
+            BASE_URL + "/eth/v1/beacon/nonexistent"
+        )
+
+
+@pytest.mark.asyncio
+async def test_async_beacon_user_request_timeout():
+    beacon = AsyncBeacon(base_url=BASE_URL, request_timeout=0.001)
+    with pytest.raises(TimeoutError):
+        await beacon.get_validators()
+
+
+# Beacon endpoint tests:
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_genesis(async_beacon):
+    response = await async_beacon.get_genesis()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_hash_root(async_beacon):
+    response = await async_beacon.get_hash_root()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_fork_data(async_beacon):
+    response = await async_beacon.get_fork_data()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_finality_checkpoint(async_beacon):
+    response = await async_beacon.get_finality_checkpoint()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_validators(async_beacon):
+    response = await async_beacon.get_validators()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_validator(async_beacon):
+    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_pubkey = random_validator["validator"]["pubkey"]
+
+    response = await async_beacon.get_validator(random_validator_pubkey)
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_validator_balances(async_beacon):
+    response = await async_beacon.get_validator_balances()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_epoch_committees(async_beacon):
+    response = await async_beacon.get_epoch_committees()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_epoch_sync_committees(async_beacon):
+    response = await async_beacon.get_epoch_sync_committees()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_epoch_randao(async_beacon):
+    response = await async_beacon.get_epoch_randao()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_block_headers(async_beacon):
+    response = await async_beacon.get_block_headers()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_block_header(async_beacon):
+    response = await async_beacon.get_block_header("head")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_block(async_beacon):
+    response = await async_beacon.get_block("head")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_block_root(async_beacon):
+    response = await async_beacon.get_block_root("head")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_blinded_blocks(async_beacon):
+    response = await async_beacon.get_blinded_blocks("head")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_rewards(async_beacon):
+    response = await async_beacon.get_rewards("head")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_block_attestations(async_beacon):
+    response = await async_beacon.get_block_attestations("head")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_attestations(async_beacon):
+    response = await async_beacon.get_attestations()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_attester_slashings(async_beacon):
+    response = await async_beacon.get_attester_slashings()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_proposer_slashings(async_beacon):
+    response = await async_beacon.get_proposer_slashings()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_voluntary_exits(async_beacon):
+    response = await async_beacon.get_voluntary_exits()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_beacon_get_bls_to_execution_changes(async_beacon):
+    response = await async_beacon.get_bls_to_execution_changes()
+    _assert_valid_response(response)
+
+
+# Config endpoint tests:
+
+
+@pytest.mark.asyncio
+async def test_async_cl_config_get_fork_schedule(async_beacon):
+    response = await async_beacon.get_fork_schedule()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_config_get_spec(async_beacon):
+    response = await async_beacon.get_spec()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_config_get_deposit_contract(async_beacon):
+    response = await async_beacon.get_deposit_contract()
+    _assert_valid_response(response)
+
+
+# Debug endpoint tests:
+
+
+@pytest.mark.asyncio
+async def test_async_cl_debug_get_beacon_state(async_beacon):
+    response = await async_beacon.get_beacon_state()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_debug_get_beacon_heads(async_beacon):
+    response = await async_beacon.get_beacon_heads()
+    _assert_valid_response(response)
+
+
+# Node endpoint tests:
+
+
+@pytest.mark.asyncio
+async def test_async_cl_node_get_node_identity(async_beacon):
+    response = await async_beacon.get_node_identity()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_node_get_peers(async_beacon):
+    response = await async_beacon.get_peers()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_node_get_peer(async_beacon):
+    response = await async_beacon.get_peer("")
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_node_get_health(async_beacon):
+    response = await async_beacon.get_health()
+    assert isinstance(response, int)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_node_get_version(async_beacon):
+    response = await async_beacon.get_version()
+    _assert_valid_response(response)
+
+
+@pytest.mark.asyncio
+async def test_async_cl_node_get_syncing(async_beacon):
+    response = await async_beacon.get_syncing()
+    _assert_valid_response(response)

web3-6.20.1/tests/beacon/test_beacon.py

@@ -0,0 +1,231 @@
+import pytest
+from random import (
+    randint,
+)
+
+from requests import (
+    Timeout,
+)
+
+from web3._utils.request import (
+    _session_cache,
+)
+from web3.beacon import (
+    Beacon,
+)
+
+# tested against lighthouse which uses port 5052 by default
+BASE_URL = "http://localhost:5052"
+
+
+def _assert_valid_response(response):
+    # assert valid response according to Beacon API spec
+    assert isinstance(response, dict)
+    assert "data" in response
+
+
+@pytest.fixture
+def beacon():
+    return Beacon(base_url=BASE_URL)
+
+
+@pytest.fixture(autouse=True)
+def _cleanup():
+    yield
+    _session_cache.clear()
+
+
+# sanity check to make sure the positive test cases are valid
+def test_cl_beacon_raises_exception_on_invalid_url(beacon):
+    with pytest.raises(ValueError):
+        beacon._make_get_request(BASE_URL + "/eth/v1/beacon/nonexistent")
+
+
+def test_beacon_user_defined_request_timeout():
+    beacon = Beacon(base_url=BASE_URL, request_timeout=0.001)
+    with pytest.raises(Timeout):
+        beacon.get_validators()
+
+
+# Beacon endpoint tests:
+
+
+def test_cl_beacon_get_genesis(beacon):
+    response = beacon.get_genesis()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_hash_root(beacon):
+    response = beacon.get_hash_root()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_fork_data(beacon):
+    response = beacon.get_fork_data()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_finality_checkpoint(beacon):
+    response = beacon.get_finality_checkpoint()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_validators(beacon):
+    response = beacon.get_validators()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_validator(beacon):
+    validators_response = beacon.get_validators()
+    _assert_valid_response(validators_response)
+
+    validators = validators_response["data"]
+    random_validator = validators[randint(0, len(validators))]
+    random_validator_pubkey = random_validator["validator"]["pubkey"]
+
+    response = beacon.get_validator(random_validator_pubkey)
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_validator_balances(beacon):
+    response = beacon.get_validator_balances()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_epoch_committees(beacon):
+    response = beacon.get_epoch_committees()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_epoch_sync_committees(beacon):
+    response = beacon.get_epoch_sync_committees()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_epoch_randao(beacon):
+    response = beacon.get_epoch_randao()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_block_headers(beacon):
+    response = beacon.get_block_headers()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_block_header(beacon):
+    response = beacon.get_block_header("head")
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_block(beacon):
+    response = beacon.get_block("head")
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_block_root(beacon):
+    response = beacon.get_block_root("head")
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_blinded_blocks(beacon):
+    response = beacon.get_blinded_blocks("head")
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_rewards(beacon):
+    response = beacon.get_rewards("head")
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_block_attestations(beacon):
+    response = beacon.get_block_attestations("head")
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_attestations(beacon):
+    response = beacon.get_attestations()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_attester_slashings(beacon):
+    response = beacon.get_attester_slashings()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_proposer_slashings(beacon):
+    response = beacon.get_proposer_slashings()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_voluntary_exits(beacon):
+    response = beacon.get_voluntary_exits()
+    _assert_valid_response(response)
+
+
+def test_cl_beacon_get_bls_to_execution_changes(beacon):
+    response = beacon.get_bls_to_execution_changes()
+    _assert_valid_response(response)
+
+
+# Config endpoint tests:
+
+
+def test_cl_config_get_fork_schedule(beacon):
+    response = beacon.get_fork_schedule()
+    _assert_valid_response(response)
+
+
+def test_cl_config_get_spec(beacon):
+    response = beacon.get_spec()
+    _assert_valid_response(response)
+
+
+def test_cl_config_get_deposit_contract(beacon):
+    response = beacon.get_deposit_contract()
+    _assert_valid_response(response)
+
+
+# Debug endpoint tests:
+
+
+def test_cl_debug_get_beacon_state(beacon):
+    response = beacon.get_beacon_state()
+    _assert_valid_response(response)
+
+
+def test_cl_debug_get_beacon_heads(beacon):
+    response = beacon.get_beacon_heads()
+    _assert_valid_response(response)
+
+
+# Node endpoint tests:
+
+
+def test_cl_node_get_node_identity(beacon):
+    response = beacon.get_node_identity()
+    _assert_valid_response(response)
+
+
+def test_cl_node_get_peers(beacon):
+    response = beacon.get_peers()
+    _assert_valid_response(response)
+
+
+def test_cl_node_get_peer(beacon):
+    response = beacon.get_peer("")
+    _assert_valid_response(response)
+
+
+def test_cl_node_get_health(beacon):
+    response = beacon.get_health()
+    assert isinstance(response, int)
+
+
+def test_cl_node_get_version(beacon):
+    response = beacon.get_version()
+    _assert_valid_response(response)
+
+
+def test_cl_node_get_syncing(beacon):
+    response = beacon.get_syncing()
+    _assert_valid_response(response)

web3-6.20.1/tests/conftest.py

@@ -0,0 +1,109 @@
+import pytest
+
+from eth_utils import (
+    event_signature_to_log_topic,
+    to_bytes,
+)
+from eth_utils.toolz import (
+    identity,
+)
+
+from web3._utils.contract_sources.contract_data.emitter_contract import (
+    EMITTER_CONTRACT_DATA,
+)
+
+from .utils import (
+    get_open_port,
+)
+
+
+@pytest.fixture(scope="module", params=[lambda x: to_bytes(hexstr=x), identity])
+def address_conversion_func(request):
+    return request.param
+
+
+@pytest.fixture()
+def open_port():
+    return get_open_port()
+
+
+def pytest_addoption(parser):
+    parser.addoption("--flaky", action="store_true")
+
+
+# --- session-scoped constants --- #
+
+
+@pytest.fixture(scope="session")
+def emitter_contract_data():
+    return EMITTER_CONTRACT_DATA
+
+
+class LogFunctions:
+    # These appear to be for a very specific test and this doesn't need to be updated
+    # for every event in the emitter contract. That ends up breaking that test.
+    LogAnonymous = 0
+    LogNoArguments = 1
+    LogSingleArg = 2
+    LogDoubleArg = 3
+    LogTripleArg = 4
+    LogQuadrupleArg = 5
+    LogSingleAnonymous = 6
+    LogSingleWithIndex = 7
+    LogDoubleAnonymous = 8
+    LogDoubleWithIndex = 9
+    LogTripleWithIndex = 10
+    LogQuadrupleWithIndex = 11
+    LogBytes = 12
+    LogString = 13
+    LogDynamicArgs = 14
+    LogListArgs = 15
+    LogAddressIndexed = 16
+    LogAddressNotIndexed = 17
+
+
+@pytest.fixture(scope="session")
+def emitter_contract_event_ids():
+    return LogFunctions
+
+
+class LogTopics:
+    LogAnonymous = event_signature_to_log_topic("LogAnonymous()")
+    LogNoArguments = event_signature_to_log_topic("LogNoArguments()")
+    LogSingleArg = event_signature_to_log_topic("LogSingleArg(uint256)")
+    LogSingleAnonymous = event_signature_to_log_topic("LogSingleAnonymous(uint256)")
+    LogSingleWithIndex = event_signature_to_log_topic("LogSingleWithIndex(uint256)")
+    LogDoubleArg = event_signature_to_log_topic("LogDoubleArg(uint256,uint256)")
+    LogDoubleAnonymous = event_signature_to_log_topic(
+        "LogDoubleAnonymous(uint256,uint256)"
+    )
+    LogDoubleWithIndex = event_signature_to_log_topic(
+        "LogDoubleWithIndex(uint256,uint256)"
+    )
+    LogTripleArg = event_signature_to_log_topic("LogTripleArg(uint256,uint256,uint256)")
+    LogTripleWithIndex = event_signature_to_log_topic(
+        "LogTripleWithIndex(uint256,uint256,uint256)"
+    )
+    LogQuadrupleArg = event_signature_to_log_topic(
+        "LogQuadrupleArg(uint256,uint256,uint256,uint256)"
+    )
+    LogQuadrupleWithIndex = event_signature_to_log_topic(
+        "LogQuadrupleWithIndex(uint256,uint256,uint256,uint256)",
+    )
+    LogBytes = event_signature_to_log_topic("LogBytes(bytes)")
+    LogString = event_signature_to_log_topic("LogString(string)")
+    LogDynamicArgs = event_signature_to_log_topic("LogDynamicArgs(string,string)")
+    LogListArgs = event_signature_to_log_topic("LogListArgs(bytes2[],bytes2[])")
+    LogAddressIndexed = event_signature_to_log_topic(
+        "LogAddressIndexed(address,address)"
+    )
+    LogAddressNotIndexed = event_signature_to_log_topic(
+        "LogAddressNotIndexed(address,address)"
+    )
+    LogStructArgs = event_signature_to_log_topic("LogStructArgs(uint256,tuple)")
+    LogIndexedAndNotIndexed = event_signature_to_log_topic("LogIndexedAndNotIndexed()")
+
+
+@pytest.fixture(scope="session")
+def emitter_contract_log_topics():
+    return LogTopics

web3-6.20.1/tests/core/admin-module/test_admin_addPeer.py

@@ -0,0 +1,7 @@
+def test_admin_add_peer(w3, skip_if_testrpc):
+    skip_if_testrpc(w3)
+
+    result = w3.geth.admin.add_peer(
+        "enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@127.0.0.1:30304",  # noqa: E501
+    )
+    assert result is True

web3-6.20.1/tests/core/admin-module/test_admin_nodeInfo.py

@@ -0,0 +1,7 @@
+def test_admin_node_info(w3, skip_if_testrpc):
+    skip_if_testrpc(w3)
+
+    node_info = w3.geth.admin.node_info
+
+    assert "enode" in node_info
+    assert "id" in node_info

web3-6.20.1/tests/core/admin-module/test_admin_peers.py

@@ -0,0 +1,4 @@
+def test_admin_peers(w3, skip_if_testrpc):
+    skip_if_testrpc(w3)
+
+    assert w3.geth.admin.peers == []

web3-6.20.1/tests/core/block-utils/test_select_method_for_block_identifier.py

@@ -0,0 +1,45 @@
+import pytest
+
+from eth_utils.toolz import (
+    partial,
+)
+
+from web3._utils.blocks import (
+    select_method_for_block_identifier,
+)
+
+selector_fn = partial(
+    select_method_for_block_identifier,
+    if_hash="test_hash",
+    if_number="test_number",
+    if_predefined="test_predefined",
+)
+
+
+@pytest.mark.parametrize(
+    "input,expected",
+    (
+        ("latest", "test_predefined"),
+        ("pending", "test_predefined"),
+        ("earliest", "test_predefined"),
+        ("safe", "test_predefined"),
+        ("finalized", "test_predefined"),
+        (-1, ValueError),
+        (0, "test_number"),
+        (1, "test_number"),
+        (4000000, "test_number"),
+        ("0x0", "test_number"),
+        ("0x00", "test_number"),
+        ("0x1", "test_number"),
+        ("0x01", "test_number"),
+        (hex(4000000), "test_number"),
+        ("0x" + "".zfill(64), "test_hash"),
+    ),
+)
+def test_select_method_for_block_identifier(input, expected):
+    if isinstance(expected, type) and issubclass(expected, Exception):
+        with pytest.raises(expected):
+            selector_fn(input)
+    else:
+        actual = selector_fn(input)
+        assert actual == expected