add test for validate_serenity_attestation_aggregate_signature

Author: djrtwo

eth/beacon/state_machines/forks/serenity/validation.py

@@ -68,9 +68,7 @@ def validate_serenity_attestation(state: BeaconState,
 
     validate_serenity_attestation_latest_crosslink_root(
         attestation.data,
-        latest_crosslink_shard_block_root=(
-            state.latest_crosslinks[attestation.data.shard].shard_block_root
-        ),
+        latest_crosslink_root=state.latest_crosslinks[attestation.data.shard].shard_block_root,
     )
 
     validate_serenity_attestation_shard_block_root(attestation.data)
@@ -161,25 +159,25 @@ def validate_serenity_attestation_justified_block_root(attestation_data: Attesta
 
 
 def validate_serenity_attestation_latest_crosslink_root(attestation_data: AttestationData,
-                                                        latest_crosslink_shard_block_root: Hash32) -> None:
+                                                        latest_crosslink_root: Hash32) -> None:
     """
-    Validate that either the ``latest_crosslink_root`` or ``shard_block_root``
-    field of ``attestation_data`` is the provided ``latest_crosslink_shard_block_root``.
+    Validate that either the attestation ``latest_crosslink_root`` or ``shard_block_root``
+    field of ``attestation_data`` is the provided ``latest_crosslink_root``.
     Raise ``ValidationError`` if it's invalid.
     """
     acceptable_shard_block_roots = [
         attestation_data.latest_crosslink_root,
         attestation_data.shard_block_root,
     ]
-    if latest_crosslink_shard_block_root not in acceptable_shard_block_roots:
+    if latest_crosslink_root not in acceptable_shard_block_roots:
         raise ValidationError(
             "Neither the attestation ``latest_crosslink_root`` nor the attestation "
-            "``shard_block_root`` are equal to the ``latest_crosslink_shard_block_root``.\n"
+            "``shard_block_root`` are equal to the ``latest_crosslink_root``.\n"
             "\tFound: %s and %s, Expected %s" %
             (
                 attestation_data.latest_crosslink_root,
                 attestation_data.shard_block_root,
-                latest_crosslink_shard_block_root,
+                latest_crosslink_root,
             )
         )
 
@@ -216,16 +214,16 @@ def validate_serenity_attestation_aggregate_signature(state: BeaconState,
     """
     participant_indices = get_attestation_participants(
         state=state,
-        slot=attestation.slot,
-        shard=attestation.shard,
+        slot=attestation.data.slot,
+        shard=attestation.data.shard,
         participation_bitfield=attestation.participation_bitfield,
         epoch_length=epoch_length,
     )
 
-    pubkeys = [
+    pubkeys = (
         state.validator_registry[validator_index].pubkey
         for validator_index in participant_indices
-    ]
+    )
     group_public_key = bls.aggregate_pubkeys(pubkeys)
 
     message = hash_eth2(

tests/beacon/conftest.py

@@ -8,8 +8,12 @@
 import eth._utils.bls as bls
 from eth.beacon._utils.hash import hash_eth2
 
+from eth.beacon.helpers import (
+    get_new_shuffling,
+)
+
 from eth.beacon.types.proposal_signed_data import (
-    ProposalSignedData
+    ProposalSignedData,
 )
 
 from eth.beacon.types.slashable_vote_data import (
@@ -20,6 +24,7 @@
     AttestationData,
 )
 
+from eth.beacon.types.states import BeaconState
 from eth.beacon.types.deposits import DepositData
 from eth.beacon.types.deposit_input import DepositInput
 
@@ -46,7 +51,7 @@
 
 @pytest.fixture(scope="session")
 def privkeys():
-    return [int.from_bytes(hash_eth2(str(i).encode('utf-8'))[:4], 'big') for i in range(1000)]
+    return [int.from_bytes(hash_eth2(str(i).encode('utf-8'))[:4], 'big') for i in range(50)]
 
 
 @pytest.fixture(scope="session")
@@ -134,8 +139,8 @@ def sample_beacon_state_params(sample_fork_data_params):
         'validator_registry_latest_change_slot': 10,
         'validator_registry_exit_count': 10,
         'validator_registry_delta_chain_tip': b'\x55' * 32,
-        'randao_mix': b'\x55' * 32,
-        'next_seed': b'\x55' * 32,
+        'randao_mix': ZERO_HASH32,
+        'next_seed': ZERO_HASH32,
         'shard_committees_at_slots': (),
         'persistent_committees': (),
         'persistent_committee_reassignments': (),
@@ -488,6 +493,27 @@ def max_exits():
 #
 # genesis
 #
+@pytest.fixture
+def genesis_state(sample_beacon_state_params,
+                  genesis_validators,
+                  epoch_length,
+                  target_committee_size,
+                  shard_count):
+    initial_shuffling = get_new_shuffling(
+        seed=ZERO_HASH32,
+        validators=genesis_validators,
+        crosslinking_start_shard=0,
+        epoch_length=epoch_length,
+        target_committee_size=target_committee_size,
+        shard_count=shard_count
+    )
+
+    return BeaconState(**sample_beacon_state_params).copy(
+        validator_registry=genesis_validators,
+        shard_committees_at_slots=initial_shuffling + initial_shuffling,
+    )
+
+
 @pytest.fixture
 def genesis_validators(init_validator_keys,
                        init_randao,

tests/beacon/state_machines/test_attestation_validation.py

@@ -1,22 +1,86 @@
 import pytest
+from hypothesis import (
+    given,
+    settings,
+    strategies as st,
+)
 
 from eth_utils import (
     ValidationError,
 )
+
+import rlp
+
 from eth.constants import (
     ZERO_HASH32,
 )
 
+from eth._utils import bls
+from eth._utils.bitfield import (
+    get_empty_bitfield,
+)
+from eth.beacon._utils.hash import (
+    hash_eth2,
+)
+from eth.beacon.aggregation import (
+    aggregate_votes,
+)
+from eth.beacon.enums import (
+    SignatureDomain,
+)
+from eth.beacon.helpers import (
+    get_domain,
+)
 from eth.beacon.state_machines.forks.serenity.validation import (
+    validate_serenity_attestation_aggregate_signature,
     validate_serenity_attestation_latest_crosslink_root,
     validate_serenity_attestation_justified_block_root,
     validate_serenity_attestation_justified_slot,
     validate_serenity_attestation_shard_block_root,
     validate_serenity_attestation_slot,
 )
-from eth.beacon.types.attestation_data import (
-    AttestationData,
-)
+from eth.beacon.types.attestations import Attestation
+from eth.beacon.types.attestation_data import AttestationData
+
+
+def create_mock_signed_attestation(state,
+                                   shard_committee,
+                                   voting_committee_indices,
+                                   attestation_data,
+                                   privkeys):
+    message = hash_eth2(
+        rlp.encode(attestation_data) +
+        (0).to_bytes(1, "big")
+    )
+    # participants sign message
+    signatures = [
+        bls.sign(
+            message,
+            privkeys[shard_committee.committee[committee_index]],
+            domain=get_domain(
+                fork_data=state.fork_data,
+                slot=attestation_data.slot,
+                domain_type=SignatureDomain.DOMAIN_ATTESTATION,
+            )
+        )
+        for committee_index in voting_committee_indices
+    ]
+
+    # aggregate signatures and construct participant bitfield
+    participation_bitfield, aggregate_signature = aggregate_votes(
+        bitfield=get_empty_bitfield(len(shard_committee.committee)),
+        sigs=(),
+        voting_sigs=signatures,
+        voting_committee_indices=voting_committee_indices,
+    )
+
+    # create attestation from attestation_data, particpipant_bitfield, and signature
+    return Attestation(
+        data=attestation_data,
+        participation_bitfield=participation_bitfield,
+        custody_bitfield=b'',
+        aggregate_signature=aggregate_signature,
+    )
 
 
 @pytest.mark.parametrize(
@@ -151,7 +215,7 @@ def test_validate_serenity_attestation_justified_block_root(sample_attestation_d
     (
         'attestation_latest_crosslink_root,'
         'attestation_shard_block_root,'
-        'latest_crosslink_shard_block_root,'
+        'latest_crosslink_root,'
         'is_valid,'
     ),
     [
@@ -165,7 +229,7 @@ def test_validate_serenity_attestation_justified_block_root(sample_attestation_d
 def test_validate_serenity_attestation_latest_crosslink_root(sample_attestation_data_params,
                                                              attestation_latest_crosslink_root,
                                                              attestation_shard_block_root,
-                                                             latest_crosslink_shard_block_root,
+                                                             latest_crosslink_root,
                                                              is_valid):
     sample_attestation_data_params['latest_crosslink_root'] = attestation_latest_crosslink_root
     sample_attestation_data_params['shard_block_root'] = attestation_shard_block_root
@@ -177,13 +241,13 @@ def test_validate_serenity_attestation_latest_crosslink_root(sample_attestation_
     if is_valid:
         validate_serenity_attestation_latest_crosslink_root(
             attestation_data,
-            latest_crosslink_shard_block_root,
+            latest_crosslink_root,
         )
     else:
         with pytest.raises(ValidationError):
             validate_serenity_attestation_latest_crosslink_root(
                 attestation_data,
-                latest_crosslink_shard_block_root,
+                latest_crosslink_root,
             )
 
 
@@ -216,5 +280,72 @@ def test_validate_serenity_attestation_shard_block_root(sample_attestation_data_
             )
 
 
-def test_validate_serenity_attestation_aggregate_signature():
-    pass
+@settings(max_examples=1)
+@given(random=st.randoms())
+@pytest.mark.parametrize(
+    (
+        'num_validators,'
+        'epoch_length,'
+        'target_committee_size,'
+        'shard_count,'
+        'is_valid,'
+    ),
+    [
+        (10, 2, 2, 2, True),
+        (40, 4, 3, 5, True),
+        (20, 5, 3, 2, True),
+        (20, 5, 3, 2, False),
+        (10, 2, 3, 4, False),
+    ],
+)
+def test_validate_serenity_attestation_aggregate_signature(genesis_state,
+                                                           epoch_length,
+                                                           random,
+                                                           privkeys,
+                                                           sample_attestation_data_params,
+                                                           is_valid):
+    state = genesis_state
+
+    # choose committee
+    slot = 0
+    shard_committee = state.shard_committees_at_slots[slot][0]
+    committee_size = len(shard_committee.committee)
+
+    # randomly select 3/4 participants from committee
+    votes_count = len(shard_committee.committee) * 3 // 4
+    voting_committee_indices = random.sample(range(committee_size), votes_count)
+    assert len(voting_committee_indices) > 0
+
+    attestation_data = AttestationData(**sample_attestation_data_params).copy(
+        slot=slot,
+        shard=shard_committee.shard,
+    )
+
+    attestation = create_mock_signed_attestation(
+        state,
+        shard_committee,
+        voting_committee_indices,
+        attestation_data,
+        privkeys,
+    )
+
+    if is_valid:
+        validate_serenity_attestation_aggregate_signature(
+            state,
+            attestation,
+            epoch_length,
+        )
+    else:
+        # mess up signature
+        attestation = attestation.copy(
+            aggregate_signature=(
+                attestation.aggregate_signature[0] + 10,
+                attestation.aggregate_signature[1] - 1
+            )
+        )
+        with pytest.raises(ValidationError):
+            validate_serenity_attestation_aggregate_signature(
+                state,
+                attestation,
+                epoch_length,
+            )