Test coverage improvements

test_libs/pyspec/eth2spec/test/helpers/transfers.py

@@ -4,13 +4,15 @@
 from eth2spec.utils.ssz.ssz_impl import signing_root
 
 
-def get_valid_transfer(spec, state, slot=None, sender_index=None, amount=None, fee=None, signed=False):
+def get_valid_transfer(spec, state, slot=None, sender_index=None,
+                       recipient_index=None, amount=None, fee=None, signed=False):
     if slot is None:
         slot = state.slot
     current_epoch = spec.get_current_epoch(state)
     if sender_index is None:
         sender_index = spec.get_active_validator_indices(state, current_epoch)[-1]
-    recipient_index = spec.get_active_validator_indices(state, current_epoch)[0]
+    if recipient_index is None:
+        recipient_index = spec.get_active_validator_indices(state, current_epoch)[0]
     transfer_pubkey = pubkeys[-1]
     transfer_privkey = privkeys[-1]
 

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py

@@ -84,6 +84,29 @@ def test_success_since_max_epochs_per_crosslink(spec, state):
     yield from run_attestation_processing(spec, state, attestation)
 
 
+@with_all_phases
+@spec_state_test
+def test_wrong_end_epoch_with_max_epochs_per_crosslink(spec, state):
+    for _ in range(spec.MAX_EPOCHS_PER_CROSSLINK + 2):
+        next_epoch(spec, state)
+    apply_empty_block(spec, state)
+
+    attestation = get_valid_attestation(spec, state)
+    data = attestation.data
+    # test logic sanity check: make sure the attestation only includes MAX_EPOCHS_PER_CROSSLINK epochs
+    assert data.crosslink.end_epoch - data.crosslink.start_epoch == spec.MAX_EPOCHS_PER_CROSSLINK
+    # Now change it to be different
+    data.crosslink.end_epoch += 1
+
+    sign_attestation(spec, state, attestation)
+
+    for _ in range(spec.MIN_ATTESTATION_INCLUSION_DELAY):
+        next_slot(spec, state)
+    apply_empty_block(spec, state)
+
+    yield from run_attestation_processing(spec, state, attestation, False)
+
+
 @with_all_phases
 @always_bls
 @spec_state_test
@@ -147,6 +170,47 @@ def test_wrong_shard(spec, state):
     yield from run_attestation_processing(spec, state, attestation, False)
 
 
+@with_all_phases
+@spec_state_test
+def test_invalid_shard(spec, state):
+    attestation = get_valid_attestation(spec, state)
+    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+    # off by one (with respect to valid range) on purpose
+    attestation.data.crosslink.shard = spec.SHARD_COUNT
+
+    sign_attestation(spec, state, attestation)
+
+    yield from run_attestation_processing(spec, state, attestation, False)
+
+
+@with_all_phases
+@spec_state_test
+def test_old_target_epoch(spec, state):
+    assert spec.MIN_ATTESTATION_INCLUSION_DELAY < spec.SLOTS_PER_EPOCH * 2
+
+    attestation = get_valid_attestation(spec, state, signed=True)
+
+    state.slot = spec.SLOTS_PER_EPOCH * 2  # target epoch will be too old to handle
+
+    yield from run_attestation_processing(spec, state, attestation, False)
+
+
+@with_all_phases
+@spec_state_test
+def test_future_target_epoch(spec, state):
+    assert spec.MIN_ATTESTATION_INCLUSION_DELAY < spec.SLOTS_PER_EPOCH * 2
+
+    attestation = get_valid_attestation(spec, state)
+
+    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+    attestation.data.target.epoch = spec.get_current_epoch(state) + 1  # target epoch will be too new to handle
+    sign_attestation(spec, state, attestation)
+
+    yield from run_attestation_processing(spec, state, attestation, False)
+
+
 @with_all_phases
 @spec_state_test
 def test_new_source_epoch(spec, state):

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attester_slashing.py

@@ -200,12 +200,106 @@ def test_participants_already_slashed(spec, state):
 
 @with_all_phases
 @spec_state_test
-def test_custody_bit_0_and_1(spec, state):
+def test_custody_bit_0_and_1_intersect(spec, state):
     attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True)
 
