Fixes bug with calculating the domain for the BLS signature

The previous implementation was using the `domain_type` as the `domain` when
it should in fact be the value calculated by `get_domain`.

Author: ralexstokes

tests/beacon/test_helpers.py

@@ -785,19 +785,24 @@ def test_verify_vote_count(max_casper_votes, sample_slashable_vote_data_params,
     assert verify_vote_count(votes, max_casper_votes)
 
 
-def _get_indices_and_signatures(num_validators, message, privkeys):
+def _get_indices_and_signatures(num_validators, message, privkeys, fork_data, slot):
     num_indices = 5
     assert num_validators >= num_indices
     indices = random.sample(range(num_validators), num_indices)
     privkeys = [privkeys[i] for i in indices]
-    domain = SignatureDomain.DOMAIN_ATTESTATION
+    domain_type = SignatureDomain.DOMAIN_ATTESTATION
+    domain = get_domain(
+        fork_data=fork_data,
+        slot=slot,
+        domain_type=domain_type,
+    )
     signatures = tuple(
         map(lambda key: bls.sign(message, key, domain), privkeys)
     )
     return (indices, signatures)
 
 
-def _correct_slashable_vote_data_params(params, validators, messages, privkeys):
+def _correct_slashable_vote_data_params(params, validators, messages, privkeys, fork_data):
     valid_params = copy.deepcopy(params)
 
     num_validators = len(validators)
@@ -807,6 +812,8 @@ def _correct_slashable_vote_data_params(params, validators, messages, privkeys):
         num_validators,
         messages[0],
         privkeys,
+        fork_data,
+        params["data"].slot,
     )
     valid_params[key] = poc_0_indices
 
@@ -816,6 +823,8 @@ def _correct_slashable_vote_data_params(params, validators, messages, privkeys):
         num_validators,
         messages[1],
         privkeys,
+        fork_data,
+        params["data"].slot,
     )
     valid_params[key] = poc_1_indices
 
@@ -827,10 +836,15 @@ def _correct_slashable_vote_data_params(params, validators, messages, privkeys):
     return valid_params
 
 
-def _corrupt_signature(params):
+def _corrupt_signature(params, fork_data):
     message = bytes.fromhex("deadbeefcafe")
     privkey = 42
-    domain = SignatureDomain.DOMAIN_ATTESTATION
+    domain_type = SignatureDomain.DOMAIN_ATTESTATION
+    domain = get_domain(
+        fork_data=fork_data,
+        slot=params["data"].slot,
+        domain_type=domain_type,
+    )
     corrupt_signature = bls.sign(message, privkey, domain)
 
     return cytoolz.assoc(params, "aggregate_signature", corrupt_signature)
@@ -860,24 +874,27 @@ def _create_slashable_vote_data_messages(params):
 def test_verify_slashable_vote_data_signature(privkeys,
                                               sample_beacon_state_params,
                                               genesis_validators,
-                                              sample_slashable_vote_data_params):
+                                              sample_slashable_vote_data_params,
+                                              sample_fork_data_params):
     sample_beacon_state_params["validator_registry"] = genesis_validators
     state = BeaconState(**sample_beacon_state_params)
 
     # NOTE: we can do this before "correcting" the params as they
     # touch disjoint subsets of the provided params
     messages = _create_slashable_vote_data_messages(sample_slashable_vote_data_params)
 
+    fork_data = ForkData(**sample_fork_data_params)
     valid_params = _correct_slashable_vote_data_params(
         sample_slashable_vote_data_params,
         genesis_validators,
         messages,
         privkeys,
+        fork_data,
     )
     valid_votes = SlashableVoteData(**valid_params)
     assert verify_slashable_vote_data_signature(state, valid_votes)
 
-    invalid_params = _corrupt_signature(valid_params)
+    invalid_params = _corrupt_signature(valid_params, fork_data)
     invalid_votes = SlashableVoteData(**invalid_params)
     assert not verify_slashable_vote_data_signature(state, invalid_votes)
 
@@ -893,22 +910,27 @@ def _run_verify_slashable_vote(params, state, max_casper_votes, should_succeed):
 
 @pytest.mark.parametrize(
     (
-        'param_mapper,'
-        'should_succeed'
+        'param_mapper',
+        'should_succeed',
+        'needs_fork_data',
     ),
     [
-        (lambda params: params, True),
-        (lambda params: _corrupt_vote_count(params), False),
-        (lambda params: _corrupt_signature(params), False),
-        (lambda params: _corrupt_vote_count(_corrupt_signature(params)), False),
+        (lambda params: params, True, False),
+        (_corrupt_vote_count, False, False),
+        (_corrupt_signature, False, True),
+        (lambda params, fork_data: _corrupt_vote_count(
+            _corrupt_signature(params, fork_data)
+        ), False, True),
     ],
 )
 def test_verify_slashable_vote_data(param_mapper,
                                     should_succeed,
+                                    needs_fork_data,
                                     privkeys,
                                     sample_beacon_state_params,
                                     genesis_validators,
                                     sample_slashable_vote_data_params,
+                                    sample_fork_data_params,
                                     max_casper_votes):
     sample_beacon_state_params["validator_registry"] = genesis_validators
     state = BeaconState(**sample_beacon_state_params)
@@ -917,13 +939,18 @@ def test_verify_slashable_vote_data(param_mapper,
     # touch disjoint subsets of the provided params
     messages = _create_slashable_vote_data_messages(sample_slashable_vote_data_params)
 
+    fork_data = ForkData(**sample_fork_data_params)
     params = _correct_slashable_vote_data_params(
         sample_slashable_vote_data_params,
         genesis_validators,
         messages,
         privkeys,
+        fork_data,
     )
-    params = param_mapper(params)
+    if needs_fork_data:
+        params = param_mapper(params, fork_data)
+    else:
+        params = param_mapper(params)
     _run_verify_slashable_vote(params, state, max_casper_votes, should_succeed)