def test_voluntary_exit(state): test_state = deepcopy(state) current_epoch = get_current_epoch(test_state) validator_index = get_active_validator_indices(test_state.validator_registry, current_epoch)[-1] voluntary_exit = VoluntaryExit( epoch=current_epoch, validator_index=validator_index, signature=b'\x00'*96, ) # # Add to state via block transition # block = construct_empty_block_for_next_slot(test_state) block.body.voluntary_exits.append(voluntary_exit) state_transition(test_state, block) assert not state.validator_registry[validator_index].initiated_exit assert test_state.validator_registry[validator_index].initiated_exit assert test_state.validator_registry[validator_index].exit_epoch == FAR_FUTURE_EPOCH # # Process within epoch transition # # artificially trigger registry update test_state.validator_registry_update_epoch -= 1 block = construct_empty_block_for_next_slot(test_state) block.slot += SLOTS_PER_EPOCH state_transition(test_state, block) assert test_state.validator_registry[validator_index].exit_epoch < FAR_FUTURE_EPOCH
def test_ejection(state): pre_state = deepcopy(state) current_epoch = get_current_epoch(pre_state) validator_index = get_active_validator_indices( pre_state.validator_registry, current_epoch)[-1] assert pre_state.validator_registry[ validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH # set validator balance to below ejection threshold pre_state.validator_balances[validator_index] = spec.EJECTION_BALANCE - 1 post_state = deepcopy(pre_state) # # trigger epoch transition # block = construct_empty_block_for_next_slot(post_state) block.slot += spec.SLOTS_PER_EPOCH state_transition(post_state, block) assert post_state.validator_registry[ validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH return pre_state, [block], post_state
def test_proposer_slashing(state): test_state = deepcopy(state) current_epoch = get_current_epoch(test_state) validator_index = get_active_validator_indices( test_state.validator_registry, current_epoch)[-1] pubkey = pubkeys[validator_index] privkey = pubkey_to_privkey[pubkey] slot = spec.GENESIS_SLOT header_1 = BeaconBlockHeader(slot=slot, previous_block_root=b'\x00' * 32, state_root=b'\x00' * 32, block_body_root=b'\x00' * 32, signature=b'\x00' * 96) header_2 = deepcopy(header_1) header_2.previous_block_root = b'\x02' * 32 header_2.slot = slot + 1 domain = get_domain( fork=test_state.fork, epoch=get_current_epoch(test_state), domain_type=spec.DOMAIN_BEACON_BLOCK, ) header_1.signature = bls.sign( message_hash=signed_root(header_1), privkey=privkey, domain=domain, ) header_2.signature = bls.sign( message_hash=signed_root(header_2), privkey=privkey, domain=domain, ) proposer_slashing = ProposerSlashing( proposer_index=validator_index, header_1=header_1, header_2=header_2, ) # # Add to state via block transition # block = construct_empty_block_for_next_slot(test_state) block.body.proposer_slashings.append(proposer_slashing) state_transition(test_state, block) assert not state.validator_registry[validator_index].initiated_exit assert not state.validator_registry[validator_index].slashed slashed_validator = test_state.validator_registry[validator_index] assert not slashed_validator.initiated_exit assert slashed_validator.slashed assert slashed_validator.exit_epoch < spec.FAR_FUTURE_EPOCH assert slashed_validator.withdrawable_epoch < spec.FAR_FUTURE_EPOCH # lost whistleblower reward assert test_state.validator_balances[ validator_index] < state.validator_balances[validator_index] return state, [block], test_state
def test_empty_epoch_transition_not_finalizing(state): test_state = deepcopy(state) block = construct_empty_block_for_next_slot(test_state) block.slot += SLOTS_PER_EPOCH * 5 state_transition(test_state, block) assert test_state.slot == block.slot assert test_state.finalized_epoch < get_current_epoch(test_state) - 4
def test_empty_block_transition(state): test_state = deepcopy(state) block = construct_empty_block_for_next_slot(test_state) state_transition(test_state, block) assert len(test_state.eth1_data_votes) == len(state.eth1_data_votes) + 1 assert get_block_root(test_state, state.slot) == block.previous_block_root return state, [block], test_state
def test_empty_epoch_transition(state): test_state = deepcopy(state) block = construct_empty_block_for_next_slot(test_state) block.slot += SLOTS_PER_EPOCH state_transition(test_state, block) assert test_state.slot == block.slot for slot in range(state.slot, test_state.slot): assert get_block_root(test_state, slot) == block.previous_block_root
def test_skipped_slots(state): test_state = deepcopy(state) block = construct_empty_block_for_next_slot(test_state) block.slot += 3 state_transition(test_state, block) assert test_state.slot == block.slot for slot in range(state.slot, test_state.slot): assert get_block_root(test_state, slot) == block.previous_block_root
def test_historical_batch(state): test_state = deepcopy(state) test_state.slot += SLOTS_PER_HISTORICAL_ROOT - (test_state.slot % SLOTS_PER_HISTORICAL_ROOT) - 1 block = construct_empty_block_for_next_slot(test_state) state_transition(test_state, block) assert test_state.slot == block.slot assert get_current_epoch(test_state) % (SLOTS_PER_HISTORICAL_ROOT // SLOTS_PER_EPOCH) == 0 assert len(test_state.historical_roots) == len(state.historical_roots) + 1
def test_transfer(state): pre_state = deepcopy(state) current_epoch = get_current_epoch(pre_state) sender_index = get_active_validator_indices(pre_state.validator_registry, current_epoch)[-1] recipient_index = get_active_validator_indices( pre_state.validator_registry, current_epoch)[0] transfer_pubkey = pubkeys[-1] transfer_privkey = pubkey_to_privkey[transfer_pubkey] amount = pre_state.validator_balances[sender_index] pre_transfer_recipient_balance = pre_state.validator_balances[ recipient_index] transfer = Transfer( sender=sender_index, recipient=recipient_index, amount=amount, fee=0, slot=pre_state.slot + 1, pubkey=transfer_pubkey, signature=b'\x00' * 96, ) transfer.signature = bls.sign(message_hash=signed_root(transfer), privkey=transfer_privkey, domain=get_domain( fork=pre_state.fork, epoch=get_current_epoch(pre_state), domain_type=spec.DOMAIN_TRANSFER, )) # ensure withdrawal_credentials reproducable pre_state.validator_registry[sender_index].withdrawal_credentials = ( spec.BLS_WITHDRAWAL_PREFIX_BYTE + hash(transfer_pubkey)[1:]) # un-activate so validator can transfer pre_state.validator_registry[ sender_index].activation_epoch = spec.FAR_FUTURE_EPOCH post_state = deepcopy(pre_state) # # Add to state via block transition # block = construct_empty_block_for_next_slot(post_state) block.body.transfers.append(transfer) state_transition(post_state, block) sender_balance = post_state.validator_balances[sender_index] recipient_balance = post_state.validator_balances[recipient_index] assert sender_balance == 0 assert recipient_balance == pre_transfer_recipient_balance + amount return pre_state, [block], post_state
def test_voluntary_exit(state): pre_state = deepcopy(state) validator_index = get_active_validator_indices( pre_state.validator_registry, get_current_epoch(pre_state))[-1] pubkey = pubkeys[validator_index] # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit pre_state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH # artificially trigger registry update at next epoch transition pre_state.validator_registry_update_epoch -= 1 post_state = deepcopy(pre_state) voluntary_exit = VoluntaryExit( epoch=get_current_epoch(pre_state), validator_index=validator_index, signature=b'\x00' * 96, ) voluntary_exit.signature = bls.sign( message_hash=signed_root(voluntary_exit), privkey=pubkey_to_privkey[pubkey], domain=get_domain( fork=pre_state.fork, epoch=get_current_epoch(pre_state), domain_type=spec.DOMAIN_VOLUNTARY_EXIT, )) # # Add to state via block transition # initiate_exit_block = construct_empty_block_for_next_slot(post_state) initiate_exit_block.body.voluntary_exits.append(voluntary_exit) state_transition(post_state, initiate_exit_block) assert not pre_state.validator_registry[validator_index].initiated_exit assert post_state.validator_registry[validator_index].initiated_exit assert post_state.validator_registry[ validator_index].exit_epoch == spec.FAR_FUTURE_EPOCH # # Process within epoch transition # exit_block = construct_empty_block_for_next_slot(post_state) exit_block.slot += spec.SLOTS_PER_EPOCH state_transition(post_state, exit_block) assert post_state.validator_registry[ validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH return pre_state, [initiate_exit_block, exit_block], post_state
def apply_test(config, initial_state, blocks, expected_state, expected_state_root): print("Applying config") print(json.dumps(config, indent=4)) for key, value in config.items(): setattr(spec, key, value) state = deepcopy(initial_state) for block in blocks: spec.state_transition(state, block) assert state == expected_state if expected_state_root: assert spec.hash_tree_root(state) == expected_state_root print("Test passed\n")
def test_attestation(state): test_state = deepcopy(state) current_epoch = get_current_epoch(test_state) slot = state.slot shard = state.current_shuffling_start_shard attestation_data = build_attestation_data(state, slot, shard) crosslink_committees = get_crosslink_committees_at_slot(state, slot) crosslink_committee = [ committee for committee, _shard in crosslink_committees if _shard == attestation_data.shard ][0] committee_size = len(crosslink_committee) bitfield_length = (committee_size + 7) // 8 aggregation_bitfield = b'\x01' + b'\x00' * (bitfield_length - 1) custody_bitfield = b'\x00' * bitfield_length attestation = Attestation( aggregation_bitfield=aggregation_bitfield, data=attestation_data, custody_bitfield=custody_bitfield, aggregate_signature=b'\x42' * 96, ) # # Add to state via block transition # block = construct_empty_block_for_next_slot(test_state) block.slot += MIN_ATTESTATION_INCLUSION_DELAY block.body.attestations.append(attestation) state_transition(test_state, block) assert len(test_state.current_epoch_attestations) == len( state.current_epoch_attestations) + 1 # # Epoch transition should move to previous_epoch_attestations # pre_current_epoch_attestations = deepcopy( test_state.current_epoch_attestations) block = construct_empty_block_for_next_slot(test_state) block.slot += SLOTS_PER_EPOCH state_transition(test_state, block) assert len(test_state.current_epoch_attestations) == 0 assert test_state.previous_epoch_attestations == pre_current_epoch_attestations
def test_historical_batch(state): pre_state = deepcopy(state) pre_state.slot += spec.SLOTS_PER_HISTORICAL_ROOT - ( pre_state.slot % spec.SLOTS_PER_HISTORICAL_ROOT) - 1 post_state = deepcopy(pre_state) block = construct_empty_block_for_next_slot(post_state) state_transition(post_state, block) assert post_state.slot == block.slot assert get_current_epoch(post_state) % (spec.SLOTS_PER_HISTORICAL_ROOT // spec.SLOTS_PER_EPOCH) == 0 assert len( post_state.historical_roots) == len(pre_state.historical_roots) + 1 return pre_state, [block], post_state
def test_ejection(state): test_state = deepcopy(state) current_epoch = get_current_epoch(test_state) validator_index = get_active_validator_indices(test_state.validator_registry, current_epoch)[-1] assert test_state.validator_registry[validator_index].exit_epoch == FAR_FUTURE_EPOCH # set validator balance to below ejection threshold test_state.validator_balances[validator_index] = EJECTION_BALANCE - 1 # # trigger epoch transition # block = construct_empty_block_for_next_slot(test_state) block.slot += SLOTS_PER_EPOCH state_transition(test_state, block) assert test_state.validator_registry[validator_index].exit_epoch < FAR_FUTURE_EPOCH
def test_deposit_in_block(state): test_state = deepcopy(state) test_deposit_data_leaves = deepcopy(all_deposit_data_leaves) withdrawal_credentials = b'\x42' * 32 deposit_timestamp = 1 proof_of_possession = b'\x44' * 96 index = len(test_deposit_data_leaves) deposit_data = DepositData( amount=MAX_DEPOSIT_AMOUNT, timestamp=deposit_timestamp, deposit_input=DepositInput( pubkey=pubkeys[index], withdrawal_credentials=withdrawal_credentials, proof_of_possession=proof_of_possession, ), ) item = hash(deposit_data.serialize()) test_deposit_data_leaves.append(item) tree = calc_merkle_tree_from_leaves(tuple(test_deposit_data_leaves)) root = get_merkle_root((tuple(test_deposit_data_leaves))) proof = list(get_merkle_proof(tree, item_index=index)) assert verify_merkle_branch(item, proof, DEPOSIT_CONTRACT_TREE_DEPTH, index, root) deposit = Deposit( proof=list(proof), index=index, deposit_data=deposit_data, ) test_state.latest_eth1_data.deposit_root = root block = construct_empty_block_for_next_slot(test_state) block.body.deposits.append(deposit) state_transition(test_state, block) assert len( test_state.validator_registry) == len(state.validator_registry) + 1 assert len( test_state.validator_balances) == len(state.validator_balances) + 1 assert test_state.validator_registry[index].pubkey == pubkeys[index]
def test_transfer(state): test_state = deepcopy(state) current_epoch = get_current_epoch(test_state) sender_index = get_active_validator_indices(test_state.validator_registry, current_epoch)[-1] recipient_index = get_active_validator_indices( test_state.validator_registry, current_epoch)[0] pubkey = b'\x00' * 48 amount = test_state.validator_balances[sender_index] pre_transfer_recipient_balance = test_state.validator_balances[ recipient_index] transfer = Transfer( sender=sender_index, recipient=recipient_index, amount=amount, fee=0, slot=test_state.slot + 1, pubkey=pubkey, signature=b'\x42' * 96, ) # ensure withdrawal_credentials reproducable test_state.validator_registry[sender_index].withdrawal_credentials = ( BLS_WITHDRAWAL_PREFIX_BYTE + hash(pubkey)[1:]) # un-activate so validator can transfer test_state.validator_registry[ sender_index].activation_epoch = FAR_FUTURE_EPOCH # # Add to state via block transition # block = construct_empty_block_for_next_slot(test_state) block.body.transfers.append(transfer) state_transition(test_state, block) sender_balance = test_state.validator_balances[sender_index] recipient_balance = test_state.validator_balances[recipient_index] assert sender_balance == 0 assert recipient_balance == pre_transfer_recipient_balance + amount
def test_deposit_top_up(state): pre_state = deepcopy(state) test_deposit_data_leaves = deepcopy(all_deposit_data_leaves) validator_index = 0 amount = spec.MAX_DEPOSIT_AMOUNT // 4 pubkey = pubkeys[validator_index] deposit_data = create_deposit_data(pre_state, pubkey, amount) merkle_index = len(test_deposit_data_leaves) item = hash(deposit_data.serialize()) test_deposit_data_leaves.append(item) tree = calc_merkle_tree_from_leaves(tuple(test_deposit_data_leaves)) root = get_merkle_root((tuple(test_deposit_data_leaves))) proof = list(get_merkle_proof(tree, item_index=merkle_index)) assert verify_merkle_branch(item, proof, spec.DEPOSIT_CONTRACT_TREE_DEPTH, merkle_index, root) deposit = Deposit( proof=list(proof), index=merkle_index, deposit_data=deposit_data, ) pre_state.latest_eth1_data.deposit_root = root block = construct_empty_block_for_next_slot(pre_state) block.body.deposits.append(deposit) pre_balance = pre_state.validator_balances[validator_index] post_state = deepcopy(pre_state) state_transition(post_state, block) assert len(post_state.validator_registry) == len( pre_state.validator_registry) assert len(post_state.validator_balances) == len( pre_state.validator_balances) assert post_state.validator_balances[ validator_index] == pre_balance + amount return pre_state, [block], post_state
def test_proposer_slashing(state): test_state = deepcopy(state) current_epoch = get_current_epoch(test_state) validator_index = get_active_validator_indices(test_state.validator_registry, current_epoch)[-1] slot = GENESIS_SLOT header_1 = BeaconBlockHeader( slot=slot, previous_block_root=b'\x00'*32, state_root=b'\x00'*32, block_body_root=b'\x00'*32, signature=b'\x00'*96 ) header_2 = deepcopy(header_1) header_2.previous_block_root = b'\x02'*32 proposer_slashing = ProposerSlashing( proposer_index=validator_index, header_1=header_1, header_2=header_2, ) # # Add to state via block transition # block = construct_empty_block_for_next_slot(test_state) block.body.proposer_slashings.append(proposer_slashing) state_transition(test_state, block) assert not state.validator_registry[validator_index].initiated_exit assert not state.validator_registry[validator_index].slashed slashed_validator = test_state.validator_registry[validator_index] assert not slashed_validator.initiated_exit assert slashed_validator.slashed assert slashed_validator.exit_epoch < FAR_FUTURE_EPOCH assert slashed_validator.withdrawable_epoch < FAR_FUTURE_EPOCH # lost whistleblower reward assert test_state.validator_balances[validator_index] < state.validator_balances[validator_index]
def test_attestation(state): test_state = deepcopy(state) slot = state.slot shard = state.current_shuffling_start_shard attestation_data = build_attestation_data(state, slot, shard) crosslink_committees = get_crosslink_committees_at_slot(state, slot) crosslink_committee = [ committee for committee, _shard in crosslink_committees if _shard == attestation_data.shard ][0] committee_size = len(crosslink_committee) bitfield_length = (committee_size + 7) // 8 aggregation_bitfield = b'\x01' + b'\x00' * (bitfield_length - 1) custody_bitfield = b'\x00' * bitfield_length attestation = Attestation( aggregation_bitfield=aggregation_bitfield, data=attestation_data, custody_bitfield=custody_bitfield, aggregate_signature=b'\x00' * 96, ) participants = get_attestation_participants( test_state, attestation.data, attestation.aggregation_bitfield, ) assert len(participants) == 1 validator_index = participants[0] pubkey = pubkeys[validator_index] privkey = pubkey_to_privkey[pubkey] message_hash = AttestationDataAndCustodyBit( data=attestation.data, custody_bit=0b0, ).hash_tree_root() attestation.aggregation_signature = bls.sign( message_hash=message_hash, privkey=privkey, domain=get_domain( fork=test_state.fork, epoch=get_current_epoch(test_state), domain_type=spec.DOMAIN_ATTESTATION, )) # # Add to state via block transition # attestation_block = construct_empty_block_for_next_slot(test_state) attestation_block.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY attestation_block.body.attestations.append(attestation) state_transition(test_state, attestation_block) assert len(test_state.current_epoch_attestations) == len( state.current_epoch_attestations) + 1 # # Epoch transition should move to previous_epoch_attestations # pre_current_epoch_attestations = deepcopy( test_state.current_epoch_attestations) epoch_block = construct_empty_block_for_next_slot(test_state) epoch_block.slot += spec.SLOTS_PER_EPOCH state_transition(test_state, epoch_block) assert len(test_state.current_epoch_attestations) == 0 assert test_state.previous_epoch_attestations == pre_current_epoch_attestations return state, [attestation_block, epoch_block], test_state