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)),
