Function check

kvac/src/bbs_sharp/proof.rs:848–1035

(message_count: u32, num_tokens: usize, nonces: Option<Vec<&[u8]>>)

        let num_tokens = 10;

        fn check(message_count: u32, num_tokens: usize, nonces: Option<Vec<&[u8]>>) {
            let mut rng = StdRng::seed_from_u64(0u64);
            let messages = (0..message_count)
                .map(|_| Fr::rand(&mut rng))
                .collect::<Vec<_>>();
            let params = MACParams::<Affine>::new::<Sha256>(b"test", message_count);
            let signer_sk = SecretKey::new(&mut rng);
            let signer_pk = SignerPublicKey::new_from_params(&signer_sk, &params);

            let user_sk = SecretKey::new(&mut rng);
            let user_pk = UserPublicKey::new_from_params(&user_sk, &params);

            let mac = MAC::new(&mut rng, &messages, &user_pk, &signer_sk, &params).unwrap();
            let proof = ProofOfValidityOfMAC::new::<_, Sha256>(
                &mut rng, &mac, &signer_sk, &signer_pk, &params, None,
            );

            mac.verify(&messages, &user_pk, &signer_sk, &params)
                .unwrap();
            proof
                .verify::<Sha256>(&mac, &messages, &user_pk, &signer_pk, params.clone())
                .unwrap();

            // User generates several requests of keyed-proofs and sends them to the signer and gets their proof of validity.
            // These will be used later to create proof of knowledge of MAC
            let mut signer_time = Duration::default();
            let mut user_time = Duration::default();

            // User proves knowledge of secret key to signer using a Schnorr signature (called pi_U in paper)
            let signer_challenge = b"signer's challenge";
            let start = Instant::now();
            let schnorr_signature = SchnorrSignature::new::<_, Sha256>(
                &mut rng,
                signer_challenge,
                &user_sk.0,
                &params.g,
            );
            user_time += start.elapsed();

            let start = Instant::now();
            assert!(schnorr_signature.verify::<Sha256>(signer_challenge, &user_pk.0, &params.g));
            signer_time += start.elapsed();

            let start = Instant::now();
            let mut user_protocol =
                HOLUserProtocol::init(&mut rng, num_tokens, &mac, &messages, &user_pk, &params)
                    .unwrap();
            user_time += start.elapsed();

            let start = Instant::now();
            let (signer_protocol, pre_challenge) =
                HOLSignerProtocol::init(&mut rng, num_tokens, &mac.A, &params);
            signer_time += start.elapsed();

            let start = Instant::now();
            let blinded_challenges =
                user_protocol.compute_challenge::<Sha256>(pre_challenge, &params, nonces.clone());
            user_time += start.elapsed();