Merge pull request #1675 from hwwhww/poc_placeholder

Add proof of custody placeholders

Author: hwwhww

eth/beacon/deposit_helpers.py

@@ -54,11 +54,13 @@ def validate_proof_of_possession(state: BeaconState,
                                  pubkey: BLSPubkey,
                                  proof_of_possession: BLSSignature,
                                  withdrawal_credentials: Hash32,
-                                 randao_commitment: Hash32) -> None:
+                                 randao_commitment: Hash32,
+                                 custody_commitment: Hash32) -> None:
     deposit_input = DepositInput(
         pubkey=pubkey,
         withdrawal_credentials=withdrawal_credentials,
         randao_commitment=randao_commitment,
+        custody_commitment=custody_commitment,
         proof_of_possession=EMPTY_SIGNATURE,
     )
 
@@ -119,6 +121,7 @@ def process_deposit(*,
                     proof_of_possession: BLSSignature,
                     withdrawal_credentials: Hash32,
                     randao_commitment: Hash32,
+                    custody_commitment: Hash32,
                     zero_balance_validator_ttl: int) -> Tuple[BeaconState, ValidatorIndex]:
     """
     Process a deposit from Ethereum 1.0.
@@ -129,6 +132,7 @@ def process_deposit(*,
         proof_of_possession,
         withdrawal_credentials,
         randao_commitment,
+        custody_commitment,
     )
 
     validator_pubkeys = tuple(v.pubkey for v in state.validator_registry)
@@ -138,6 +142,7 @@ def process_deposit(*,
             withdrawal_credentials=withdrawal_credentials,
             randao_commitment=randao_commitment,
             latest_status_change_slot=state.slot,
+            custody_commitment=custody_commitment,
         )
 
         state, index = add_pending_validator(

eth/beacon/helpers.py

@@ -437,9 +437,9 @@ def generate_aggregate_pubkeys(validators: Sequence['ValidatorRecord'],
     Compute the aggregate pubkey we expect based on
     the proof-of-custody indices found in the ``vote_data``.
     """
-    proof_of_custody_0_indices = vote_data.aggregate_signature_poc_0_indices
-    proof_of_custody_1_indices = vote_data.aggregate_signature_poc_1_indices
-    all_indices = (proof_of_custody_0_indices, proof_of_custody_1_indices)
+    custody_bit_0_indices = vote_data.custody_bit_0_indices
+    custody_bit_1_indices = vote_data.custody_bit_1_indices
+    all_indices = (custody_bit_0_indices, custody_bit_1_indices)
     get_pubkeys = functools.partial(get_pubkey_for_indices, validators)
     return map(
         bls.aggregate_pubkeys,

eth/beacon/types/attestation_data_and_custody_bits.py

@@ -0,0 +1,50 @@
+import rlp
+from rlp.sedes import (
+    Boolean,
+)
+from eth_typing import (
+    Hash32,
+)
+
+from eth.beacon._utils.hash import (
+    hash_eth2,
+)
+
+from .attestation_data import (
+    AttestationData,
+)
+
+
+class AttestationDataAndCustodyBit(rlp.Serializable):
+    """
+    Note: using RLP until we have standardized serialization format.
+    """
+    fields = [
+        # Attestation data
+        ('data', AttestationData),
+        # Custody bit
+        ('custody_bit', Boolean),
+    ]
+
+    def __init__(self,
+                 data: AttestationData,
+                 custody_bit: bool)-> None:
+
+        super().__init__(
+            data=data,
+            custody_bit=custody_bit,
+        )
+
+    _hash = None
+
+    @property
+    def hash(self) -> Hash32:
+        if self._hash is None:
+            self._hash = hash_eth2(rlp.encode(self.data))
+        return self._hash
+
+    @property
+    def root(self) -> Hash32:
+        # Alias of `hash`.
+        # Using flat hash, will likely use SSZ tree hash.
+        return self.hash

eth/beacon/types/blocks.py

@@ -39,10 +39,13 @@
 
 
 from .attestations import Attestation
-from .proposer_slashings import ProposerSlashing
+from .custody_challenges import CustodyChallenge
+from .custody_reseeds import CustodyReseed
+from .custody_responses import CustodyResponse
 from .casper_slashings import CasperSlashing
 from .deposits import Deposit
 from .exits import Exit
+from .proposer_slashings import ProposerSlashing
 
 if TYPE_CHECKING:
     from eth.beacon.db.chain import BaseBeaconChainDB  # noqa: F401
@@ -53,20 +56,29 @@ class BaseBeaconBlockBody(rlp.Serializable):
         ('proposer_slashings', CountableList(ProposerSlashing)),
         ('casper_slashings', CountableList(CasperSlashing)),
         ('attestations', CountableList(Attestation)),
+        ('custody_reseeds', CountableList(CustodyReseed)),
+        ('custody_challenges', CountableList(CustodyChallenge)),
+        ('custody_responses', CountableList(CustodyResponse)),
         ('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:
+                 proposer_slashings: Sequence[ProposerSlashing],
+                 casper_slashings: Sequence[CasperSlashing],
+                 attestations: Sequence[Attestation],
+                 custody_reseeds: Sequence[CustodyReseed],
+                 custody_challenges: Sequence[CustodyResponse],
+                 custody_responses: Sequence[CustodyResponse],
+                 deposits: Sequence[Deposit],
+                 exits: Sequence[Exit])-> None:
         super().__init__(
             proposer_slashings=proposer_slashings,
             casper_slashings=casper_slashings,
             attestations=attestations,
+            custody_reseeds=custody_reseeds,
+            custody_challenges=custody_challenges,
+            custody_responses=custody_responses,
             deposits=deposits,
             exits=exits,
         )
@@ -166,6 +178,9 @@ def from_root(cls, root: Hash32, chaindb: 'BaseBeaconChainDB') -> 'BeaconBlock':
             proposer_slashings=block.body.proposer_slashings,
             casper_slashings=block.body.casper_slashings,
             attestations=block.body.attestations,
+            custody_reseeds=block.body.custody_reseeds,
+            custody_challenges=block.body.custody_challenges,
+            custody_responses=block.body.custody_responses,
             deposits=block.body.deposits,
             exits=block.body.exits,
         )

