1  import eth2spec.phase0.spec as spec
  2  from eth2spec.phase0.spec import (
  3      get_beacon_proposer_index,
  4      process_attester_slashing,
  5  )
  6  from eth2spec.test.context import spec_state_test, expect_assertion_error, always_bls
  7  from eth2spec.test.helpers.attestations import sign_indexed_attestation
  8  from eth2spec.test.helpers.attester_slashings import get_valid_attester_slashing
  9  from eth2spec.test.helpers.block import apply_empty_block
 10  from eth2spec.test.helpers.state import (
 11      get_balance,
 12      next_epoch,
 13  )
 14  
 15  
 16  def run_attester_slashing_processing(state, attester_slashing, valid=True):
 17      """
 18      Run ``process_attester_slashing``, yielding:
 19        - pre-state ('pre')
 20        - attester_slashing ('attester_slashing')
 21        - post-state ('post').
 22      If ``valid == False``, run expecting ``AssertionError``
 23      """
 24  
 25      yield 'pre', state
 26      yield 'attester_slashing', attester_slashing
 27  
 28      if not valid:
 29          expect_assertion_error(lambda: process_attester_slashing(state, attester_slashing))
 30          yield 'post', None
 31          return
 32  
 33      slashed_index = attester_slashing.attestation_1.custody_bit_0_indices[0]
 34      pre_slashed_balance = get_balance(state, slashed_index)
 35  
 36      proposer_index = get_beacon_proposer_index(state)
 37      pre_proposer_balance = get_balance(state, proposer_index)
 38  
 39      # Process slashing
 40      process_attester_slashing(state, attester_slashing)
 41  
 42      slashed_validator = state.validator_registry[slashed_index]
 43  
 44      # Check slashing
 45      assert slashed_validator.slashed
 46      assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH
 47      assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH
 48  
 49      if slashed_index != proposer_index:
 50          # lost whistleblower reward
 51          assert get_balance(state, slashed_index) < pre_slashed_balance
 52          # gained whistleblower reward
 53          assert get_balance(state, proposer_index) > pre_proposer_balance
 54      else:
 55          # gained rewards for all slashings, which may include others. And only lost that of themselves.
 56          # Netto at least 0, if more people where slashed, a balance increase.
 57          assert get_balance(state, slashed_index) >= pre_slashed_balance
 58  
 59      yield 'post', state
 60  
 61  
 62  @spec_state_test
 63  def test_success_double(state):
 64      attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=True)
 65  
 66      yield from run_attester_slashing_processing(state, attester_slashing)
 67  
 68  
 69  @spec_state_test
 70  def test_success_surround(state):
 71      next_epoch(state)
 72      apply_empty_block(state)
 73  
 74      state.current_justified_epoch += 1
 75      attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True)
 76  
 77      # set attestion1 to surround attestation 2
 78      attester_slashing.attestation_1.data.source_epoch = attester_slashing.attestation_2.data.source_epoch - 1
 79      attester_slashing.attestation_1.data.target_epoch = attester_slashing.attestation_2.data.target_epoch + 1
 80  
 81      sign_indexed_attestation(state, attester_slashing.attestation_1)
 82  
 83      yield from run_attester_slashing_processing(state, attester_slashing)
 84  
 85  
 86  @always_bls
 87  @spec_state_test
 88  def test_invalid_sig_1(state):
 89      attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True)
 90      yield from run_attester_slashing_processing(state, attester_slashing, False)
 91  
 92  
 93  @always_bls
 94  @spec_state_test
 95  def test_invalid_sig_2(state):
 96      attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=False)
 97      yield from run_attester_slashing_processing(state, attester_slashing, False)
 98  
 99  
100  @always_bls
101  @spec_state_test
102  def test_invalid_sig_1_and_2(state):
103      attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=False)
104      yield from run_attester_slashing_processing(state, attester_slashing, False)
105  
106  
107  @spec_state_test
108  def test_same_data(state):
109      attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True)
110  
111      attester_slashing.attestation_1.data = attester_slashing.attestation_2.data
112      sign_indexed_attestation(state, attester_slashing.attestation_1)
113  
114      yield from run_attester_slashing_processing(state, attester_slashing, False)
115  
116  
117  @spec_state_test
118  def test_no_double_or_surround(state):
119      attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True)
120  
121      attester_slashing.attestation_1.data.target_epoch += 1
122      sign_indexed_attestation(state, attester_slashing.attestation_1)
123  
124      yield from run_attester_slashing_processing(state, attester_slashing, False)
125  
126  
127  @spec_state_test
128  def test_participants_already_slashed(state):
129      attester_slashing = get_valid_attester_slashing(state, signed_1=True, signed_2=True)
130  
131      # set all indices to slashed
132      attestation_1 = attester_slashing.attestation_1
133      validator_indices = attestation_1.custody_bit_0_indices + attestation_1.custody_bit_1_indices
134      for index in validator_indices:
135          state.validator_registry[index].slashed = True
136  
137      yield from run_attester_slashing_processing(state, attester_slashing, False)
138  
139  
140  @spec_state_test
141  def test_custody_bit_0_and_1(state):
142      attester_slashing = get_valid_attester_slashing(state, signed_1=False, signed_2=True)
143  
144      attester_slashing.attestation_1.custody_bit_1_indices = (
145          attester_slashing.attestation_1.custody_bit_0_indices
146      )
147      sign_indexed_attestation(state, attester_slashing.attestation_1)
148  
149      yield from run_attester_slashing_processing(state, attester_slashing, False)