Fix #1582, Special -> operations and rework beacon block (#1585)

* delete special_records and add casper_slashings

* add a crappy Deposit

* fix attestation block exit proposer_slashings and add tests

* fix linting error by removing unused block_proposal.py

* split deposits, deposit_data, deposit_parameters, casper_slashings, and slashable_vote_data out

* fix validator_index in Exit

* replace ancestor_hashes and parent_hash with parent_root, reorder BeaconBlockBody attestation field, and fix comments

* use tuple as default parameter

* remove kwargs for performance

* make flake8 happy

* more ancestor_hashes to parent_root, and rework get_pseudo_chain

* update casper_slashings to reflect ethereum/consensus-specs/pull/301

* refactor get_pseudo_chain to yield

* flake8

* fix create_test_block

* fix child.parent_root

Author: ChihChengLiang

eth/beacon/block_proposal.py

@@ -278,25 +278,25 @@ def _persist_block_chain(
             return tuple(), tuple()
         else:
             for parent, child in sliding_window(2, blocks):
-                if parent.hash != child.parent_hash:
+                if parent.hash != child.parent_root:
                     raise ValidationError(
                         "Non-contiguous chain. Expected {} to have {} as parent but was {}".format(
                             encode_hex(child.hash),
                             encode_hex(parent.hash),
-                            encode_hex(child.parent_hash),
+                            encode_hex(child.parent_root),
                         )
                     )
 
-            is_genesis = first_block.parent_hash == GENESIS_PARENT_HASH
-            if not is_genesis and not cls._block_exists(db, first_block.parent_hash):
+            is_genesis = first_block.parent_root == GENESIS_PARENT_HASH
+            if not is_genesis and not cls._block_exists(db, first_block.parent_root):
                 raise ParentNotFound(
                     "Cannot persist block ({}) with unknown parent ({})".format(
-                        encode_hex(first_block.hash), encode_hex(first_block.parent_hash)))
+                        encode_hex(first_block.hash), encode_hex(first_block.parent_root)))
 
             if is_genesis:
                 score = 0
             else:
-                score = cls._get_score(db, first_block.parent_hash)
+                score = cls._get_score(db, first_block.parent_root)
 
         for block in blocks:
             db.set(
@@ -389,10 +389,10 @@ def _find_new_ancestors(cls, db: BaseDB, block: BaseBeaconBlock) -> Iterable[Bas
             # Found a new ancestor
             yield block
 
-            if block.parent_hash == GENESIS_PARENT_HASH:
+            if block.parent_root == GENESIS_PARENT_HASH:
                 break
             else:
-                block = cls._get_block_by_hash(db, block.parent_hash)
+                block = cls._get_block_by_hash(db, block.parent_root)
 
     @staticmethod
     def _add_block_slot_to_hash_lookup(db: BaseDB, block: BaseBeaconBlock) -> None:

eth/beacon/db/chain.py

@@ -42,12 +42,12 @@ def __init__(self,
                  justified_slot: int,
                  justified_block_hash: Hash32) -> None:
         super().__init__(
-            slot=slot,
-            shard=shard,
-            beacon_block_hash=beacon_block_hash,
-            epoch_boundary_hash=epoch_boundary_hash,
-            shard_block_hash=shard_block_hash,
-            latest_crosslink_hash=latest_crosslink_hash,
-            justified_slot=justified_slot,
-            justified_block_hash=justified_block_hash,
+            slot,
+            shard,
+            beacon_block_hash,
+            epoch_boundary_hash,
+            shard_block_hash,
+            latest_crosslink_hash,
+            justified_slot,
+            justified_block_hash,
         )

eth/beacon/types/attestation_data.py

@@ -18,7 +18,7 @@
 )
 
 
-class AttestationRecord(rlp.Serializable):
+class Attestation(rlp.Serializable):
     """
     Note: using RLP until we have standardized serialization format.
     """
@@ -36,13 +36,10 @@ def __init__(self,
                  data: AttestationData,
                  participation_bitfield: bytes,
                  custody_bitfield: bytes,
-                 aggregate_sig: Sequence[int]=None) -> None:
-        if aggregate_sig is None:
-            aggregate_sig = (0, 0)
-
+                 aggregate_sig: Sequence[int]=(0, 0)) -> None:
         super().__init__(
-            data=data,
-            participation_bitfield=participation_bitfield,
-            custody_bitfield=custody_bitfield,
-            aggregate_sig=aggregate_sig,
+            data,
+            participation_bitfield,
+            custody_bitfield,
+            aggregate_sig,
         )

