Add AttestationDataAndCustodyBit data structure

1. Update `SlashableVoteData.messages`
2. Rename `aggregate_signature_poc_0_indices` => `custody_bit_0_indices`
3. Rename `aggregate_signature_poc_1_indices` => `custody_bit_1_indices`

Author: hwwhww

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/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,
         )

eth/beacon/types/states.py

@@ -65,8 +65,7 @@ class BeaconState(rlp.Serializable):
         ('persistent_committees', CountableList(CountableList(uint24))),
         ('persistent_committee_reassignments', CountableList(ShardReassignmentRecord)),
 
-
-        # Proof of custody
+        # Custody challenges
         ('custody_challenges', CountableList(CustodyChallenge)),
 
         # Finality

tests/beacon/conftest.py

@@ -117,6 +117,14 @@ def sample_attestation_data_params():
     }
 
 
+@pytest.fixture
+def sample_attestation_data_and_custody_bit_params(sample_attestation_data_params):
+    return {
+        'data': AttestationData(**sample_attestation_data_params),
+        'custody_bit': False,
+    }
+
+
 @pytest.fixture
 def sample_beacon_block_body_params():
     return {
@@ -287,8 +295,8 @@ def sample_shard_reassignment_record():
 @pytest.fixture
 def sample_slashable_vote_data_params(sample_attestation_data_params):
     return {
-        'aggregate_signature_poc_0_indices': (10, 11, 12, 15, 28),
-        'aggregate_signature_poc_1_indices': (7, 8, 100, 131, 249),
+        'custody_bit_0_indices': (10, 11, 12, 15, 28),
+        'custody_bit_1_indices': (7, 8, 100, 131, 249),
         'data': AttestationData(**sample_attestation_data_params),
         'aggregate_signature': (1, 2, 3, 4, 5),
     }

tests/beacon/test_helpers.py

@@ -766,13 +766,13 @@ def test_generate_aggregate_pubkeys(genesis_validators, sample_slashable_vote_da
             max_value=max_value_for_list,
         )
     )
-    proof_of_custody_0_indices = indices[:some_index]
-    proof_of_custody_1_indices = indices[some_index:]
+    custody_bit_0_indices = indices[:some_index]
+    custody_bit_1_indices = indices[some_index:]
 
-    key = "aggregate_signature_poc_0_indices"
-    sample_slashable_vote_data_params[key] = proof_of_custody_0_indices
-    key = "aggregate_signature_poc_1_indices"
-    sample_slashable_vote_data_params[key] = proof_of_custody_1_indices
+    key = "custody_bit_0_indices"
+    sample_slashable_vote_data_params[key] = custody_bit_0_indices
+    key = "custody_bit_1_indices"
+    sample_slashable_vote_data_params[key] = custody_bit_1_indices
 
     votes = SlashableVoteData(**sample_slashable_vote_data_params)
 
