Set indices to be represented as vectors instead of unique

[iquerejeta]

Up until now, a signature could be valid for a single index. This resulted in a practical requirement that the aggregate should have as many signatures as indices, but this is not a requirement by design. Moreover, the current mechanism for signers to find "valid" signatures was by producing the same signature for each index and checking validity. With the changes in this PR we optimise both points. In particular:

• Signatures contain a vector of the valid indexes
• Signers produce a single signature and iterate over the indices without having to recompute the signature
• Signatures are checked once (and not as many times as valid indexes they had)

These changes implements option 3 of #296. In this PR we also implement PartialEq for StmSig and define a canonical display for a VerificationKey and Signature, which closes #336 and closes #337 respectively.

[github-actions]

Unit Test Results

233 tests  ±0   233 ✔️ ±0   4m 16s ⏱️ - 3m 3s
  18 suites ±0       0 💤 ±0 
    6 files   ±0       0 ❌ ±0 

Results for commit cb6e434. ± Comparison against base commit 50cafcf.

♻️ This comment has been updated with latest results.

[jpraynaud]

Maybe you could avoid filtering the deduped_sig.indexes multiple times like this, WDYT?

        for (_, &sig) in sig_by_index.iter() {
            if dedup_sigs.contains(sig) {
                continue;
            }
            let mut deduped_sig = sig.clone();
            if let Some(indexes) = removal_idx_by_vk.get(sig) {
                deduped_sig.indexes = deduped_sig
                    .indexes
                    .clone()
                    .into_iter()
                    .filter(|i| !indexes.contains(i))
                    .collect();
            }

            let size: Result<u64, _> = deduped_sig.indexes.len().try_into();
            if let Ok(size) = size {
                dedup_sigs.insert(deduped_sig);
                count += size;
                if count >= self.params.k {
                    return Ok(dedup_sigs.into_iter().collect());
                }
            }
        }

[iquerejeta]

@jpraynaud , to be able to check that a signature is inside the hashmap before filtering the list of indexes we need to define the hash and the eq functions in a way that does not depend on the set of valid indices. I think it is alright, and I chose the underlying signature for that. WDYT?

[jpraynaud]

This means that it was also the case for this part of the code 🤔 (so that a signature number of won lotteries would have been counted multiple times)

if dedup_sigs.insert(deduped_sig) {
    count += size;
}

Using the underlying signature for the hash looks good as there should 't be any need for the same signature with different won lotteries indices after deduplication IMH 👍

[iquerejeta]

Before it was not the case, because we were inserting (and therefore checking if the signature was in the map) after editing the vector of indexes. Therefore, the previous Hash and PartialEq criteria was catching duplicates.

[jpraynaud]

You're completely right 👍

[jpraynaud]

LGTM