def test_signature_aggregation(backend, msg, privkeys, domain):
bls.use(backend)
sigs = [bls.sign(msg, k, domain=domain) for k in privkeys]
pubs = [bls.privtopub(k) for k in privkeys]
aggsig = bls.aggregate_signatures(sigs)
aggpub = bls.aggregate_pubkeys(pubs)
assert bls.verify(msg, aggpub, aggsig, domain=domain)
def test_sanity(backend):
bls.use(backend)
msg_0 = b"\x32" * 32
domain = 123
# Test: Verify the basic sign/verify process
privkey_0 = 5566
sig_0 = bls.sign(msg_0, privkey_0, domain)
assert_signature(sig_0)
pubkey_0 = bls.privtopub(privkey_0)
assert_pubkey(pubkey_0)
assert bls.verify(msg_0, pubkey_0, sig_0, domain)
privkey_1 = 5567
sig_1 = bls.sign(msg_0, privkey_1, domain)
pubkey_1 = bls.privtopub(privkey_1)
assert bls.verify(msg_0, pubkey_1, sig_1, domain)
# Test: Verify signatures are correctly aggregated
aggregated_signature = bls.aggregate_signatures([sig_0, sig_1])
assert_signature(aggregated_signature)
# Test: Verify pubkeys are correctly aggregated
aggregated_pubkey = bls.aggregate_pubkeys([pubkey_0, pubkey_1])
assert_pubkey(aggregated_pubkey)
# Test: Verify with `aggregated_signature` and `aggregated_pubkey`
assert bls.verify(msg_0, aggregated_pubkey, aggregated_signature, domain)
# Test: `verify_multiple`
msg_1 = b"x22" * 32
privkey_2 = 55688
sig_2 = bls.sign(msg_1, privkey_2, domain)
assert_signature(sig_2)
pubkey_2 = bls.privtopub(privkey_2)
assert_pubkey(pubkey_2)
sig_1_2 = bls.aggregate_signatures([sig_1, sig_2])
assert bls.verify_multiple(
pubkeys=[pubkey_1, pubkey_2],
message_hashes=[msg_0, msg_1],
signature=sig_1_2,
domain=domain,
)
def _correct_indexed_attestation_params(validator_count, message_hash, params,
privkeys, state, config):
valid_params = copy.deepcopy(params)
(attesting_indices,
signatures) = _get_indices_and_signatures(validator_count, state, config,
message_hash, privkeys)
valid_params["attesting_indices"] = attesting_indices
signature = bls.aggregate_signatures(signatures)
valid_params["signature"] = signature
return valid_params
def aggregate_votes(
bitfield: Bitfield, sigs: Sequence[BLSSignature],
voting_sigs: Sequence[BLSSignature],
attesting_indices: Sequence[ValidatorIndex]
) -> Tuple[Bitfield, BLSSignature]:
"""
Aggregate the votes.
"""
# Update the bitfield and append the signatures
sigs = tuple(sigs) + tuple(voting_sigs)
bitfield = pipe(
bitfield,
*(set_voted(index=committee_index)
for committee_index in attesting_indices))
return bitfield, bls.aggregate_signatures(sigs)
def _correct_indexed_attestation_params(validator_count, message_hashes,
params, privkeys, state, config):
valid_params = copy.deepcopy(params)
(custody_bit_0_indices, signatures) = _get_indices_and_signatures(
validator_count,
state,
config,
message_hashes[0], # custody bit is False
privkeys,
)
valid_params["custody_bit_0_indices"] = custody_bit_0_indices
valid_params["custody_bit_1_indices"] = tuple()
signature = bls.aggregate_signatures(signatures)
valid_params["signature"] = signature
return valid_params
def get_aggregate_from_valid_committee_attestations(
attestations: Sequence[Attestation]) -> Attestation:
"""
Return the aggregate attestation.
The given attestations SHOULD have the same `data: AttestationData` and are valid.
"""
signatures = [attestation.signature for attestation in attestations]
aggregate_signature = bls.aggregate_signatures(signatures)
all_aggregation_bits = [
attestation.aggregation_bits for attestation in attestations
]
aggregation_bits = tuple(map(any, zip(*all_aggregation_bits)))
assert len(attestations) > 0
return Attestation.create(
data=attestations[0].data,
aggregation_bits=Bitfield(aggregation_bits),
signature=aggregate_signature,
)
def test_multi_aggregation(backend, msg_1, msg_2, privkeys_1, privkeys_2,
domain):
bls.use(backend)
sigs_1 = [bls.sign(msg_1, k, domain=domain)
for k in privkeys_1] # signatures to msg_1
pubs_1 = [bls.privtopub(k) for k in privkeys_1]
aggpub_1 = bls.aggregate_pubkeys(pubs_1) # sig_1 to msg_1
sigs_2 = [bls.sign(msg_2, k, domain=domain)
for k in privkeys_2] # signatures to msg_2
pubs_2 = [bls.privtopub(k) for k in privkeys_2]
aggpub_2 = bls.aggregate_pubkeys(pubs_2) # sig_2 to msg_2
message_hashes = [msg_1, msg_2]
pubs = [aggpub_1, aggpub_2]
aggsig = bls.aggregate_signatures(sigs_1 + sigs_2)
assert bls.verify_multiple(pubkeys=pubs,
message_hashes=message_hashes,
signature=aggsig,
domain=domain)
def run_with(_cls, inputs: SequenceOfBLSSignature,
_config: Optional[Eth2Config]) -> BLSSignature:
# BLS override
bls.use(MilagroBackend)
return bls.aggregate_signatures(inputs)
def test_empty_aggregation(backend):
bls.use(backend)
assert bls.aggregate_pubkeys([]) == EMPTY_PUBKEY
assert bls.aggregate_signatures([]) == EMPTY_SIGNATURE