@@ -781,8 +781,8 @@ def test_generate_aggregate_pubkeys(genesis_validators, sample_slashable_vote_da
 
     (poc_0_key, poc_1_key) = keys
 
-    poc_0_keys = get_pubkey_for_indices(genesis_validators, proof_of_custody_0_indices)
-    poc_1_keys = get_pubkey_for_indices(genesis_validators, proof_of_custody_1_indices)
+    poc_0_keys = get_pubkey_for_indices(genesis_validators, custody_bit_0_indices)
+    poc_1_keys = get_pubkey_for_indices(genesis_validators, custody_bit_1_indices)
 
     assert bls.aggregate_pubkeys(poc_0_keys) == poc_0_key
     assert bls.aggregate_pubkeys(poc_1_keys) == poc_1_key
@@ -791,13 +791,13 @@ def test_generate_aggregate_pubkeys(genesis_validators, sample_slashable_vote_da
 @given(st.data())
 def test_verify_vote_count(max_casper_votes, sample_slashable_vote_data_params, data):
     (indices, some_index) = _list_and_index(data, max_size=max_casper_votes)
-    proof_of_custody_0_indices = indices[:some_index]
-    proof_of_custody_1_indices = indices[some_index:]
+    custody_bit_0_indices = indices[:some_index]
+    custody_bit_1_indices = indices[some_index:]
 
-    key = "aggregate_signature_poc_0_indices"
-    sample_slashable_vote_data_params[key] = proof_of_custody_0_indices
-    key = "aggregate_signature_poc_1_indices"
-    sample_slashable_vote_data_params[key] = proof_of_custody_1_indices
+    key = "custody_bit_0_indices"
+    sample_slashable_vote_data_params[key] = custody_bit_0_indices
+    key = "custody_bit_1_indices"
+    sample_slashable_vote_data_params[key] = custody_bit_1_indices
 
     votes = SlashableVoteData(**sample_slashable_vote_data_params)
 
@@ -821,15 +821,15 @@ def _correct_slashable_vote_data_params(params, validators, messages, privkeys):
 
     num_validators = len(validators)
 
-    key = "aggregate_signature_poc_0_indices"
+    key = "custody_bit_0_indices"
     (poc_0_indices, poc_0_signatures) = _get_indices_and_signatures(
         num_validators,
         messages[0],
         privkeys,
     )
     valid_params[key] = poc_0_indices
 
-    key = "aggregate_signature_poc_1_indices"
+    key = "custody_bit_1_indices"
     # NOTE: does not guarantee non-empty intersection
     (poc_1_indices, poc_1_signatures) = _get_indices_and_signatures(
         num_validators,
@@ -857,7 +857,7 @@ def _corrupt_signature(params):
 
 def _corrupt_vote_count(params):
     params = copy.deepcopy(params)
-    key = "aggregate_signature_poc_0_indices"
+    key = "custody_bit_0_indices"
     for i in itertools.count():
         if i not in params[key]:
             params[key].append(i)

tests/beacon/types/test_attestation_data_and_custody_bit.py

@@ -0,0 +1,11 @@
+from eth.beacon.types.attestation_data_and_custody_bits import (
+    AttestationDataAndCustodyBit,
+)
+
+
+def test_defaults(sample_attestation_data_and_custody_bit_params):
+    params = sample_attestation_data_and_custody_bit_params
+    attestation_data_and_custody_bit = AttestationDataAndCustodyBit(**params)
+
+    assert attestation_data_and_custody_bit.data == params['data']
+    assert attestation_data_and_custody_bit.custody_bit == params['custody_bit']

tests/beacon/types/test_casper_slashings.py

@@ -5,12 +5,12 @@ def test_defaults(sample_casper_slashing_params):
     slashing = CasperSlashing(**sample_casper_slashing_params)
 
     assert (slashing.slashable_vote_data_1
-            .aggregate_signature_poc_0_indices ==
+            .custody_bit_0_indices ==
             sample_casper_slashing_params['slashable_vote_data_1']
-            .aggregate_signature_poc_0_indices
+            .custody_bit_0_indices
             )
     assert (slashing.slashable_vote_data_2
-            .aggregate_signature_poc_1_indices ==
+            .custody_bit_1_indices ==
             sample_casper_slashing_params['slashable_vote_data_2']
-            .aggregate_signature_poc_1_indices
+            .custody_bit_1_indices
             )

tests/beacon/types/test_slashable_vote_data.py

@@ -1,21 +1,24 @@
+from eth.beacon.types.attestation_data_and_custody_bits import (
+    AttestationDataAndCustodyBit,
+)
 from eth.beacon.types.slashable_vote_data import (
     SlashableVoteData,
 )
 
 
 def test_defaults(sample_slashable_vote_data_params):
-    votes = SlashableVoteData(**sample_slashable_vote_data_params)
+    vote_data = SlashableVoteData(**sample_slashable_vote_data_params)
 
-    assert (votes.aggregate_signature_poc_0_indices ==
-            sample_slashable_vote_data_params['aggregate_signature_poc_0_indices'])
-    assert (votes.aggregate_signature_poc_1_indices ==
-            sample_slashable_vote_data_params['aggregate_signature_poc_1_indices'])
-    assert votes.data == sample_slashable_vote_data_params['data']
-    assert votes.aggregate_signature == sample_slashable_vote_data_params['aggregate_signature']
+    assert (vote_data.custody_bit_0_indices ==
+            sample_slashable_vote_data_params['custody_bit_0_indices'])
+    assert (vote_data.custody_bit_1_indices ==
+            sample_slashable_vote_data_params['custody_bit_1_indices'])
+    assert vote_data.data == sample_slashable_vote_data_params['data']
+    assert vote_data.aggregate_signature == sample_slashable_vote_data_params['aggregate_signature']
 
 
 def test_hash(sample_slashable_vote_data_params):
-    votes = SlashableVoteData(**sample_slashable_vote_data_params)
+    vote_data = SlashableVoteData(**sample_slashable_vote_data_params)
 
     # NOTE: this hash was simply copied from the existing implementation
     # which should be the keccak-256 of the rlp serialization of `votes`.
@@ -24,36 +27,33 @@ def test_hash(sample_slashable_vote_data_params):
     # if we expect the hash computation is not working correctly
     hash_hex = "7e4b4cf3ac47988865d693a29b6aa5a825f27e065cf21a80af5e077ea102e297"
 
-    assert votes.hash == bytes.fromhex(hash_hex)
+    assert vote_data.hash == bytes.fromhex(hash_hex)
 
 
 def test_root(sample_slashable_vote_data_params):
-    votes = SlashableVoteData(**sample_slashable_vote_data_params)
+    vote_data = SlashableVoteData(**sample_slashable_vote_data_params)
 
     # NOTE: see note in `test_hash`, this test will need to be updated
     # once ssz tree hash lands...
 
-    assert votes.root == votes.hash
+    assert vote_data.root == vote_data.hash
 
 
 def test_vote_count(sample_slashable_vote_data_params):
-    votes = SlashableVoteData(**sample_slashable_vote_data_params)
+    vote_data = SlashableVoteData(**sample_slashable_vote_data_params)
 
-    key = "aggregate_signature_poc_0_indices"
-    proof_of_custody_0_indices = sample_slashable_vote_data_params[key]
-    key = "aggregate_signature_poc_1_indices"
-    proof_of_custody_1_indices = sample_slashable_vote_data_params[key]
+    key = "custody_bit_0_indices"
+    custody_bit_0_indices = sample_slashable_vote_data_params[key]
+    key = "custody_bit_1_indices"
+    custody_bit_1_indices = sample_slashable_vote_data_params[key]
 
-    assert votes.vote_count == len(proof_of_custody_0_indices) + len(proof_of_custody_1_indices)
+    assert vote_data.vote_count == len(custody_bit_0_indices) + len(custody_bit_1_indices)
 
 
 def test_messages(sample_slashable_vote_data_params):
-    votes = SlashableVoteData(**sample_slashable_vote_data_params)
-
-    zero_discriminator = (0).to_bytes(1, 'big')
-    one_discriminator = (1).to_bytes(1, 'big')
+    vote_data = SlashableVoteData(**sample_slashable_vote_data_params)
 
-    assert votes.messages == (
-        votes.root + zero_discriminator,
-        votes.root + one_discriminator,
+    assert vote_data.messages == (
+        AttestationDataAndCustodyBit(vote_data.data, False).root,
+        AttestationDataAndCustodyBit(vote_data.data, True).root,
     )