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