PR feedback

Author: hwwhww

eth/beacon/block_committees_info.py

@@ -1,47 +1,20 @@
 from typing import (
     Iterable,
+    NamedTuple,
     TYPE_CHECKING,
 )
 
 if TYPE_CHECKING:
     from eth.beacon.types.shard_and_committees import ShardAndCommittee  # noqa: F401
 
 
-class BlockCommitteesInfo:
-    _proposer_index = None  # validator index
-    _proposer_index_in_committee = None
-    _proposer_shard_id = None
-    _proposer_committee_size = None
-    _shards_and_committees = None
-
-    def __init__(self,
-                 proposer_index: int,
-                 proposer_index_in_committee: int,
-                 proposer_shard_id: int,
-                 proposer_committee_size: int,
-                 shards_and_committees: Iterable['ShardAndCommittee']) -> None:
-        self._proposer_index = proposer_index
-        self._proposer_index_in_committee = proposer_index_in_committee
-        self._proposer_shard_id = proposer_shard_id
-        self._proposer_committee_size = proposer_committee_size
-        self._shards_and_committees = shards_and_committees
-
-    @property
-    def proposer_index(self) -> int:
-        return self._proposer_index
-
-    @property
-    def proposer_index_in_committee(self) -> int:
-        return self._proposer_index_in_committee
-
-    @property
-    def proposer_shard_id(self) -> int:
-        return self._proposer_shard_id
-
-    @property
-    def proposer_committee_size(self) -> int:
-        return self._proposer_committee_size
-
-    @property
-    def shards_and_committees(self) -> Iterable['ShardAndCommittee']:
-        return self._shards_and_committees
+BlockCommitteesInfo = NamedTuple(
+    'BlockCommitteesInfo',
+    (
+        ('proposer_index', int),
+        ('proposer_index_in_committee', int),
+        ('proposer_shard_id', int),
+        ('proposer_committee_size', int),
+        ('shards_and_committees', Iterable['ShardAndCommittee'])
+    )
+)

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,11 @@
+import functools
 from itertools import (
     repeat,
 )
+
+from cytoolz import (
+    pipe
+)
 from typing import (
     Any,
     Iterable,
@@ -17,6 +22,15 @@
     Hash32,
 )
 
+from eth.utils import bls
+from eth.utils.bitfield import (
+    set_voted,
+)
+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,
@@ -220,18 +234,6 @@ def get_active_validator_indices(dynasty: int,
 #
 # Shuffling
 #
-def clamp(minval: int, x: int, maxval: int) -> int:
-    """
-    Bound the given ``x`` between ``minval`` and ``maxval``
-    """
-    if x <= minval:
-        return minval
-    elif x >= maxval:
-        return maxval
-    else:
-        return x
-
-
 def _get_shuffling_committee_slot_portions(
         active_validators_size: int,
         cycle_length: int,
@@ -333,8 +335,8 @@ def get_new_shuffling(*,
     active_validators_size = len(active_validators)
     committees_per_slot = clamp(
         1,
+        shard_count // cycle_length,
         active_validators_size // cycle_length // (min_committee_size * 2) + 1,
-        shard_count // cycle_length
     )
     shuffled_active_validator_indices = shuffle(active_validators, seed)
 
@@ -365,12 +367,13 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
     """
     Returns the proposer index in committee and the ``shard_id``.
     """
-    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]
+    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(
@@ -392,3 +395,89 @@ def get_block_committees_info(parent_block: 'BaseBeaconBlock',
         proposer_committee_size=proposer_committee_size,
         shards_and_committees=shards_and_committees,
     )
+
+
+#
+# Signatures and Aggregation
+#
+def create_signing_message(slot: int,
+                           parent_hashes: Iterable[Hash32],
+                           shard_id: int,
+                           shard_block_hash: Hash32,
+                           justified_slot: int) -> bytes:
+    # TODO: will be updated to hashed 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 aggregate_attestation_record(last_justified_slot: int,
+                                 recent_block_hashes: Iterable[Hash32],
+                                 block: 'BaseBeaconBlock',
+                                 votes: Iterable[Tuple[int, bytes, int]],
+                                 proposer_attestation: 'AttestationRecord',
+                                 cycle_length: int) -> 'AttestationRecord':
+    """
+    Aggregate the votes.
+
+    TODO: Write tests
+    """
+    # Get signing message
+    parent_hashes = get_hashes_to_sign(
+        recent_block_hashes,
+        block,
+        cycle_length,
+    )
+    message = create_signing_message(
+        block.slot_number,
+        parent_hashes,
+        proposer_attestation.shard_id,
+        block.shard_block_hash,
+        last_justified_slot,
+    )
+    
+    bitfield, sigs = aggregate_votes(
+        message,
+        votes,
+        proposer_attestation.bitfield,
+        proposer_attestation.sigs,
+    )
+
+    return proposer_attestation.copy(
+        bitfield=bitfield,
+        sigs=bls.aggregate_sigs(sigs),
+    )
+
+
+def aggregate_votes(message: bytes,
+                    votes: Iterable[Tuple[int, bytes, int]],
+                    pre_bitfield: bytes,
+                    pre_sigs: Iterable[bytes]) -> Tuple[bytes, Iterable[int]]:
+    # Update the bitfield and append the signatures
+    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 = ()
+        committee_indices = ()
+
+    sigs = sigs + tuple(pre_sigs)
+    bitfield = pre_bitfield
+    bitfield = pipe(
+        bitfield,
+        *(
+            functools.partial(set_voted, index=committee_index)
+            for committee_index in committee_indices
+        )
+    )
+
+    return bitfield, bls.aggregate_sigs(sigs)