def keymap(privkeys): keymap = {} for i, k in enumerate(privkeys): keymap[bls.privtopub(k)] = k if i % 50 == 0: print("Generated %d keys" % i) return keymap
def test_signature_aggregation(msg, privkeys): domain = 0 sigs = [sign(msg, k, domain=domain) for k in privkeys] pubs = [privtopub(k) for k in privkeys] aggsig = aggregate_signatures(sigs) aggpub = aggregate_pubkeys(pubs) assert verify(msg, aggpub, aggsig, domain=domain)
def test_bls_core(privkey): domain = 0 p1 = multiply(G1, privkey) p2 = multiply(G2, privkey) msg = str(privkey).encode('utf-8') msghash = hash_to_G2(msg, domain=domain) assert normalize(decompress_G1(compress_G1(p1))) == normalize(p1) assert normalize(decompress_G2(compress_G2(p2))) == normalize(p2) assert normalize(decompress_G2(compress_G2(msghash))) == normalize(msghash) sig = sign(msg, privkey, domain=domain) pub = privtopub(privkey) assert verify(msg, pub, sig, domain=domain)
def test_multi_aggregation(msg_1, msg_2, privkeys_1, privkeys_2): domain = 0 sigs_1 = [sign(msg_1, k, domain=domain) for k in privkeys_1] pubs_1 = [privtopub(k) for k in privkeys_1] aggsig_1 = aggregate_signatures(sigs_1) aggpub_1 = aggregate_pubkeys(pubs_1) sigs_2 = [sign(msg_2, k, domain=domain) for k in privkeys_2] pubs_2 = [privtopub(k) for k in privkeys_2] aggsig_2 = aggregate_signatures(sigs_2) aggpub_2 = aggregate_pubkeys(pubs_2) msgs = [msg_1, msg_2] pubs = [aggpub_1, aggpub_2] aggsig = aggregate_signatures([aggsig_1, aggsig_2]) assert verify_multiple( pubkeys=pubs, messages=msgs, signature=aggsig, domain=domain, )
block = BeaconBlock(**sample_beacon_block_params).copy(slot=block_slot, ) if isinstance(expected, Exception): with pytest.raises(ValidationError): validate_block_slot(state, block) else: validate_block_slot(state, block) @pytest.mark.parametrize( 'epoch_length, shard_count,' 'proposer_privkey, proposer_pubkey, is_valid_signature', ( ( 5, 2, 0, bls.privtopub(0), True, ), (5, 2, 0, bls.privtopub(0)[1:] + b'\x01', False), (5, 2, 0, b'\x01\x23', False), (5, 2, 123, bls.privtopub(123), True), (5, 2, 123, bls.privtopub(123)[1:] + b'\x01', False), (5, 2, 123, b'\x01\x23', False), )) def test_validate_proposer_signature( proposer_privkey, proposer_pubkey, is_valid_signature, sample_beacon_block_params, sample_beacon_state_params, beacon_chain_shard_number, epoch_length, max_deposit, target_committee_size, shard_count): state = BeaconState(**sample_beacon_state_params).copy(
from eth2.beacon.types.blocks import BeaconBlock from eth2.beacon.types.proposal_signed_data import ( ProposalSignedData, ) from eth2.beacon.types.states import BeaconState from eth2.beacon.state_machines.forks.serenity.validation import ( validate_serenity_proposer_signature, ) from tests.eth2.beacon.helpers import mock_validator_record from tests.eth2.beacon.test_helpers import ( get_sample_shard_committees_at_slots, ) @pytest.mark.parametrize( 'proposer_privkey, proposer_pubkey, is_valid_signature', ( (0, bls.privtopub(0), True), (0, bls.privtopub(0) + 1, False), (0, 123, False), (123, bls.privtopub(123), True), (123, bls.privtopub(123) + 1, False), (123, 123, False), )) def test_validate_serenity_proposer_signature( proposer_privkey, proposer_pubkey, is_valid_signature, sample_beacon_block_params, sample_beacon_state_params, sample_shard_committee_params, beacon_chain_shard_number, epoch_length, max_deposit): state = BeaconState(**sample_beacon_state_params).copy( validator_registry=tuple( mock_validator_record(proposer_pubkey) for _ in range(10)),