def explain_default_size(): """ Show the size of the serialized object with defaults Note: ValidatorRecord omitted (has no defaults) """ attestation_record = AttestationRecord() block = Block() crosslink_record = CrosslinkRecord() shard_and_committee = ShardAndCommittee() crystallized_state = CrystallizedState() attestation_record_bytes = serialize(attestation_record, type(attestation_record)) block_bytes = serialize(block, type(block)) crosslink_record_bytes = serialize(crosslink_record, type(crosslink_record)) shard_and_committee_bytes = serialize(shard_and_committee, type(shard_and_committee)) crystallized_state_bytes = serialize(crystallized_state, type(crystallized_state)) if (verbose): print('{} | {}'.format(len(attestation_record_bytes), attestation_record_bytes)) print('{} | {}'.format(len(block_bytes), block_bytes)) print('{} | {}'.format(len(shard_and_committee_bytes), shard_and_committee_bytes)) print('{} | {}'.format(len(crosslink_record_bytes), crosslink_record_bytes)) print('{} | {}'.format(len(crystallized_state_bytes), crystallized_state_bytes)) return { 'attestationRecord': len(attestation_record_bytes), 'block': len(block_bytes), 'shardAndCommittee': len(shard_and_committee_bytes), 'crosslinkRecord': len(crosslink_record_bytes), 'validatorRecord': "N/A", 'crystallizedState': len(crystallized_state_bytes), }
def test_state_transition_integration(genesis_crystallized_state, genesis_active_state, genesis_block, num_validators, epoch_length, mock_make_child): c = genesis_crystallized_state a = genesis_active_state block = genesis_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))) block2, c2, a2 = mock_make_child((c, a), block, 0, 0.8, []) t = time.time() assert compute_state_transition((c, a), block, block2) print("Normal block (basic attestation only) processed in %.4f sec" % (time.time() - t)) print('Verified a block!') block3, c3, a3 = mock_make_child((c2, a2), block2, 0, 0.8, [(0, 0.75)]) print('Verified a block with a committee!') while a3.height % epoch_length > 0: block3, c3, a3 = mock_make_child((c3, a3), block3, 0, 0.8, [(a3.height, 0.6 + 0.02 * a3.height)]) print('Height: %d' % a3.height) print('FFG bitmask:', bin(int.from_bytes(a3.ffg_voter_bitfield, 'big'))) block4, c4, a4 = mock_make_child((c3, a3), block3, 1, 0.55, []) t = time.time() assert compute_state_transition((c3, a3), block3, block4) print("Epoch transition processed in %.4f sec" % (time.time() - t))
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 mock_make_child(parent_state, parent, skips, attester_share=0.8, crosslink_shards=[]): crystallized_state, active_state = parent_state block, proposer = make_unfinished_block(parent_state, parent, skips, attester_share, crosslink_shards) print('Generated preliminary block header') new_crystallized_state, new_active_state = compute_state_transition( (crystallized_state, active_state), parent, block, verify_sig=False, config=config) print('Calculated state transition') if crystallized_state == new_crystallized_state: block.state_hash = blake(parent.state_hash[:32] + blake(serialize(new_active_state))) else: block.state_hash = blake( blake(serialize(new_crystallized_state)) + blake(serialize(new_active_state))) # Main signature block.sign( keymap[crystallized_state.active_validators[proposer].pubkey]) print('Signed') return block, new_crystallized_state, new_active_state
def mock_make_child(parent_state, parent, skips, attester_share=0.8, crosslink_shards=[]): crystallized_state, active_state = parent_state parent_attestation = serialize(parent) indices, main_signer = get_attesters_and_signer(crystallized_state, active_state, skips) print('Selected indices: %r' % indices) print('Selected main signer: %d' % main_signer) # Randomly pick indices to include bitfield = [1 if random.random() < attester_share else 0 for i in indices] # Attestations sigs = [bls.sign(parent_attestation, keymap[crystallized_state.active_validators[indices[i]].pubkey]) for i in range(len(indices)) if bitfield[i]] attestation_aggregate_sig = bls.aggregate_sigs(sigs) print('Aggregated sig') attestation_bitmask = bytearray((len(bitfield)-1) // 8 + 1) for i, b in enumerate(bitfield): attestation_bitmask[i//8] ^= (128 >> (i % 8)) * b print('Aggregate bitmask:', bin(int.from_bytes(attestation_bitmask, 'big'))) # Randomly pick indices to include for crosslinks shard_aggregate_votes = [] for shard, crosslinker_share in crosslink_shards: print('Making crosslink in shard %d' % shard) indices = get_shard_attesters(crystallized_state, shard) print('Indices: %r' % indices) bitfield = [1 if random.random() < crosslinker_share else 0 for i in indices] bitmask = bytearray((len(bitfield)+7) // 8) for i, b in enumerate(bitfield): bitmask[i//8] ^= (128 >> (i % 8)) * b print('Bitmask:', bin(int.from_bytes(bitmask, 'big'))) shard_block_hash = blake(bytes([shard])) crosslink_attestation_hash = get_crosslink_aggvote_msg(shard, shard_block_hash, crystallized_state) sigs = [bls.sign(crosslink_attestation_hash, keymap[crystallized_state.active_validators[indices[i]].pubkey]) for i in range(len(indices)) if bitfield[i]] v = AggregateVote(shard_id=shard, shard_block_hash=shard_block_hash, signer_bitmask=bitmask, aggregate_sig=list(bls.aggregate_sigs(sigs))) shard_aggregate_votes.append(v) print('Added %d shard aggregate votes' % len(crosslink_shards)) # State calculations o = Block(parent_hash=blake(parent_attestation), skip_count=skips, randao_reveal=blake(str(random.random()).encode('utf-8')), attestation_bitmask=attestation_bitmask, attestation_aggregate_sig=list(attestation_aggregate_sig), shard_aggregate_votes=shard_aggregate_votes, main_chain_ref=b'\x00'*32, state_hash=b'\x00'*64) print('Generated preliminary block header') new_crystallized_state, new_active_state = \ compute_state_transition((crystallized_state, active_state), parent, o, verify_sig=False) print('Calculated state transition') if crystallized_state == new_crystallized_state: o.state_hash = blake(parent.state_hash[:32] + blake(serialize(new_active_state))) else: o.state_hash = blake(blake(serialize(new_crystallized_state)) + blake(serialize(new_active_state))) # Main signature o.sign(keymap[crystallized_state.active_validators[main_signer].pubkey]) print('Signed') return o, 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_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 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.indices_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 test_active_state_serialization(): s = ActiveState() ds = deserialize(serialize(s, type(s)), type(s)) assert eq(s, ds) s = ActiveState(partial_crosslinks=[ PartialCrosslinkRecord(shard_id=42, shard_block_hash=b'\x55' * 32, voter_bitmask=b'31337dawg') ], height=555, randao=b'\x88' * 32, balance_deltas=[5, 7, 9, 579] + [3] * 333) ds = deserialize(serialize(s, type(s)), type(s)) assert eq(s, ds)
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 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 _compute_new_active_state(crystallized_state, active_state, parent_block, block, verify_sig=True, config=DEFAULT_CONFIG): # Determine who the attesters and the main signer are attestation_indices, proposer = get_attesters_and_proposer( crystallized_state, active_state, block.skip_count, config) # Verify attestations attesters = process_attestations(crystallized_state.active_validators, attestation_indices, block.attestation_bitfield, serialize(parent_block), block.attestation_aggregate_sig) # Verify main signature if verify_sig: assert block.verify( crystallized_state.active_validators[proposer].pubkey) print('Verified main sig') # Update crosslink records new_crosslink_records, new_ffg_bitfield, total_new_voters = update_ffg_and_crosslink_progress( crystallized_state, active_state.partial_crosslinks, active_state.ffg_voter_bitfield, block.shard_aggregate_votes, config) # track the reward for the block proposer proposer = RecentProposerRecord(index=proposer, balance_delta=len(attesters) + total_new_voters) # TODO: verify randao reveal from validator's hash preimage updated_randao = (int.from_bytes(active_state.randao, 'big') ^ int.from_bytes(block.randao_reveal, 'big')).to_bytes( 32, 'big') return ActiveState( height=active_state.height + 1, randao=updated_randao, total_skip_count=active_state.total_skip_count + block.skip_count, partial_crosslinks=new_crosslink_records, ffg_voter_bitfield=new_ffg_bitfield, recent_attesters=active_state.recent_attesters + attesters, recent_proposers=active_state.recent_proposers + [proposer])
def _compute_new_active_state(crystallized_state, active_state, parent_block, block, verify_sig=True): # Determine who the attesters and the main signer are attestation_indices, main_signer = get_attesters_and_signer( crystallized_state, active_state, block.skip_count) # Verify attestations balance_deltas = process_attestations(crystallized_state.active_validators, attestation_indices, block.attestation_bitfield, serialize(parent_block), block.attestation_aggregate_sig) # Reward main signer balance_deltas.append((main_signer << 24) + len(balance_deltas)) # Verify main signature if verify_sig: assert block.verify( crystallized_state.active_validators[main_signer].pubkey) print('Verified main sig') # Update crosslink records new_crosslink_records, new_ffg_bitfield, total_new_voters = update_ffg_and_crosslink_progress( crystallized_state, active_state.partial_crosslinks, active_state.ffg_voter_bitfield, block.shard_aggregate_votes) balance_deltas.append((main_signer << 24) + total_new_voters) # TODO: verify randao reveal from validator's hash preimage updated_randao = (int.from_bytes(active_state.randao, 'big') ^ int.from_bytes(block.randao_reveal, 'big')).to_bytes( 32, 'big') return ActiveState( height=active_state.height + 1, randao=updated_randao, total_skip_count=active_state.total_skip_count + block.skip_count, partial_crosslinks=new_crosslink_records, ffg_voter_bitfield=new_ffg_bitfield, balance_deltas=active_state.balance_deltas + balance_deltas)
def test_initialize_new_cycle( genesis_crystallized_state, genesis_active_state, genesis_block, last_state_recalc, last_justified_slot, justified_streak, last_finalized_slot, crystallized_state_total_deposits, block_vote_cache_total_deposits, 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_crystallized_state.total_deposits = crystallized_state_total_deposits 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) # 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': block_vote_cache_total_deposits, } 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 hash(self): return blake(serialize(self))
def verify(self, pub): zig = self.sig self.sig = [0, 0] o = verify(serialize(self), pub, tuple(zig)) self.sig = zig return o
def sign(self, key): self.sig = [0, 0] self.sig = list(sign(serialize(self), key))
def make_unfinished_block(parent_state, parent, skips, attester_share=0.8, crosslink_shards_and_shares=None): if crosslink_shards_and_shares is None: crosslink_shards_and_shares = [] crystallized_state, active_state = parent_state parent_attestation = serialize(parent) indices, proposer = get_attesters_and_proposer( crystallized_state, active_state, skips, config ) print('Selected indices: %r' % indices) print('Selected block proposer: %d' % proposer) # Randomly pick indices to include is_attesting = [random.random() < attester_share for _ in indices] # Attestations sigs = [ bls.sign( parent_attestation, keymap[crystallized_state.active_validators[indices[i]].pubkey] ) for i, attesting in enumerate(is_attesting) if attesting ] attestation_aggregate_sig = bls.aggregate_sigs(sigs) print('Aggregated sig') attestation_bitfield = get_empty_bitfield(len(indices)) for i, attesting in enumerate(is_attesting): if attesting: attestation_bitfield = set_voted(attestation_bitfield, i) print('Aggregate bitfield:', bin(int.from_bytes(attestation_bitfield, 'big'))) # Randomly pick indices to include for crosslinks shard_aggregate_votes = [] # The shards that are selected to be crosslinking crosslink_shards = get_crosslink_shards(crystallized_state, config=config) for shard, crosslinker_share in crosslink_shards_and_shares: # Check if this shard is in the crosslink shards list assert shard in crosslink_shards print('Making crosslink in shard %d' % shard) indices = get_crosslink_notaries(crystallized_state, shard, crosslink_shards=crosslink_shards, config=config) print('Indices: %r' % indices) is_notarizing = [random.random() < attester_share for _ in indices] notary_bitfield = get_empty_bitfield(len(indices)) for i, notarizing in enumerate(is_notarizing): if notarizing: notary_bitfield = set_voted(notary_bitfield, i) print('Bitfield:', bin(int.from_bytes(notary_bitfield, 'big'))) shard_block_hash = blake(bytes([shard])) crosslink_attestation_hash = get_crosslink_aggvote_msg( shard, shard_block_hash, crystallized_state ) sigs = [ bls.sign( crosslink_attestation_hash, keymap[crystallized_state.active_validators[indices[i]].pubkey] ) for i, notarizing in enumerate(is_notarizing) if notarizing ] v = AggregateVote( shard_id=shard, shard_block_hash=shard_block_hash, notary_bitfield=notary_bitfield, aggregate_sig=list(bls.aggregate_sigs(sigs)) ) shard_aggregate_votes.append(v) print('Added %d shard aggregate votes' % len(crosslink_shards_and_shares)) block = Block( parent_hash=blake(parent_attestation), skip_count=skips, randao_reveal=blake(str(random.random()).encode('utf-8')), attestation_bitfield=attestation_bitfield, attestation_aggregate_sig=list(attestation_aggregate_sig), shard_aggregate_votes=shard_aggregate_votes, main_chain_ref=b'\x00'*32, state_hash=b'\x00'*64 ) return block, proposer
def explain_maxval_size(): """ Show the size of the object when using maximum values """ # Attestation Record # TODO replace oblique hash loop with correct size obl_hashes = [] for i in range(0, 64): obl_hashes.append(helpers.MAX_BYTES) attestation_record = AttestationRecord( slot=helpers.MAX_I64, shard_id=helpers.MAX_I16, oblique_parent_hashes=obl_hashes, shard_block_hash=helpers.MAX_BYTES, attester_bitfield=helpers.MAX_BYTES, aggregate_sig=[helpers.MAX_256, helpers.MAX_256] ) # Blocks # TODO: provide realistic number for attestations attestations = [] for i in range(0, helpers.MAX_ATTESTATIONS): attestations.append(attestation_record) block = Block( parent_hash=helpers.MAX_BYTES, slot_number=helpers.MAX_I64, randao_reveal=helpers.MAX_BYTES, attestations=attestations, pow_chain_ref=helpers.MAX_BYTES, active_state_root=helpers.MAX_BYTES, crystallized_state_root=helpers.MAX_BYTES, ) # Crosslink Record crosslink_record = CrosslinkRecord( hash=helpers.MAX_BYTES, dynasty=helpers.MAX_I64, ) # Validator Record validator_record = ValidatorRecord( pubkey=helpers.MAX_256, withdrawal_shard=helpers.MAX_I16, withdrawal_address=helpers.ADDRESS_BYTES, randao_commitment=helpers.MAX_BYTES, balance=helpers.MAX_I64, start_dynasty=helpers.MAX_I64, end_dynasty=helpers.MAX_I64, ) # Shard and Committee # TODO: replace placeholder committees = [] for i in range(0, helpers.PLACEHOLDER): committees.append(helpers.MAX_I16) shard_and_committee = ShardAndCommittee( shard_id=helpers.MAX_I16, committee=committees, ) # Crystallized State validatorlist = [] for i in range(0, helpers.MAX_VALIDATORS): validatorlist.append(validator_record) # TODO: replace placeholder crosslinklist = [] for i in range(0, helpers.PLACEHOLDER): crosslinklist.append(crosslink_record) # TODO: replace placeholder indices_heights = [] for i in range(0, helpers.PLACEHOLDER): tmp = [] for j in range(0, 10): tmp.append(shard_and_committee) indices_heights.append(tmp) crystallized_state = CrystallizedState( validators=validatorlist, indices_for_heights=indices_heights, last_justified_slot=helpers.MAX_I64, justified_streak=helpers.MAX_I64, last_finalized_slot=helpers.MAX_I64, current_dynasty=helpers.MAX_I64, crosslinking_start_shard=helpers.MAX_I16, crosslink_records=crosslinklist, total_deposits=helpers.MAX_256, dynasty_seed=helpers.MAX_BYTES, dynasty_seed_last_reset=helpers.MAX_I64, last_state_recalc=helpers.MAX_I64, ) attestation_record_bytes = serialize(attestation_record, type(attestation_record)) block_bytes = serialize(block, type(block)) crosslink_record_bytes = serialize(crosslink_record, type(crosslink_record)) validator_record_bytes = serialize(validator_record, type(validator_record)) shard_and_committee_bytes = serialize(shard_and_committee, type(shard_and_committee)) crystallized_state_bytes = serialize(crystallized_state, type(crystallized_state)) if (verbose): print('{} | {}'.format(len(attestation_record_bytes), attestation_record_bytes)) print('{} | {}'.format(len(block_bytes), block_bytes)) print('{} | {}'.format(len(shard_and_committee_bytes), shard_and_committee_bytes)) print('{} | {}'.format(len(crosslink_record_bytes), crosslink_record_bytes)) print('{} | {}'.format(len(validator_record_bytes), validator_record_bytes)) print('{} | {}'.format(len(crystallized_state_bytes), crystallized_state_bytes)) return { 'attestationRecord': len(attestation_record_bytes), 'block': len(block_bytes), 'shardAndCommittee': len(shard_and_committee_bytes), 'crosslinkRecord': len(crosslink_record_bytes), 'validatorRecord': len(validator_record_bytes), 'crystallizedState': len(crystallized_state_bytes), }
def test_failed_serialization(value, typ): with pytest.raises(Exception): serialize(value, typ)
def state_hash(crystallized_state, active_state): return blake(serialize(crystallized_state)) + blake( serialize(active_state))
def make_unfinished_block(parent_state, parent, skips, attester_share=0.8, crosslink_shards_and_shares=None): if crosslink_shards_and_shares is None: crosslink_shards_and_shares = [] crystallized_state, active_state = parent_state parent_attestation = serialize(parent) indices, proposer = get_attesters_and_proposer(crystallized_state, active_state, skips, config) print('Selected indices: %r' % indices) print('Selected block proposer: %d' % proposer) # Randomly pick indices to include bitfield = [ 1 if random.random() < attester_share else 0 for i in indices ] # Attestations sigs = [ bls.sign( parent_attestation, keymap[ crystallized_state.active_validators[indices[i]].pubkey]) for i in range(len(indices)) if bitfield[i] ] attestation_aggregate_sig = bls.aggregate_sigs(sigs) print('Aggregated sig') attestation_bitfield = bytearray((len(bitfield) - 1) // 8 + 1) for i, b in enumerate(bitfield): attestation_bitfield[i // 8] ^= (128 >> (i % 8)) * b print('Aggregate bitfield:', bin(int.from_bytes(attestation_bitfield, 'big'))) # Randomly pick indices to include for crosslinks shard_aggregate_votes = [] # The shards that are selected to be crosslinking crosslink_shards = get_crosslink_shards(crystallized_state, config=config) for shard, crosslinker_share in crosslink_shards_and_shares: # Check if this shard is in the crosslink shards list assert shard in crosslink_shards print('Making crosslink in shard %d' % shard) indices = get_crosslink_notaries(crystallized_state, shard, crosslink_shards=crosslink_shards, config=config) print('Indices: %r' % indices) bitfield = [ 1 if random.random() < crosslinker_share else 0 for i in indices ] bitmask = bytearray((len(bitfield) + 7) // 8) for i, b in enumerate(bitfield): bitmask[i // 8] ^= (128 >> (i % 8)) * b print('Bitmask:', bin(int.from_bytes(bitmask, 'big'))) shard_block_hash = blake(bytes([shard])) crosslink_attestation_hash = get_crosslink_aggvote_msg( shard, shard_block_hash, crystallized_state) sigs = [ bls.sign( crosslink_attestation_hash, keymap[crystallized_state.active_validators[ indices[i]].pubkey]) for i in range(len(indices)) if bitfield[i] ] v = AggregateVote(shard_id=shard, shard_block_hash=shard_block_hash, signer_bitmask=bitmask, aggregate_sig=list(bls.aggregate_sigs(sigs))) shard_aggregate_votes.append(v) print('Added %d shard aggregate votes' % len(crosslink_shards_and_shares)) block = Block( parent_hash=blake(parent_attestation), skip_count=skips, randao_reveal=blake(str(random.random()).encode('utf-8')), attestation_bitfield=attestation_bitfield, attestation_aggregate_sig=list(attestation_aggregate_sig), shard_aggregate_votes=shard_aggregate_votes, main_chain_ref=b'\x00' * 32, state_hash=b'\x00' * 64) return block, proposer
def test_basic_serialization(value, typ, data): assert serialize(value, typ) == data assert deserialize(data, typ) == value