def test_update_validator(
genesis_state,
validator_index_offset,
validator_count,
new_pubkey,
new_balance,
config,
):
state = genesis_state
validator = create_mock_validator(new_pubkey, config)
validator_index = validator_count + validator_index_offset
if validator_index < state.validator_count:
result_state = state.update_validator(validator_index=validator_index,
validator=validator,
balance=new_balance)
assert result_state.balances[validator_index] == new_balance
assert result_state.validators[validator_index].pubkey == new_pubkey
assert state.validators[validator_index].pubkey != new_pubkey
else:
with pytest.raises(IndexError):
state.update_validator(
validator_index=validator_index,
validator=validator,
balance=new_balance,
)
def genesis_validators(validator_count, pubkeys, config):
"""
Returns ``validator_count`` number of activated validators.
"""
return tuple(
create_mock_validator(pubkey=pubkey, config=config)
for pubkey in pubkeys[:validator_count])
def test_randao_processing_validates_randao_reveal(
sample_beacon_block_params,
sample_beacon_block_body_params,
sample_beacon_state_params,
sample_fork_params,
keymap,
config,
):
proposer_pubkey, proposer_privkey = first(keymap.items())
state = SerenityBeaconState.create(**sample_beacon_state_params).mset(
"validators",
tuple(
create_mock_validator(proposer_pubkey, config)
for _ in range(config.TARGET_COMMITTEE_SIZE)),
"balances",
(config.MAX_EFFECTIVE_BALANCE, ) * config.TARGET_COMMITTEE_SIZE,
"randao_mixes",
tuple(ZERO_HASH32 for _ in range(config.EPOCHS_PER_HISTORICAL_VECTOR)),
)
epoch = state.current_epoch(config.SLOTS_PER_EPOCH)
message_hash = (epoch + 1).to_bytes(32, byteorder="little")
domain = get_domain(state, SignatureDomain.DOMAIN_RANDAO,
config.SLOTS_PER_EPOCH)
randao_reveal = bls.sign(message_hash, proposer_privkey, domain)
block_body = BeaconBlockBody.create(**sample_beacon_block_body_params).set(
"randao_reveal", randao_reveal)
block = SerenityBeaconBlock.create(**sample_beacon_block_params).set(
"body", block_body)
with pytest.raises(ValidationError):
process_randao(state, block, config)
def genesis_validators(validator_count, pubkeys, config):
"""
Returns ``validator_count`` number of activated validators.
"""
return HashableList.from_iterable(
(create_mock_validator(pubkey=pubkey, config=config)
for pubkey in pubkeys[:validator_count]),
List(Validator, config.VALIDATOR_REGISTRY_LIMIT),
)
def test_validate_proposer_signature(
slots_per_epoch,
shard_count,
proposer_privkey,
proposer_pubkey,
is_valid_signature,
sample_beacon_block_params,
sample_beacon_state_params,
target_committee_size,
max_effective_balance,
config):
state = BeaconState(**sample_beacon_state_params).copy(
validators=tuple(
create_mock_validator(proposer_pubkey, config)
for _ in range(10)
),
balances=(max_effective_balance,) * 10,
)
block = BeaconBlock(**sample_beacon_block_params)
header = block.header
proposed_block = block.copy(
signature=bls.sign(
message_hash=header.signing_root,
privkey=proposer_privkey,
domain=get_domain(
state,
SignatureDomain.DOMAIN_BEACON_PROPOSER,
slots_per_epoch,
),
),
)
if is_valid_signature:
validate_proposer_signature(
state,
proposed_block,
CommitteeConfig(config),
)
else:
with pytest.raises(ValidationError):
validate_proposer_signature(
state,
proposed_block,
CommitteeConfig(config),
)
def test_randao_processing(sample_beacon_block_params,
sample_beacon_block_body_params,
sample_beacon_state_params,
keymap,
config):
proposer_pubkey, proposer_privkey = first(keymap.items())
state = SerenityBeaconState(**sample_beacon_state_params).copy(
validators=tuple(
create_mock_validator(proposer_pubkey, config)
for _ in range(config.TARGET_COMMITTEE_SIZE)
),
balances=(config.MAX_EFFECTIVE_BALANCE,) * config.TARGET_COMMITTEE_SIZE,
randao_mixes=tuple(
ZERO_HASH32
for _ in range(config.EPOCHS_PER_HISTORICAL_VECTOR)
),
)
epoch = state.current_epoch(config.SLOTS_PER_EPOCH)
slot = get_epoch_start_slot(epoch, config.SLOTS_PER_EPOCH)
randao_reveal = _generate_randao_reveal(
privkey=proposer_privkey,
slot=slot,
state=state,
config=config,
)
block_body = BeaconBlockBody(**sample_beacon_block_body_params).copy(
randao_reveal=randao_reveal,
)
block = SerenityBeaconBlock(**sample_beacon_block_params).copy(
body=block_body,
)
new_state = process_randao(state, block, config)
updated_index = epoch % config.EPOCHS_PER_HISTORICAL_VECTOR
original_mixes = state.randao_mixes
updated_mixes = new_state.randao_mixes
assert all(
updated == original if index != updated_index else updated != original
for index, (updated, original) in enumerate(zip(updated_mixes, original_mixes))
)
def test_activate_validator(genesis_state, is_already_activated,
validator_count, pubkeys, config):
some_future_epoch = config.GENESIS_EPOCH + random.randrange(1, 2**32)
if is_already_activated:
assert validator_count > 0
some_validator = genesis_state.validators[0]
assert some_validator.activation_eligibility_epoch == config.GENESIS_EPOCH
assert some_validator.activation_epoch == config.GENESIS_EPOCH
else:
some_validator = create_mock_validator(pubkeys[:validator_count + 1],
config,
is_active=is_already_activated)
assert some_validator.activation_eligibility_epoch == FAR_FUTURE_EPOCH
assert some_validator.activation_epoch == FAR_FUTURE_EPOCH
assert not some_validator.slashed
activated_validator = activate_validator(some_validator, some_future_epoch)
assert activated_validator.activation_eligibility_epoch == some_future_epoch
assert activated_validator.activation_epoch == some_future_epoch
assert not activated_validator.slashed
def test_validate_proposer_signature(
slots_per_epoch,
max_committees_per_slot,
proposer_privkey,
proposer_pubkey,
is_valid_signature,
sample_beacon_block_params,
sample_beacon_state_params,
target_committee_size,
max_effective_balance,
config,
):
state = BeaconState.create(**sample_beacon_state_params).mset(
"validators",
tuple(
create_mock_validator(proposer_pubkey, config) for _ in range(10)),
"balances",
(max_effective_balance, ) * 10,
)
block = BeaconBlock.create(**sample_beacon_block_params)
proposed_block = SignedBeaconBlock.create(
message=block,
signature=bls.sign(
message_hash=block.hash_tree_root,
privkey=proposer_privkey,
domain=get_domain(state, SignatureDomain.DOMAIN_BEACON_PROPOSER,
slots_per_epoch),
),
)
if is_valid_signature:
validate_proposer_signature(state, proposed_block,
CommitteeConfig(config))
else:
with pytest.raises(ValidationError):
validate_proposer_signature(state, proposed_block,
CommitteeConfig(config))
def test_validators_and_balances_length(sample_beacon_state_params, config):
# When len(BeaconState.validators) != len(BeaconState.validtor_balances)
with pytest.raises(ValueError):
BeaconState(**sample_beacon_state_params).copy(validators=tuple(
create_mock_validator(pubkey, config) for pubkey in range(10)), )
