Merge pull request #1390 from hwwhww/attestation_validation

Per block transition and attestation

Author: hwwhww

eth/beacon/aggregation.py

@@ -0,0 +1,79 @@
+from typing import (
+    Iterable,
+    Tuple,
+)
+from cytoolz import (
+    pipe
+)
+
+
+from eth_typing import (
+    Hash32,
+)
+
+from eth.utils import bls
+from eth.utils.bitfield import (
+    set_voted,
+)
+from eth.utils.blake import blake
+
+
+def create_signing_message(slot: int,
+                           parent_hashes: Iterable[Hash32],
+                           shard_id: int,
+                           shard_block_hash: Hash32,
+                           justified_slot: int) -> bytes:
+    """
+    Return the signining message for attesting.
+    """
+    # TODO: Will be updated with SSZ encoded attestation.
+    return blake(
+        slot.to_bytes(8, byteorder='big') +
+        b''.join(parent_hashes) +
+        shard_id.to_bytes(2, byteorder='big') +
+        shard_block_hash +
+        justified_slot.to_bytes(8, 'big')
+    )
+
+
+def verify_votes(
+        message: bytes,
+        votes: Iterable[Tuple[int, bytes, int]]) -> Tuple[Tuple[bytes, ...], Tuple[int, ...]]:
+    """
+    Verify the given votes.
+
+    vote: (committee_index, sig, public_key)
+    """
+    sigs_with_committe_info = tuple(
+        (sig, committee_index)
+        for (committee_index, sig, public_key)
+        in votes
+        if bls.verify(message, public_key, sig)
+    )
+    try:
+        sigs, committee_indices = zip(*sigs_with_committe_info)
+    except ValueError:
+        sigs = tuple()
+        committee_indices = tuple()
+
+    return sigs, committee_indices
+
+
+def aggregate_votes(bitfield: bytes,
+                    sigs: Iterable[bytes],
+                    voting_sigs: Iterable[bytes],
+                    voting_committee_indices: Iterable[int]) -> Tuple[bytes, Tuple[int]]:
+    """
+    Aggregate the votes.
+    """
+    # Update the bitfield and append the signatures
+    sigs = tuple(sigs) + tuple(voting_sigs)
+    bitfield = pipe(
+        bitfield,
+        *(
+            set_voted(index=committee_index)
+            for committee_index in voting_committee_indices
+        )
+    )
+
+    return bitfield, bls.aggregate_sigs(sigs)

eth/beacon/block_committees_info.py

@@ -0,0 +1,20 @@
+from typing import (
+    NamedTuple,
+    Tuple,
+    TYPE_CHECKING,
+)
+
+if TYPE_CHECKING:
+    from eth.beacon.types.shard_and_committees import ShardAndCommittee  # noqa: F401
+
+
+BlockCommitteesInfo = NamedTuple(
+    'BlockCommitteesInfo',
+    (
+        ('proposer_index', int),
+        ('proposer_index_in_committee', int),
+        ('proposer_shard_id', int),
+        ('proposer_committee_size', int),
+        ('shards_and_committees', Tuple['ShardAndCommittee'])
+    )
+)

eth/beacon/block_proposal.py

@@ -0,0 +1,23 @@
+from typing import (
+    NamedTuple,
+    Tuple,
+    TYPE_CHECKING,
+)
+
+from eth.constants import (
+    Hash32,
+)
+
+if TYPE_CHECKING:
+    from eth.beacon.types.blocks import AttestationRecord  # noqa: F401
+    from eth.beacon.types.blocks import BaseBeaconBlock  # noqa: F401
+
+
+BlockProposal = NamedTuple(
+    'BlockProposal',
+    (
+        ('block', 'BaseBeaconBlock'),
+        ('shard_id', int),
+        ('shard_block_hash', Tuple[Hash32]),
+    )
+)

eth/beacon/db/chain.py

@@ -72,6 +72,10 @@ def get_canonical_block_hash(self, slot: int) -> Hash32:
     def get_canonical_block_by_slot(self, slot: int) -> BaseBeaconBlock:
         pass
 
