def mock_make_child(parent_state, parent, slot_number, attestations=None):
if attestations is None:
attestations = []
crystallized_state, active_state = parent_state
block = Block(parent_hash=parent.hash,
slot_number=slot_number,
randao_reveal=blake(
str(random.random()).encode('utf-8')),
attestations=attestations,
pow_chain_ref=b'\x00' * 32,
active_state_root=b'\x00' * 32,
crystallized_state_root=b'\x00' * 32)
print('Generated preliminary block header')
new_crystallized_state, new_active_state = compute_state_transition(
(crystallized_state, active_state), parent, block, config=config)
print('Calculated state transition')
if crystallized_state == new_crystallized_state:
block.crystallized_state_root = parent.crystallized_state_root
else:
block.crystallized_state_root = blake(
serialize(crystallized_state))
block.active_state_root = blake(serialize(active_state))
return block, new_crystallized_state, new_active_state
def genesis_block(genesis_active_state, genesis_crystallized_state):
active_state_root = blake(serialize(genesis_active_state))
crystallized_state_root = blake(serialize(genesis_crystallized_state))
return get_genesis_block(
active_state_root=active_state_root,
crystallized_state_root=crystallized_state_root,
)
def test_get_genesis_block(genesis_active_state, genesis_crystallized_state):
active_state_root = blake(serialize(genesis_active_state))
crystallized_state_root = blake(serialize(genesis_crystallized_state))
block = get_genesis_block(
active_state_root=active_state_root,
crystallized_state_root=crystallized_state_root,
)
assert block.parent_hash == ZERO_HASH32
assert block.slot_number == 0
assert block.randao_reveal == ZERO_HASH32
assert block.num_attestations == 0
assert block.pow_chain_ref == ZERO_HASH32
assert block.active_state_root == active_state_root
assert block.crystallized_state_root == crystallized_state_root
def test_state_transition_integration(genesis_crystallized_state,
genesis_active_state, genesis_block,
mock_make_child, mock_make_attestations,
config):
c = genesis_crystallized_state
a = genesis_active_state
block = genesis_block
a.chain = Chain(head=block, blocks=[block])
print('Generated genesis state')
print('Crystallized state length:',
len(serialize(genesis_crystallized_state)))
print('Active state length:', len(serialize(genesis_active_state)))
print('Block size:', len(serialize(genesis_block)))
attestations_of_genesis = mock_make_attestations((c, a),
block,
attester_share=0.8)
block2, c2, a2 = mock_make_child((c, a), block, 1, attestations_of_genesis)
assert block2.slot_number == 1
assert len(block2.attestations) == len(attestations_of_genesis)
assert block2.crystallized_state_root == block.crystallized_state_root
assert block2.active_state_root != b'\x00' * 32
t = time.time()
assert compute_state_transition((c, a), block, block2, config=config)
print(
"Normal block with %s attestations of size %s processed in %.4f sec" %
(len(attestations_of_genesis),
len(c.shard_and_committee_for_slots[attestations_of_genesis[0].slot]
[0].committee), (time.time() - t)))
print('Verified a block!')
attestations_of_2 = mock_make_attestations((c2, a2),
block2,
attester_share=0.8)
cycle_transition_slot = c2.last_state_recalc + config['cycle_length']
block3, c3, a3 = mock_make_child((c2, a2), block2, cycle_transition_slot,
attestations_of_2)
t = time.time()
assert compute_state_transition((c2, a2), block2, block3, config=config)
print("Cycle transition processed in %.4f sec" % (time.time() - t))
def get_hashes_to_sign(
active_state: 'ActiveState',
block: 'Block',
config: Dict[str, Any] = DEFAULT_CONFIG) -> List[Hash32]:
cycle_length = config['cycle_length']
hashes = get_hashes_from_active_state(
active_state,
block,
from_slot=block.slot_number - cycle_length + 1,
to_slot=block.slot_number - 1,
config=config,
) + [blake(serialize(block))]
return hashes
def test_initialize_new_cycle(
genesis_crystallized_state, genesis_active_state, genesis_block,
last_state_recalc, last_justified_slot, justified_streak,
last_finalized_slot, fraction_voted, result_last_state_recalc,
result_justified_streak, result_last_finalized_slot, config):
# Fill the parent_crystallized_state with parematers
parent_crystallized_state = genesis_crystallized_state
parent_crystallized_state.last_state_recalc = last_state_recalc
parent_crystallized_state.last_justified_slot = last_justified_slot
parent_crystallized_state.justified_streak = justified_streak
parent_crystallized_state.last_finalized_slot = last_finalized_slot
parent_active_state = genesis_active_state
parent_block = genesis_block
block = copy.deepcopy(genesis_block)
block.slot_number = 258
block.parent_hash = blake(serialize(parent_block))
active_state = fill_recent_block_hashes(parent_active_state, parent_block,
block)
fraction_voted *= 1.01 # add margin for rounding error
# Fill the total_voter_deposits to simulate the different committee results
active_state.block_vote_cache[block.parent_hash] = {
'voter_indices':
set(),
'total_voter_deposits':
int(parent_crystallized_state.total_deposits * fraction_voted)
}
crystallized_state, active_state = initialize_new_cycle(
parent_crystallized_state,
active_state,
block,
config=config,
)
assert crystallized_state.last_state_recalc == result_last_state_recalc
assert crystallized_state.justified_streak == result_justified_streak
assert crystallized_state.last_finalized_slot == result_last_finalized_slot
def test_failed_serialization(value, typ):
with pytest.raises(Exception):
serialize(value, typ)
def test_basic_serialization(value, typ, data):
assert serialize(value, typ) == data
def hash(self):
return blake(serialize(self))