eth/beacon/types/attestation_records.py renamed to eth/beacon/types/attestations.py

@@ -21,51 +21,73 @@
 )
 from eth.utils.blake import blake
 
-from .attestation_records import AttestationRecord
-from .special_records import SpecialRecord
+from .attestations import Attestation
+from .proposer_slashings import ProposerSlashing
+from .casper_slashings import CasperSlashing
+from .deposits import Deposit
+from .exits import Exit
+
+
+class BeaconBlockBody(rlp.Serializable):
+    fields = [
+        ('proposer_slashings', CountableList(ProposerSlashing)),
+        ('casper_slashings', CountableList(CasperSlashing)),
+        ('attestations', CountableList(Attestation)),
+        ('deposits', CountableList(Deposit)),
+        ('exits', CountableList(Exit)),
+    ]
+
+    def __init__(self,
+                 proposer_slashings: Sequence[int],
+                 casper_slashings: Sequence[int],
+                 attestations: Sequence[int],
+                 deposits: Sequence[int],
+                 exits: Sequence[int])-> None:
+        super().__init__(
+            proposer_slashings=proposer_slashings,
+            casper_slashings=casper_slashings,
+            attestations=attestations,
+            deposits=deposits,
+            exits=exits,
+        )
 
 
 class BaseBeaconBlock(rlp.Serializable):
     fields = [
-        # Slot number
+        #
+        # Header
+        #
         ('slot', uint64),
-        # Proposer RANDAO reveal
-        ('randao_reveal', hash32),
-        # Recent PoW receipt root
-        ('candidate_pow_receipt_root', hash32),
         # Skip list of previous beacon block hashes
         # i'th item is the most recent ancestor whose slot is a multiple of 2**i for i = 0, ..., 31
-        ('ancestor_hashes', CountableList(hash32)),
-        # State root
+        ('parent_root', hash32),
         ('state_root', hash32),
-        # Attestations
-        ('attestations', CountableList(AttestationRecord)),
-        # Specials (e.g. logouts, penalties)
-        ('specials', CountableList(SpecialRecord)),
-        # Proposer signature
-        ('proposer_signature', CountableList(uint256)),
+        ('randao_reveal', hash32),
+        ('candidate_pow_receipt_root', hash32),
+        ('signature', CountableList(uint256)),
+
+        #
+        # Body
+        #
+        ('body', BeaconBlockBody)
     ]
 
     def __init__(self,
                  slot: int,
+                 parent_root: Hash32,
+                 state_root: Hash32,
                  randao_reveal: Hash32,
                  candidate_pow_receipt_root: Hash32,
-                 ancestor_hashes: Sequence[Hash32],
-                 state_root: Hash32,
-                 attestations: Sequence[AttestationRecord],
-                 specials: Sequence[SpecialRecord],
-                 proposer_signature: Sequence[int]=None) -> None:
-        if proposer_signature is None:
-            proposer_signature = (0, 0)
+                 body: BeaconBlockBody,
+                 signature: Sequence[int]=(0, 0)) -> None:
         super().__init__(
-            slot=slot,
-            randao_reveal=randao_reveal,
-            candidate_pow_receipt_root=candidate_pow_receipt_root,
-            ancestor_hashes=ancestor_hashes,
-            state_root=state_root,
-            attestations=attestations,
-            specials=specials,
-            proposer_signature=proposer_signature,
+            slot,
+            parent_root,
+            state_root,
+            randao_reveal,
+            candidate_pow_receipt_root,
+            signature,
+            body
         )
 
     def __repr__(self) -> str:
@@ -84,11 +106,4 @@ def hash(self) -> Hash32:
 
     @property
     def num_attestations(self) -> int:
-        return len(self.attestations)
-
-    @property
-    def parent_hash(self) -> Hash32:
-        if not self.ancestor_hashes:
-            return None
-        else:
-            return self.ancestor_hashes[0]
+        return len(self.body.attestations)

eth/beacon/types/blocks.py