eth/beacon/types/custody_challenges.py

@@ -0,0 +1,5 @@
+import rlp
+
+
+class CustodyChallenge(rlp.Serializable):
+    pass

eth/beacon/types/custody_reseeds.py

@@ -0,0 +1,5 @@
+import rlp
+
+
+class CustodyReseed(rlp.Serializable):
+    pass

eth/beacon/types/custody_responses.py

@@ -0,0 +1,5 @@
+import rlp
+
+
+class CustodyResponse(rlp.Serializable):
+    pass

eth/beacon/types/deposit_input.py

@@ -29,6 +29,8 @@ class DepositInput(rlp.Serializable):
         ('withdrawal_credentials', hash32),
         # Initial RANDAO commitment
         ('randao_commitment', hash32),
+        # Initial proof of custody commitment
+        ('custody_commitment', hash32),
         # BLS proof of possession (a BLS signature)
         ('proof_of_possession', CountableList(uint384)),
     ]
@@ -37,11 +39,13 @@ def __init__(self,
                  pubkey: BLSPubkey,
                  withdrawal_credentials: Hash32,
                  randao_commitment: Hash32,
+                 custody_commitment: Hash32,
                  proof_of_possession: BLSSignature=EMPTY_SIGNATURE) -> None:
         super().__init__(
             pubkey=pubkey,
             withdrawal_credentials=withdrawal_credentials,
             randao_commitment=randao_commitment,
+            custody_commitment=custody_commitment,
             proof_of_possession=proof_of_possession,
         )
 

eth/beacon/types/pending_attestation_records.py

@@ -25,9 +25,9 @@ class PendingAttestationRecord(rlp.Serializable):
         ('data', AttestationData),
         # Attester participation bitfield
         ('participation_bitfield', binary),
-        # Proof of custody bitfield
+        # Custody bitfield
         ('custody_bitfield', binary),
-        # Slot in which it was included
+        # Slot the attestation was included
         ('slot_included', uint64),
     ]
 

eth/beacon/types/slashable_vote_data.py

@@ -21,31 +21,32 @@
 from eth.beacon.constants import EMPTY_SIGNATURE
 
 from .attestation_data import AttestationData
+from .attestation_data_and_custody_bits import AttestationDataAndCustodyBit
 
 
 class SlashableVoteData(rlp.Serializable):
     """
     Note: using RLP until we have standardized serialization format.
     """
     fields = [
-        # Proof-of-custody indices (0 bits)
-        ('aggregate_signature_poc_0_indices', CountableList(uint24)),
-        # Proof-of-custody indices (1 bits)
-        ('aggregate_signature_poc_1_indices', CountableList(uint24)),
+        # Validator indices with custody bit equal to 0
+        ('custody_bit_0_indices', CountableList(uint24)),
+        # Validator indices with custody bit equal to 1
+        ('custody_bit_1_indices', CountableList(uint24)),
         # Attestation data
         ('data', AttestationData),
         # Aggregate signature
         ('aggregate_signature', CountableList(uint384)),
     ]
 
     def __init__(self,
-                 aggregate_signature_poc_0_indices: Sequence[ValidatorIndex],
-                 aggregate_signature_poc_1_indices: Sequence[ValidatorIndex],
+                 custody_bit_0_indices: Sequence[ValidatorIndex],
+                 custody_bit_1_indices: Sequence[ValidatorIndex],
                  data: AttestationData,
                  aggregate_signature: BLSSignature = EMPTY_SIGNATURE) -> None:
         super().__init__(
-            aggregate_signature_poc_0_indices,
-            aggregate_signature_poc_1_indices,
+            custody_bit_0_indices,
+            custody_bit_1_indices,
             data,
             aggregate_signature,
         )
@@ -69,19 +70,18 @@ def root(self) -> Hash32:
     @property
     def vote_count(self) -> int:
         if self._vote_count is None:
-            count_zero_indices = len(self.aggregate_signature_poc_0_indices)
-            count_one_indices = len(self.aggregate_signature_poc_1_indices)
+            count_zero_indices = len(self.custody_bit_0_indices)
+            count_one_indices = len(self.custody_bit_1_indices)
             self._vote_count = count_zero_indices + count_one_indices
         return self._vote_count
 
     @property
-    def messages(self) -> Tuple[bytes, bytes]:
+    def messages(self) -> Tuple[Hash32, Hash32]:
         """
         Build the messages that validators are expected to sign for a ``CasperSlashing`` operation.
         """
-        # TODO: change to hash_tree_root(vote_data) when we have SSZ tree hashing
-        vote_data_root = self.root
+        # TODO: change to hash_tree_root when we have SSZ tree hashing
         return (
-            vote_data_root + (0).to_bytes(1, 'big'),
-            vote_data_root + (1).to_bytes(1, 'big'),
+            AttestationDataAndCustodyBit(self.data, False).root,
+            AttestationDataAndCustodyBit(self.data, True).root,
         )