+    @abstractmethod
+    def get_canonical_block_hash_by_slot(self, slot: int) -> Hash32:
+        pass
+
     @abstractmethod
     def get_canonical_head(self) -> BaseBeaconBlock:
         pass
@@ -195,7 +199,7 @@ def _get_canonical_block_hash(db: BaseDB, slot: int) -> Hash32:
 
     def get_canonical_block_by_slot(self, slot: int) -> BaseBeaconBlock:
         """
-        Return the block header with the given slot in the canonical chain.
+        Return the block with the given slot in the canonical chain.
 
         Raise BlockNotFound if there's no block with the given slot in the
         canonical chain.
@@ -207,10 +211,26 @@ def _get_canonical_block_by_slot(
             cls,
             db: BaseDB,
             slot: int) -> BaseBeaconBlock:
-        validate_slot(slot)
-        canonical_block_hash = cls._get_canonical_block_hash(db, slot)
+        canonical_block_hash = cls._get_canonical_block_hash_by_slot(db, slot)
         return cls._get_block_by_hash(db, canonical_block_hash)
 
+    def get_canonical_block_hash_by_slot(self, slot: int) -> Hash32:
+        """
+        Return the block hash with the given slot in the canonical chain.
+
+        Raise BlockNotFound if there's no block with the given slot in the
+        canonical chain.
+        """
+        return self._get_canonical_block_hash_by_slot(self.db, slot)
+
+    @classmethod
+    def _get_canonical_block_hash_by_slot(
+            cls,
+            db: BaseDB,
+            slot: int) -> Hash32:
+        validate_slot(slot)
+        return cls._get_canonical_block_hash(db, slot)
+
     def get_canonical_head(self) -> BaseBeaconBlock:
         """
         Return the current block at the head of the chain.

eth/beacon/helpers.py

@@ -1,6 +1,7 @@
 from itertools import (
     repeat,
 )
+
 from typing import (
     Any,
     Iterable,
@@ -17,9 +18,11 @@
     Hash32,
 )
 
