def get_valid_early_derived_secret_reveal(spec, state, epoch=None): current_epoch = spec.get_current_epoch(state) revealed_index = spec.get_active_validator_indices(state, current_epoch)[-1] masker_index = spec.get_active_validator_indices(state, current_epoch)[0] if epoch is None: epoch = current_epoch + spec.CUSTODY_PERIOD_TO_RANDAO_PADDING reveal = bls_sign( message_hash=spec.hash_tree_root(epoch), privkey=privkeys[revealed_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) mask = bls_sign( message_hash=spec.hash_tree_root(epoch), privkey=privkeys[masker_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) return spec.EarlyDerivedSecretReveal( revealed_index=revealed_index, epoch=epoch, reveal=reveal, masker_index=masker_index, mask=mask, )
def sign_block(spec, state, block, proposer_index=None): assert state.slot <= block.slot if proposer_index is None: if block.slot == state.slot: proposer_index = spec.get_beacon_proposer_index(state) else: if spec.compute_epoch_at_slot( state.slot) + 1 > spec.compute_epoch_at_slot(block.slot): print( "warning: block slot far away, and no proposer index manually given." " Signing block is slow due to transition for proposer index calculation." ) # use stub state to get proposer index of future slot stub_state = deepcopy(state) spec.process_slots(stub_state, block.slot) proposer_index = spec.get_beacon_proposer_index(stub_state) privkey = privkeys[proposer_index] block.body.randao_reveal = bls_sign( privkey=privkey, message_hash=hash_tree_root(spec.compute_epoch_at_slot(block.slot)), domain=spec.get_domain( state, message_epoch=spec.compute_epoch_at_slot(block.slot), domain_type=spec.DOMAIN_RANDAO, )) block.signature = bls_sign(message_hash=signing_root(block), privkey=privkey, domain=spec.get_domain( state, spec.DOMAIN_BEACON_PROPOSER, spec.compute_epoch_at_slot(block.slot)))
def get_valid_custody_key_reveal(spec, state, period=None): current_epoch = spec.get_current_epoch(state) revealer_index = spec.get_active_validator_indices(state, current_epoch)[0] revealer = state.validators[revealer_index] if period is None: period = revealer.next_custody_secret_to_reveal epoch_to_sign = spec.get_randao_epoch_for_custody_period( period, revealer_index) # Generate the secret that is being revealed reveal = bls_sign( message_hash=hash_tree_root(spec.Epoch(epoch_to_sign)), privkey=privkeys[revealer_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch_to_sign, ), ) return spec.CustodyKeyReveal( revealer_index=revealer_index, reveal=reveal, )
def get_attestation_signature(spec, state, attestation_data, privkey): return bls_sign(message_hash=attestation_data.hash_tree_root(), privkey=privkey, domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_BEACON_ATTESTER, message_epoch=attestation_data.target.epoch, ))
def sign_transfer(state, transfer, privkey): transfer.signature = bls_sign(message_hash=signing_root(transfer), privkey=privkey, domain=get_domain( state=state, domain_type=spec.DOMAIN_TRANSFER, message_epoch=get_current_epoch(state), )) return transfer
def get_attestation_signature(spec, beacon_state, shard_state, message_hash, block_epoch, privkey): return bls_sign(message_hash=message_hash, privkey=privkey, domain=spec.get_domain( state=beacon_state, domain_type=spec.DOMAIN_SHARD_ATTESTER, message_epoch=block_epoch, ))
def sign_voluntary_exit(spec, state, voluntary_exit, privkey): voluntary_exit.signature = bls_sign( message_hash=signing_root(voluntary_exit), privkey=privkey, domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_VOLUNTARY_EXIT, message_epoch=voluntary_exit.epoch, ))
def sign_deposit_data(spec, state, deposit_data, privkey): signature = bls_sign( message_hash=signing_root(deposit_data), privkey=privkey, domain=spec.get_domain( state, spec.DOMAIN_DEPOSIT, ) ) deposit_data.signature = signature
def sign_block_header(state, header, privkey): domain = get_domain( state=state, domain_type=spec.DOMAIN_BEACON_PROPOSER, ) header.signature = bls_sign( message_hash=signing_root(header), privkey=privkey, domain=domain, )
def sign_voluntary_exit(spec, state, voluntary_exit, privkey): return spec.SignedVoluntaryExit( message=voluntary_exit, signature=bls_sign(message_hash=hash_tree_root(voluntary_exit), privkey=privkey, domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_VOLUNTARY_EXIT, message_epoch=voluntary_exit.epoch, )))
def sign_block_header(spec, state, header, privkey): domain = spec.get_domain( state=state, domain_type=spec.DOMAIN_BEACON_PROPOSER, ) return spec.SignedBeaconBlockHeader(message=header, signature=bls_sign( message_hash=hash_tree_root(header), privkey=privkey, domain=domain, ))
def apply_sig(spec, state, signed_block, proposer_index=None): block = signed_block.message proposer_index = get_proposer_index_maybe(spec, state, block.slot, proposer_index) privkey = privkeys[proposer_index] signed_block.signature = bls_sign( message_hash=hash_tree_root(block), privkey=privkey, domain=spec.get_domain(state, spec.DOMAIN_BEACON_PROPOSER, spec.compute_epoch_at_slot(block.slot)))
def get_valid_early_derived_secret_reveal(spec, state, epoch=None): current_epoch = spec.get_current_epoch(state) revealed_index = spec.get_active_validator_indices(state, current_epoch)[-1] masker_index = spec.get_active_validator_indices(state, current_epoch)[0] if epoch is None: epoch = current_epoch + spec.CUSTODY_PERIOD_TO_RANDAO_PADDING # Generate the secret that is being revealed reveal = bls_sign( message_hash=spec.hash_tree_root(spec.Epoch(epoch)), privkey=privkeys[revealed_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) # Generate the mask (any random 32 bytes that don't reveal the masker's secret will do) mask = hash(reveal) # Generate masker's signature on the mask masker_signature = bls_sign( message_hash=mask, privkey=privkeys[masker_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) masked_reveal = bls_aggregate_signatures([reveal, masker_signature]) return spec.EarlyDerivedSecretReveal( revealed_index=revealed_index, epoch=epoch, reveal=masked_reveal, masker_index=masker_index, mask=mask, )
def test_invalid_block_sig(spec, state): block = build_empty_block_for_next_slot(spec, state) invalid_signed_block = spec.SignedBeaconBlock( message=block, signature=bls_sign(message_hash=hash_tree_root(block), privkey=123456, domain=spec.get_domain( state, spec.DOMAIN_BEACON_PROPOSER, spec.compute_epoch_at_slot(block.slot)))) expect_assertion_error( lambda: spec.state_transition(state, invalid_signed_block)) yield 'blocks', [invalid_signed_block] yield 'post', None
def apply_randao_reveal(spec, state, block, proposer_index=None): assert state.slot <= block.slot proposer_index = get_proposer_index_maybe(spec, state, block.slot, proposer_index) privkey = privkeys[proposer_index] block.body.randao_reveal = bls_sign( privkey=privkey, message_hash=hash_tree_root(spec.compute_epoch_at_slot(block.slot)), domain=spec.get_domain( state, message_epoch=spec.compute_epoch_at_slot(block.slot), domain_type=spec.DOMAIN_RANDAO, ))
def get_attestation_signature(spec, state, attestation_data, privkey, custody_bit=0b0): message_hash = spec.AttestationDataAndCustodyBit( data=attestation_data, custody_bit=custody_bit, ).hash_tree_root() return bls_sign( message_hash=message_hash, privkey=privkey, domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_BEACON_ATTESTER, message_epoch=attestation_data.target.epoch, ) )
def sign_shard_block(spec, beacon_state, shard_state, block, proposer_index=None): if proposer_index is None: proposer_index = spec.get_shard_proposer_index(beacon_state, shard_state.shard, block.slot) privkey = privkeys[proposer_index] block.signature = bls_sign( message_hash=signing_root(block), privkey=privkey, domain=spec.get_domain( beacon_state, spec.DOMAIN_SHARD_PROPOSER, spec.compute_epoch_of_shard_slot(block.slot), ) )
def sign_deposit_data(spec, deposit_data, privkey, state=None): if state is None: # Genesis domain = spec.compute_domain(spec.DOMAIN_DEPOSIT) else: domain = spec.get_domain( state, spec.DOMAIN_DEPOSIT, ) signature = bls_sign( message_hash=signing_root(deposit_data), privkey=privkey, domain=domain, ) deposit_data.signature = signature
def get_valid_bit_challenge(spec, state, attestation, invalid_custody_bit=False): beacon_committee = spec.get_beacon_committee( state, attestation.data.slot, attestation.data.crosslink.shard, ) responder_index = beacon_committee[0] challenger_index = beacon_committee[-1] epoch = spec.get_randao_epoch_for_custody_period( attestation.data.target.epoch, responder_index) # Generate the responder key responder_key = bls_sign( message_hash=hash_tree_root(spec.Epoch(epoch)), privkey=privkeys[responder_index], domain=spec.get_domain( state=state, domain_type=spec.DOMAIN_RANDAO, message_epoch=epoch, ), ) chunk_count = spec.get_custody_chunk_count(attestation.data.crosslink) chunk_bits = bitlist_from_int(spec.MAX_CUSTODY_CHUNKS, chunk_count, 0) n = 0 while spec.get_chunk_bits_root( chunk_bits) == attestation.custody_bits[0] ^ invalid_custody_bit: chunk_bits = bitlist_from_int(spec.MAX_CUSTODY_CHUNKS, chunk_count, n) n += 1 return spec.CustodyBitChallenge( responder_index=responder_index, attestation=attestation, challenger_index=challenger_index, responder_key=responder_key, chunk_bits=chunk_bits, )
def test_voluntary_exit(state): validator_index = get_active_validator_indices( state, get_current_epoch(state) )[-1] # move state forward PERSISTENT_COMMITTEE_PERIOD epochs to allow for exit state.slot += spec.PERSISTENT_COMMITTEE_PERIOD * spec.SLOTS_PER_EPOCH yield 'pre', state voluntary_exit = VoluntaryExit( epoch=get_current_epoch(state), validator_index=validator_index, ) voluntary_exit.signature = bls_sign( message_hash=signing_root(voluntary_exit), privkey=privkeys[validator_index], domain=get_domain( state=state, domain_type=spec.DOMAIN_VOLUNTARY_EXIT, ) ) # Add to state via block transition initiate_exit_block = build_empty_block_for_next_slot(state) initiate_exit_block.body.voluntary_exits.append(voluntary_exit) sign_block(state, initiate_exit_block) state_transition(state, initiate_exit_block) assert state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH # Process within epoch transition exit_block = build_empty_block_for_next_slot(state) exit_block.slot += spec.SLOTS_PER_EPOCH sign_block(state, exit_block) state_transition(state, exit_block) yield 'blocks', [initiate_exit_block, exit_block], [spec.BeaconBlock] yield 'post', state assert state.validator_registry[validator_index].exit_epoch < spec.FAR_FUTURE_EPOCH
def sign_deposit_data(spec, deposit_data, privkey, state=None): if state is None: # Genesis domain = spec.compute_domain(spec.DOMAIN_DEPOSIT) else: domain = spec.get_domain( state, spec.DOMAIN_DEPOSIT, ) deposit_message = spec.DepositMessage( pubkey=deposit_data.pubkey, withdrawal_credentials=deposit_data.withdrawal_credentials, amount=deposit_data.amount) signature = bls_sign( message_hash=hash_tree_root(deposit_message), privkey=privkey, domain=domain, ) deposit_data.signature = signature