Fix get_block_hash

Author: hwwhww

eth/beacon/helpers.py

@@ -74,34 +74,33 @@ def _get_element_from_recent_list(
 # Get block hash(es)
 #
 def get_block_hash(
-        recent_block_hashes: Sequence[Hash32],
-        current_block_slot_number: int,
+        latest_block_hashes: Sequence[Hash32],
+        current_block_slot: int,
         slot: int,
         epoch_length: int) -> Hash32:
     """
-    Return the blockhash from ``ActiveState.recent_block_hashes`` by
-    ``current_block_slot_number``.
+    Returns the block hash at a recent ``slot``.
     """
-    if len(recent_block_hashes) != epoch_length * 2:
+    if len(latest_block_hashes) != epoch_length * 2:
         raise ValueError(
-            "Length of recent_block_hashes != epoch_length * 2"
+            "Length of latest_block_hashes != epoch_length * 2"
             "\texpected: %s, found: %s" % (
-                epoch_length * 2, len(recent_block_hashes)
+                epoch_length * 2, len(latest_block_hashes)
             )
         )
 
-    slot_relative_position = current_block_slot_number - epoch_length * 2
+    slot_relative_position = current_block_slot - epoch_length * 2
     return _get_element_from_recent_list(
-        recent_block_hashes,
+        latest_block_hashes,
         slot,
         slot_relative_position,
     )
 
 
 @to_tuple
-def get_hashes_from_recent_block_hashes(
-        recent_block_hashes: Sequence[Hash32],
-        current_block_slot_number: int,
+def get_hashes_from_latest_block_hashes(
+        latest_block_hashes: Sequence[Hash32],
+        current_block_slot: int,
         from_slot: int,
         to_slot: int,
         epoch_length: int) -> Iterable[Hash32]:
@@ -110,43 +109,43 @@ def get_hashes_from_recent_block_hashes(
     """
     for slot in range(from_slot, to_slot + 1):
         yield get_block_hash(
-            recent_block_hashes,
-            current_block_slot_number,
+            latest_block_hashes,
+            current_block_slot,
             slot,
             epoch_length,
         )
 
 
 @to_tuple
-def get_hashes_to_sign(recent_block_hashes: Sequence[Hash32],
+def get_hashes_to_sign(latest_block_hashes: Sequence[Hash32],
                        block: 'BaseBeaconBlock',
                        epoch_length: int) -> Iterable[Hash32]:
     """
     Given the head block to attest to, collect the list of hashes to be
     signed in the attestation.
     """
-    yield from get_hashes_from_recent_block_hashes(
-        recent_block_hashes,
-        block.slot_number,
-        from_slot=block.slot_number - epoch_length + 1,
-        to_slot=block.slot_number - 1,
+    yield from get_hashes_from_latest_block_hashes(
+        latest_block_hashes,
+        block.slot,
+        from_slot=block.slot - epoch_length + 1,
+        to_slot=block.slot - 1,
         epoch_length=epoch_length,
     )
     yield block.hash
 
 
 @to_tuple
-def get_signed_parent_hashes(recent_block_hashes: Sequence[Hash32],
+def get_signed_parent_hashes(latest_block_hashes: Sequence[Hash32],
                              block: 'BaseBeaconBlock',
                              attestation: 'AttestationRecord',
                              epoch_length: int) -> Iterable[Hash32]:
     """
     Given an attestation and the block they were included in,
     the list of hashes that were included in the signature.
     """
-    yield from get_hashes_from_recent_block_hashes(
-        recent_block_hashes,
-        block.slot_number,
+    yield from get_hashes_from_latest_block_hashes(
+        latest_block_hashes,
+        block.slot,
         from_slot=attestation.slot - epoch_length + 1,
         to_slot=attestation.slot - len(attestation.oblique_parent_hashes),
         epoch_length=epoch_length,
@@ -155,7 +154,7 @@ def get_signed_parent_hashes(recent_block_hashes: Sequence[Hash32],
 
 
 @to_tuple
-def get_new_recent_block_hashes(old_block_hashes: Sequence[Hash32],
+def get_new_latest_block_hashes(old_block_hashes: Sequence[Hash32],
                                 parent_slot: int,
                                 current_slot: int,
                                 parent_hash: Hash32) -> Iterable[Hash32]:
@@ -339,7 +338,7 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
                               epoch_length: int) -> BlockCommitteesInfo:
     shards_committees = get_shard_committees_at_slot(
         crystallized_state,
-        parent_block.slot_number,
+        parent_block.slot,
         epoch_length,
     )
     """
@@ -360,7 +359,7 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
         )
 
     proposer_index_in_committee = (
-        parent_block.slot_number %
+        parent_block.slot %
         proposer_committee_size
     )
 

tests/beacon/conftest.py

@@ -75,12 +75,12 @@ def sample_attestation_data_params():
 
 
 @pytest.fixture
-def sample_beacon_block_params():
+def sample_beacon_block_params(epoch_length):
     return {
         'slot': 10,
         'randao_reveal': b'\x55' * 32,
         'candidate_pow_receipt_root': b'\x55' * 32,
-        'ancestor_hashes': (),
+        'ancestor_hashes': tuple([ZERO_HASH32 for _ in range(2 * epoch_length)]),
         'state_root': b'\x55' * 32,
         'attestations': (),
         'specials': (),

tests/beacon/helpers.py

@@ -4,9 +4,6 @@
 from eth.beacon.types.validator_records import (
     ValidatorRecord,
 )
-from eth.constants import (
-    ZERO_HASH32,
-)
 
 
 def mock_validator_record(pubkey, max_deposit):
@@ -23,15 +20,24 @@ def mock_validator_record(pubkey, max_deposit):
 
 
 def get_pseudo_chain(length, genesis_block):
-    """Get a pseudo chain, only slot_number and parent_hash are valid.
+    """
+    Get a pseudo chain, only slot and parent_hash are valid.
     """
     blocks = []
+    ancestor_hashes_len = len(genesis_block.ancestor_hashes)
     for slot in range(length * 3):
+        if slot > 0:
+            ancestor_hashes = (
+                (blocks[slot - 1].hash, ) +
+                blocks[slot - 1].ancestor_hashes[:ancestor_hashes_len]
+            )
+        else:
+            ancestor_hashes = genesis_block.ancestor_hashes
         blocks.append(
             genesis_block.copy(
-                slot_number=slot,
-                parent_hash=blocks[slot - 1].hash if slot > 0 else ZERO_HASH32
+                slot=slot,
+                ancestor_hashes=ancestor_hashes
             )
         )
 
-    return blocks
+    return tuple(blocks)

tests/beacon/test_helpers.py

@@ -4,14 +4,15 @@
     ValidatorStatusCode,
 )
 from eth.beacon.types.attestation_records import AttestationRecord
+from eth.beacon.types.blocks import BaseBeaconBlock
 from eth.beacon.types.shard_committees import ShardCommittee
 from eth.beacon.types.validator_records import ValidatorRecord
 from eth.beacon.helpers import (
     _get_element_from_recent_list,
     get_active_validator_indices,
     get_attestation_indices,
     get_block_hash,
-    get_hashes_from_recent_block_hashes,
+    get_hashes_from_latest_block_hashes,
     get_hashes_to_sign,
     get_new_shuffling,
     _get_shard_committees_at_slot,
@@ -39,18 +40,18 @@ def get_sample_shard_committees_at_slots(num_slot,
     )
 
 
-def generate_mock_recent_block_hashes(
+def generate_mock_latest_block_hashes(
         genesis_block,
         current_block_number,
         epoch_length):
     chain_length = (current_block_number // epoch_length + 1) * epoch_length
     blocks = get_pseudo_chain(chain_length, genesis_block)
-    recent_block_hashes = [
+    latest_block_hashes = [
         b'\x00' * 32
         for i
         in range(epoch_length * 2 - current_block_number)
     ] + [block.hash for block in blocks[:current_block_number]]
-    return blocks, recent_block_hashes
+    return blocks, latest_block_hashes
 
 
 @pytest.mark.parametrize(
@@ -88,7 +89,6 @@ def test_get_element_from_recent_list(target_list,
 #
 # Get block hashes
 #
-@pytest.mark.xfail(reason="Need to be fixed")
 @pytest.mark.parametrize(
     (
         'current_block_number,target_slot,success'
@@ -103,22 +103,22 @@ def test_get_element_from_recent_list(target_list,
     ],
 )
 def test_get_block_hash(
-        genesis_block,
         current_block_number,
         target_slot,
         success,
-        epoch_length):
-    epoch_length = epoch_length
+        epoch_length,
+        sample_beacon_block_params):
+    sample_block = BaseBeaconBlock(**sample_beacon_block_params)
 
-    blocks, recent_block_hashes = generate_mock_recent_block_hashes(
-        genesis_block,
+    blocks, latest_block_hashes = generate_mock_latest_block_hashes(
+        sample_block,
         current_block_number,
         epoch_length,
     )
 
     if success:
         block_hash = get_block_hash(
-            recent_block_hashes,
+            latest_block_hashes,
             current_block_number,
             target_slot,
             epoch_length,
@@ -127,7 +127,7 @@ def test_get_block_hash(
     else:
         with pytest.raises(ValueError):
             get_block_hash(
-                recent_block_hashes,
+                latest_block_hashes,
                 current_block_number,
                 target_slot,
                 epoch_length,
@@ -137,28 +137,28 @@ def test_get_block_hash(
 @pytest.mark.xfail(reason="Need to be fixed")
 @pytest.mark.parametrize(
     (
-        'epoch_length,current_block_slot_number,from_slot,to_slot'
+        'epoch_length,current_block_slot,from_slot,to_slot'
     ),
     [
         (20, 10, 2, 7),
         (20, 30, 10, 20),
     ],
 )
-def test_get_hashes_from_recent_block_hashes(
+def test_get_hashes_from_latest_block_hashes(
         genesis_block,
-        current_block_slot_number,
+        current_block_slot,
         from_slot,
         to_slot,
         epoch_length):
-    _, recent_block_hashes = generate_mock_recent_block_hashes(
+    _, latest_block_hashes = generate_mock_latest_block_hashes(
         genesis_block,
-        current_block_slot_number,
+        current_block_slot,
         epoch_length,
     )
 
-    result = get_hashes_from_recent_block_hashes(
-        recent_block_hashes,
-        current_block_slot_number,
+    result = get_hashes_from_latest_block_hashes(
+        latest_block_hashes,
+        current_block_slot,
         from_slot,
         to_slot,
         epoch_length,
@@ -169,16 +169,16 @@ def test_get_hashes_from_recent_block_hashes(
 @pytest.mark.xfail(reason="Need to be fixed")
 def test_get_hashes_to_sign(genesis_block, epoch_length):
     epoch_length = epoch_length
-    current_block_slot_number = 1
-    blocks, recent_block_hashes = generate_mock_recent_block_hashes(
+    current_block_slot = 1
+    blocks, latest_block_hashes = generate_mock_latest_block_hashes(
         genesis_block,
-        current_block_slot_number,
+        current_block_slot,
         epoch_length,
     )
 
-    block = blocks[current_block_slot_number]
+    block = blocks[current_block_slot]
     result = get_hashes_to_sign(
-        recent_block_hashes,
+        latest_block_hashes,
         block,
         epoch_length,
     )
@@ -187,25 +187,25 @@ def test_get_hashes_to_sign(genesis_block, epoch_length):
 
 
 @pytest.mark.xfail(reason="Need to be fixed")
-def test_get_new_recent_block_hashes(genesis_block,
+def test_get_new_latest_block_hashes(genesis_block,
                                      epoch_length,
                                      sample_attestation_record_params):
     epoch_length = epoch_length
-    current_block_slot_number = 15
-    blocks, recent_block_hashes = generate_mock_recent_block_hashes(
+    current_block_slot = 15
+    blocks, latest_block_hashes = generate_mock_latest_block_hashes(
         genesis_block,
-        current_block_slot_number,
+        current_block_slot,
         epoch_length,
     )
 
-    block = blocks[current_block_slot_number]
+    block = blocks[current_block_slot]
     oblique_parent_hashes = [b'\x77' * 32]
     attestation = AttestationRecord(**sample_attestation_record_params).copy(
         slot=10,
         oblique_parent_hashes=oblique_parent_hashes,
     )
     result = get_signed_parent_hashes(
-        recent_block_hashes,
+        latest_block_hashes,
         block,
         attestation,
         epoch_length,
@@ -449,12 +449,12 @@ def mock_get_shard_committees_at_slot(parent_block,
     monkeypatch.setattr(
         helpers,
         '_get_shard_committees_at_slot',
-        mock__get_shard_committees_at_slot
+        mock_get_shard_committees_at_slot
     )
 
     parent_block = genesis_block
     parent_block = genesis_block.copy(
-        slot_number=parent_block_number,
+        slot=parent_block_number,
     )
 
     if isinstance(result_proposer_index_in_committee, Exception):