-    attester_slashing.attestation_1.custody_bit_1_indices = (
-        attester_slashing.attestation_1.custody_bit_0_indices
+    attester_slashing.attestation_1.custody_bit_1_indices.append(
+        attester_slashing.attestation_1.custody_bit_0_indices[0]
     )
+
     sign_indexed_attestation(spec, state, attester_slashing.attestation_1)
 
     yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+@always_bls
+@with_all_phases
+@spec_state_test
+def test_att1_bad_extra_index(spec, state):
+    attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True)
+
+    indices = attester_slashing.attestation_1.custody_bit_0_indices
+    options = list(set(range(len(state.validators))) - set(indices))
+    indices.append(options[len(options) // 2])  # add random index, not previously in attestation.
+    attester_slashing.attestation_1.custody_bit_0_indices = sorted(indices)
+    # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not),
+    # see if the bad extra index is spotted, and slashing is aborted.
+
+    yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+@always_bls
+@with_all_phases
+@spec_state_test
+def test_att1_bad_replaced_index(spec, state):
+    attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True)
+
+    indices = attester_slashing.attestation_1.custody_bit_0_indices
+    options = list(set(range(len(state.validators))) - set(indices))
+    indices[3] = options[len(options) // 2]  # replace with random index, not previously in attestation.
+    attester_slashing.attestation_1.custody_bit_0_indices = sorted(indices)
+    # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not),
+    # see if the bad replaced index is spotted, and slashing is aborted.
+
+    yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+@always_bls
+@with_all_phases
+@spec_state_test
+def test_att2_bad_extra_index(spec, state):
+    attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True)
+
+    indices = attester_slashing.attestation_2.custody_bit_0_indices
+    options = list(set(range(len(state.validators))) - set(indices))
+    indices.append(options[len(options) // 2])  # add random index, not previously in attestation.
+    attester_slashing.attestation_2.custody_bit_0_indices = sorted(indices)
+    # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not),
+    # see if the bad extra index is spotted, and slashing is aborted.
+
+    yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+@always_bls
+@with_all_phases
+@spec_state_test
+def test_att2_bad_replaced_index(spec, state):
+    attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=True)
+
+    indices = attester_slashing.attestation_2.custody_bit_0_indices
+    options = list(set(range(len(state.validators))) - set(indices))
+    indices[3] = options[len(options) // 2]  # replace with random index, not previously in attestation.
+    attester_slashing.attestation_2.custody_bit_0_indices = sorted(indices)
+    # Do not sign the modified attestation (it's ok to slash if attester signed, not if they did not),
+    # see if the bad replaced index is spotted, and slashing is aborted.
+
+    yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+@with_all_phases
+@spec_state_test
+def test_unsorted_att_1_bit0(spec, state):
+    attester_slashing = get_valid_attester_slashing(spec, state, signed_1=False, signed_2=True)
+
+    indices = attester_slashing.attestation_1.custody_bit_0_indices
+    assert len(indices) >= 3
+    indices[1], indices[2] = indices[2], indices[1]  # unsort second and third index
+    sign_indexed_attestation(spec, state, attester_slashing.attestation_1)
+
+    yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+@with_all_phases
+@spec_state_test
+def test_unsorted_att_2_bit0(spec, state):
+    attester_slashing = get_valid_attester_slashing(spec, state, signed_1=True, signed_2=False)
+
+    indices = attester_slashing.attestation_2.custody_bit_0_indices
+    assert len(indices) >= 3
+    indices[1], indices[2] = indices[2], indices[1]  # unsort second and third index
+    sign_indexed_attestation(spec, state, attester_slashing.attestation_2)
+
+    yield from run_attester_slashing_processing(spec, state, attester_slashing, False)
+
+
+# note: unsorted indices for custody bit 0 are to be introduced in phase 1 testing.

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_deposit.py

@@ -49,20 +49,50 @@ def run_deposit_processing(spec, state, deposit, validator_index, valid=True, ef
             assert len(state.balances) == pre_validator_count + 1
         assert get_balance(state, validator_index) == pre_balance + deposit.data.amount
 
+        effective = min(spec.MAX_EFFECTIVE_BALANCE,
+                        pre_balance + deposit.data.amount)
+        effective -= effective % spec.EFFECTIVE_BALANCE_INCREMENT
+        assert state.validators[validator_index].effective_balance == effective
+
     assert state.eth1_deposit_index == state.eth1_data.deposit_count
 
 
 @with_all_phases
 @spec_state_test
-def test_new_deposit(spec, state):
+def test_new_deposit_under_max(spec, state):
+    # fresh deposit = next validator index = validator appended to registry
+    validator_index = len(state.validators)
+    # effective balance will be 1 EFFECTIVE_BALANCE_INCREMENT smaller because of this small decrement.
+    amount = spec.MAX_EFFECTIVE_BALANCE - 1
+    deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True)
+
+    yield from run_deposit_processing(spec, state, deposit, validator_index)
+
+
+@with_all_phases
+@spec_state_test
+def test_new_deposit_max(spec, state):
     # fresh deposit = next validator index = validator appended to registry
     validator_index = len(state.validators)
+    # effective balance will be exactly the same as balance.
     amount = spec.MAX_EFFECTIVE_BALANCE
     deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True)
 
     yield from run_deposit_processing(spec, state, deposit, validator_index)
 
 
+@with_all_phases
+@spec_state_test
+def test_new_deposit_over_max(spec, state):
+    # fresh deposit = next validator index = validator appended to registry
+    validator_index = len(state.validators)
+    # just 1 over the limit, effective balance should be set MAX_EFFECTIVE_BALANCE during processing
+    amount = spec.MAX_EFFECTIVE_BALANCE + 1
+    deposit = prepare_state_and_deposit(spec, state, validator_index, amount, signed=True)
+
+    yield from run_deposit_processing(spec, state, deposit, validator_index)
+
+
 @with_all_phases
 @always_bls
 @spec_state_test