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