@@ -0,0 +1,22 @@
+import rlp
+from .slashable_vote_data import SlashableVoteData
+
+
+class CasperSlashing(rlp.Serializable):
+    """
+    Note: using RLP until we have standardized serialization format.
+    """
+    fields = [
+        # First batch of votes
+        ('slashable_vote_data_1', SlashableVoteData),
+        # Second batch of votes
+        ('slashable_vote_data_2', SlashableVoteData),
+    ]
+
+    def __init__(self,
+                 slashable_vote_data_1: SlashableVoteData,
+                 slashable_vote_data_2: SlashableVoteData)-> None:
+        super().__init__(
+            slashable_vote_data_1,
+            slashable_vote_data_2,
+        )

eth/beacon/types/casper_slashings.py

@@ -0,0 +1,29 @@
+
+import rlp
+from eth.rlp.sedes import uint64
+from .deposit_parameters import DepositParameters
+
+
+class DepositData(rlp.Serializable):
+    """
+    Not in spec, this is for fields in Deposit
+    """
+    fields = [
+        # Deposit parameters
+        ('deposit_parameters', DepositParameters),
+        # Value in Gwei
+        ('value', uint64),
+        # Timestamp from deposit contract
+        ('timestamp', uint64),
+    ]
+
+    def __init__(self,
+                 deposit_parameters: DepositParameters,
+                 value: int,
+                 timestamp: int) -> None:
+
+        super().__init__(
+            deposit_parameters,
+            value,
+            timestamp,
+        )

eth/beacon/types/deposit_data.py

@@ -16,7 +16,7 @@
 )
 
 
-class DepositParametersRecord(rlp.Serializable):
+class DepositParameters(rlp.Serializable):
     """
     Note: using RLP until we have standardized serialization format.
     """
@@ -35,13 +35,10 @@ def __init__(self,
                  pubkey: int,
                  withdrawal_credentials: Hash32,
                  randao_commitment: Hash32,
-                 proof_of_possession: Sequence[int]=None) -> None:
-        if proof_of_possession is None:
-            proof_of_possession = (0, 0)
-
+                 proof_of_possession: Sequence[int]=(0, 0)) -> None:
         super().__init__(
-            pubkey=pubkey,
-            proof_of_possession=proof_of_possession,
-            withdrawal_credentials=withdrawal_credentials,
-            randao_commitment=randao_commitment,
+            pubkey,
+            proof_of_possession,
+            withdrawal_credentials,
+            randao_commitment,
         )

eth/beacon/types/deposit_parameters_records.py renamed to eth/beacon/types/deposit_parameters.py

@@ -0,0 +1,43 @@
+from typing import (
+    Sequence,
+)
+
+from eth_typing import (
+    Hash32,
+)
+import rlp
+from rlp.sedes import (
+    CountableList,
+)
+
+from eth.rlp.sedes import (
+    hash32,
+    uint64,
+)
+
+from .deposit_data import DepositData
+
+
+class Deposit(rlp.Serializable):
+    """
+    Note: using RLP until we have standardized serialization format.
+    """
+
+    fields = [
+        # Receipt Merkle branch
+        ('merkle_branch', CountableList(hash32)),
+        # Merkle tree index
+        ('merkle_tree_index', uint64),
+        # Deposit data
+        ('deposit_data', DepositData),
+    ]
+
+    def __init__(self,
+                 merkle_branch: Sequence[Hash32],
+                 merkle_tree_index: int,
+                 deposit_data: DepositData)-> None:
+        super().__init__(
+            merkle_branch,
+            merkle_tree_index,
+            deposit_data,
+        )

eth/beacon/types/deposits.py

@@ -0,0 +1,34 @@
+from typing import Sequence
+import rlp
+from rlp.sedes import (
+    CountableList,
+)
+from eth.rlp.sedes import (
+    uint24,
+    uint64,
+    uint256,
+)
+
+
+class Exit(rlp.Serializable):
+    """
+    Note: using RLP until we have standardized serialization format.
+    """
+    fields = [
+        # Minimum slot for processing exit
+        ('slot', uint64),
+        # Index of the exiting validator
+        ('validator_index', uint24),
+        # Validator signature
+        ('signature', CountableList(uint256)),
+    ]
+
+    def __init__(self,
+                 slot: int,
+                 validator_index: int,
+                 signature: Sequence[int]) -> None:
+        super().__init__(
+            slot,
+            validator_index,
+            signature,
+        )