-from eth.utils.blake import (
-    blake,
+from eth.utils.numeric import (
+    clamp,
 )
+
+from eth.beacon.block_committees_info import BlockCommitteesInfo
 from eth.beacon.types.shard_and_committees import (
     ShardAndCommittee,
 )
@@ -42,7 +45,7 @@ def _get_element_from_recent_list(
         target_slot: int,
         slot_relative_position: int) -> Any:
     """
-    Returns the element from ``target_list`` by the ``target_slot`` number,
+    Return the element from ``target_list`` by the ``target_slot`` number,
     where the the element should be at ``target_slot - slot_relative_position``th
     element of the given ``target_list``.
     """
@@ -72,7 +75,7 @@ def get_block_hash(
         slot: int,
         cycle_length: int) -> Hash32:
     """
-    Returns the blockhash from ``ActiveState.recent_block_hashes`` by
+    Return the blockhash from ``ActiveState.recent_block_hashes`` by
     ``current_block_slot_number``.
     """
     if len(recent_block_hashes) != cycle_length * 2:
@@ -125,7 +128,7 @@ def get_hashes_to_sign(recent_block_hashes: Sequence[Hash32],
         to_slot=block.slot_number - 1,
         cycle_length=cycle_length,
     )
-    yield blake(block.hash)
+    yield block.hash
 
 
 @to_tuple
@@ -189,7 +192,7 @@ def get_attestation_indices(crystallized_state: 'CrystallizedState',
                             attestation: 'AttestationRecord',
                             cycle_length: int) -> Iterable[int]:
     """
-    Returns committee of the given attestation.
+    Return committee of the given attestation.
     """
     shard_id = attestation.shard_id
 
@@ -228,7 +231,7 @@ def _get_shuffling_committee_slot_portions(
         min_committee_size: int,
         shard_count: int) -> Tuple[int, int]:
     """
-    Returns committees number per slot and slots number per committee.
+    Return committees number per slot and slots number per committee.
     """
     # If there are enough active validators to form committees for every slot
     if active_validators_size >= cycle_length * min_committee_size:
@@ -276,7 +279,7 @@ def get_new_shuffling(*,
                       min_committee_size: int,
                       shard_count: int) -> Iterable[Iterable[ShardAndCommittee]]:
     """
-    Returns shuffled ``shard_and_committee_for_slots`` (``[[ShardAndCommittee]]``) of
+    Return shuffled ``shard_and_committee_for_slots`` (``[[ShardAndCommittee]]``) of
     the given active ``validators``.
 
     Two-dimensional:
@@ -321,24 +324,19 @@ def get_new_shuffling(*,
     """
     active_validators = get_active_validator_indices(dynasty, validators)
     active_validators_size = len(active_validators)
-
-    committees_per_slot, slots_per_committee = _get_shuffling_committee_slot_portions(
-        active_validators_size,
-        cycle_length,
-        min_committee_size,
-        shard_count,
+    committees_per_slot = clamp(
+        1,
+        shard_count // cycle_length,
+        active_validators_size // cycle_length // (min_committee_size * 2) + 1,
     )
-
     shuffled_active_validator_indices = shuffle(active_validators, seed)
 
     # Split the shuffled list into cycle_length pieces
     validators_per_slot = split(shuffled_active_validator_indices, cycle_length)
-    for slot, slot_indices in enumerate(validators_per_slot):
+    for index, slot_indices in enumerate(validators_per_slot):
         # Split the shuffled list into committees_per_slot pieces
         shard_indices = split(slot_indices, committees_per_slot)
-        shard_id_start = crosslinking_start_shard + (
-            slot * committees_per_slot // slots_per_committee
-        )
+        shard_id_start = crosslinking_start_shard + index * committees_per_slot
         yield _get_shards_and_committees_for_shard_indices(
             shard_indices,
             shard_id_start,
@@ -349,31 +347,42 @@ def get_new_shuffling(*,
 #
 # Get proposer postition
 #
-def get_proposer_position(parent_block: 'BaseBeaconBlock',
-                          crystallized_state: 'CrystallizedState',
-                          cycle_length: int) -> Tuple[int, int]:
+def get_block_committees_info(parent_block: 'BaseBeaconBlock',
+                              crystallized_state: 'CrystallizedState',
+                              cycle_length: int) -> BlockCommitteesInfo:
     shards_and_committees = get_shards_and_committees_for_slot(
         crystallized_state,
         parent_block.slot_number,
         cycle_length,
     )
     """
-    Returns the proposer index in committee and the ``shard_id``.
+    Return the block committees and proposer info with BlockCommitteesInfo pack.
     """
-    if len(shards_and_committees) <= 0:
-        raise ValueError("shards_and_committees should not be empty.")
-
     # `proposer_index_in_committee` th attester in `shard_and_committee`
     # is the proposer of the parent block.
-    shard_and_committee = shards_and_committees[0]
-    if len(shard_and_committee.committee) <= 0:
+    try:
+        shard_and_committee = shards_and_committees[0]
+    except IndexError:
+        raise ValueError("shards_and_committees should not be empty.")
+
+    proposer_committee_size = len(shard_and_committee.committee)
+    if proposer_committee_size <= 0:
         raise ValueError(
             "The first committee should not be empty"
         )
 
     proposer_index_in_committee = (
         parent_block.slot_number %
-        len(shard_and_committee.committee)
+        proposer_committee_size
     )
 
-    return proposer_index_in_committee, shard_and_committee.shard_id
+    # The index in CrystallizedState.validators
+    proposer_index = shard_and_committee.committee[proposer_index_in_committee]
+
+    return BlockCommitteesInfo(
+        proposer_index=proposer_index,
+        proposer_index_in_committee=proposer_index_in_committee,
+        proposer_shard_id=shard_and_committee.shard_id,
+        proposer_committee_size=proposer_committee_size,
+        shards_and_committees=shards_and_committees,
+    )