SeqValidator

bbs_plus/src/error.rs

@@ -4,7 +4,7 @@ use ark_serialize::SerializationError;
 use ark_std::fmt::Debug;
 use dock_crypto_utils::{
     serde_utils::ArkSerializationError,
-    try_iter::{IndexIsOutOfBounds, InvalidPairOrItem},
+    try_iter::{IndexIsOutOfBounds, InvalidPair},
 };
 use schnorr_pok::error::SchnorrError;
 use serde::Serialize;
@@ -27,7 +27,7 @@ pub enum BBSPlusError {
     #[serde(with = "ArkSerializationError")]
     Serialization(SerializationError),
     SchnorrError(SchnorrError),
-    MessageIndicesMustBeUniqueAndSorted(InvalidPairOrItem<usize>),
+    MessageIndicesMustBeUniqueAndSorted(InvalidPair<usize>),
     MessageIndexIsOutOfBounds(IndexIsOutOfBounds),
 }
 
@@ -37,8 +37,8 @@ impl From<SchnorrError> for BBSPlusError {
     }
 }
 
-impl From<InvalidPairOrItem<usize>> for BBSPlusError {
-    fn from(err: InvalidPairOrItem<usize>) -> Self {
+impl From<InvalidPair<usize>> for BBSPlusError {
+    fn from(err: InvalidPair<usize>) -> Self {
         Self::MessageIndicesMustBeUniqueAndSorted(err)
     }
 }

bbs_plus/src/setup.rs

@@ -46,7 +46,7 @@ use zeroize::Zeroize;
 use core::iter::once;
 use dock_crypto_utils::{
     concat_slices, hashing_utils::projective_group_elem_from_try_and_incr, iter::*,
-    misc::pair_is_lt, serde_utils::*, try_iter::CheckLeft,
+    misc::seq_pairs_satisfy, serde_utils::*, try_iter::CheckLeft,
 };
 use itertools::process_results;
 
@@ -207,7 +207,7 @@ macro_rules! impl_sig_params {
                 let (bases, scalars): (Vec<_>, Vec<_>) = process_results(
                     pair_valid_items_with_slice::<_, _, _, BBSPlusError, _>(
                         indexed_messages_sorted_by_index,
-                        CheckLeft(pair_is_lt),
+                        CheckLeft(seq_pairs_satisfy(|a, b| a < b)),
                         &self.h,
                     ),
                     |iter| iter.chain(once((&self.h_0, blinding))).unzip(),

coconut/src/proof/messages_pok/proof.rs

@@ -3,10 +3,11 @@ use ark_ec::pairing::Pairing;
 use ark_serialize::*;
 
 use serde::{Deserialize, Serialize};
+use utils::try_iter::InvalidPair;
 
 use crate::{
     helpers::{
-        pair_is_lt, pluck_missed, take_while_satisfy, DoubleEndedExactSizeIterator, PairOrSingle,
+        pluck_missed, seq_pairs_satisfy, take_while_satisfy, DoubleEndedExactSizeIterator,
         SendIfParallel, WithSchnorrResponse,
     },
     setup::SignatureParams,
@@ -121,7 +122,7 @@ impl<E: Pairing> MessagesPoK<E> {
         let committed_h = pluck_missed(
             take_while_satisfy(
                 unique_sorted_revealed_indices,
-                pair_is_lt,
+                seq_pairs_satisfy(|a, b| a < b),
                 &mut invalid_idx_pair,
             ),
             h,
@@ -132,7 +133,7 @@ impl<E: Pairing> MessagesPoK<E> {
             .map_err(schnorr_error)
             .map_err(MessagesPoKError::InvalidComProof);
 
-        if let Some((previous, current)) = invalid_idx_pair.map(PairOrSingle::unwrap_pair) {
+        if let Some(InvalidPair(previous, current)) = invalid_idx_pair {
             Err(MessagesPoKError::RevealedIndicesMustBeUniqueAndSorted { previous, current })
         } else {
             verification_res

coconut/src/proof/signature_pok/proof.rs

@@ -2,12 +2,13 @@ use alloc::vec::Vec;
 use ark_ec::pairing::Pairing;
 use ark_serialize::*;
 use serde::{Deserialize, Serialize};
-use utils::{join, misc::pair_is_lt, randomized_pairing_check::RandomizedPairingChecker};
+use utils::{
+    join, misc::seq_pairs_satisfy, randomized_pairing_check::RandomizedPairingChecker,
+    try_iter::InvalidPair,
+};
 
 use crate::{
-    helpers::{
-        pluck_missed, take_while_satisfy, PairOrSingle, SendIfParallel, WithSchnorrResponse,
-    },
+    helpers::{pluck_missed, take_while_satisfy, SendIfParallel, WithSchnorrResponse},
     setup::{PreparedPublicKey, PreparedSignatureParams},
 };
 
@@ -83,7 +84,7 @@ impl<E: Pairing> SignaturePoK<E> {
         let mut invalid_idx_pair = None;
         let unique_sorted_msg_ids = take_while_satisfy(
             unique_sorted_revealed_msg_ids,
-            pair_is_lt,
+            seq_pairs_satisfy(|a, b| a < b),
             &mut invalid_idx_pair,
         );
 
@@ -93,7 +94,7 @@ impl<E: Pairing> SignaturePoK<E> {
             .map_err(schnorr_error)
             .map_err(SignaturePoKError::SchnorrError);
 
-        if let Some((previous, current)) = invalid_idx_pair.map(PairOrSingle::unwrap_pair) {
+        if let Some(InvalidPair(previous, current)) = invalid_idx_pair {
             Err(SignaturePoKError::RevealedIndicesMustBeUniqueAndSorted { previous, current })
         } else {
             res
@@ -152,7 +153,7 @@ impl<E: Pairing> SignaturePoK<E> {
         let committed_beta_tilde = pluck_missed(
             take_while_satisfy(
                 sorted_unique_revealed_indices,
-                pair_is_lt,
+                seq_pairs_satisfy(|a, b| a < b),
                 &mut invalid_idx_pair,
             ),
             &pk.beta_tilde,
@@ -164,7 +165,7 @@ impl<E: Pairing> SignaturePoK<E> {
             .map_err(schnorr_error)
             .map_err(SignaturePoKError::SchnorrError);
 
-        if let Some((previous, current)) = invalid_idx_pair.map(PairOrSingle::unwrap_pair) {
+        if let Some(InvalidPair(previous, current)) = invalid_idx_pair {
             Err(SignaturePoKError::RevealedIndicesMustBeUniqueAndSorted { previous, current })
         } else {
             verification_res

coconut/src/proof/signature_pok/randomized_signature.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use utils::join;
 
 use crate::{
-    helpers::{pair_is_lt, pair_valid_items_with_slice, CheckLeft, OwnedPairs},
+    helpers::{pair_valid_items_with_slice, seq_pairs_satisfy, CheckLeft, OwnedPairs},
     setup::{PreparedSignatureParams, PublicKey, SignatureParams},
     signature_pok::K,
     PSError, Signature,
@@ -71,7 +71,7 @@ impl<E: Pairing> RandomizedSignature<E> {
     {
         let uncommitted_beta_tilde_m_pairs: OwnedPairs<_, _> = pair_valid_items_with_slice(
             indexed_revealed_messages_sorted_by_index,
-            CheckLeft(pair_is_lt),
+            CheckLeft(seq_pairs_satisfy(|a, b| a < b)),
             beta_tilde,
         )
         .map_ok(|(&beta_tilde, &msg)| (beta_tilde, msg))

coconut/src/signature/aggregated_signature.rs

@@ -7,10 +7,11 @@ use serde::{Deserialize, Serialize};
 use ark_ec::pairing::Pairing;
 
 use ark_serialize::*;
+use utils::iter::validate;
 
 use super::{error::AggregatedPSError, ps_signature::Signature};
 use crate::{
-    helpers::{lagrange_basis_at_0, pair_is_lt, try_validate, CheckLeft},
+    helpers::{lagrange_basis_at_0, seq_pairs_satisfy, CheckLeft},
     owned_pairs,
 };
 
@@ -35,20 +36,15 @@ impl<E: Pairing> AggregatedSignature<E> {
     where
         SI: IntoIterator<Item = (ParticipantId, &'a Signature<E>)>,
     {
-        let ensure_participant_signatures_sigma_1_equals_to_h =
-            participant_signatures.into_iter().map(|(id, sig)| {
-                if sig.sigma_1 == h {
-                    Ok((id, sig))
-                } else {
-                    Err(AggregatedPSError::InvalidSigma1For(id))
-                }
-            });
+        let validator = (
+            |(idx, sig): &(u16, &Signature<E>)| {
+                (sig.sigma_1 != h).then_some(AggregatedPSError::InvalidSigma1For(*idx))
+            },
+            CheckLeft(seq_pairs_satisfy(|a, b| a < b)),
+        );
+
         let (participant_ids, s): (Vec<_>, Vec<_>) = process_results(
-            try_validate(
-                ensure_participant_signatures_sigma_1_equals_to_h,
-                CheckLeft(pair_is_lt),
-            )
-            .map_ok(|(id, sig)| (id, sig.sigma_2)),
+            validate(participant_signatures, validator).map_ok(|(id, sig)| (id, sig.sigma_2)),
             |iter| iter.unzip(),
         )?;
         if s.is_empty() {

coconut/src/signature/blind_signature.rs

@@ -11,7 +11,8 @@ use utils::join;
 use super::{error::BlindPSError, ps_signature::Signature};
 use crate::{
     helpers::{
-        pair_is_lt, pair_valid_items_with_slice, pair_with_slice, CheckLeft, ExtendSome, OwnedPairs,
+        pair_valid_items_with_slice, pair_with_slice, seq_pairs_satisfy, CheckLeft, ExtendSome,
+        OwnedPairs,
     },
     setup::{PublicKey, SecretKey},
     MessageCommitment,
@@ -107,7 +108,7 @@ impl<E: Pairing> BlindSignature<E> {
     {
         let blindings_with_beta: OwnedPairs<_, _> = pair_valid_items_with_slice(
             indexed_blindings_sorted_by_index,
-            CheckLeft(pair_is_lt),
+            CheckLeft(seq_pairs_satisfy(|a, b| a < b)),
             beta,
         )
         .map_ok(|(beta_j, o)| (*beta_j, (-*o)))

coconut/src/signature/error.rs

@@ -1,13 +1,13 @@
 use secret_sharing_and_dkg::common::ParticipantId;
 
-use crate::helpers::{IndexIsOutOfBounds, InvalidPairOrItem};
+use crate::helpers::{IndexIsOutOfBounds, InvalidPair};
 
 /// An error originated from `Signature`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PSError {
     NoMessages,
     InvalidMessageCount { received: usize, expected: usize },
-    MessageIndicesMustBeUniqueAndSorted(InvalidPairOrItem<usize>),
+    MessageIndicesMustBeUniqueAndSorted(InvalidPair<usize>),
     ZeroSignature,
     MessageIndexIsOutOfBounds(IndexIsOutOfBounds),
     PairingCheckFailed,
@@ -19,8 +19,8 @@ impl From<IndexIsOutOfBounds> for PSError {
     }
 }
 
-impl From<InvalidPairOrItem<usize>> for PSError {
-    fn from(err: InvalidPairOrItem<usize>) -> Self {
+impl From<InvalidPair<usize>> for PSError {
+    fn from(err: InvalidPair<usize>) -> Self {
         Self::MessageIndicesMustBeUniqueAndSorted(err)
     }
 }
@@ -34,7 +34,7 @@ pub enum BlindPSError {
         received: Option<usize>,
         expected: usize,
     },
-    BlindingIndicesMustBeUniqueAndSorted(InvalidPairOrItem<usize>),
+    BlindingIndicesMustBeUniqueAndSorted(InvalidPair<usize>),
     IncompatibleVerificationKey,
 }
 
@@ -44,8 +44,8 @@ impl From<IndexIsOutOfBounds> for BlindPSError {
     }
 }
 
-impl From<InvalidPairOrItem<usize>> for BlindPSError {
-    fn from(err: InvalidPairOrItem<usize>) -> Self {
+impl From<InvalidPair<usize>> for BlindPSError {
+    fn from(err: InvalidPair<usize>) -> Self {
         Self::BlindingIndicesMustBeUniqueAndSorted(err)
     }
 }
@@ -55,12 +55,12 @@ impl From<InvalidPairOrItem<usize>> for BlindPSError {
 pub enum AggregatedPSError {
     NoSignatures,
     InvalidSigma1For(ParticipantId),
-    ParticipantIdsMustBeUniqueAndSorted(InvalidPairOrItem<ParticipantId>),
+    ParticipantIdsMustBeUniqueAndSorted(InvalidPair<ParticipantId>),
     PSError(PSError),
 }
 
-impl From<InvalidPairOrItem<ParticipantId>> for AggregatedPSError {
-    fn from(err: InvalidPairOrItem<ParticipantId>) -> Self {
+impl From<InvalidPair<ParticipantId>> for AggregatedPSError {
+    fn from(err: InvalidPair<ParticipantId>) -> Self {
         Self::ParticipantIdsMustBeUniqueAndSorted(err)
     }
 }

proof_system/src/error.rs

@@ -1,6 +1,7 @@
 use ark_serialize::SerializationError;
 use ark_std::{collections::BTreeSet, fmt::Debug, string::String, vec::Vec};
 use bbs_plus::error::BBSPlusError;
+use coconut_crypto::helpers::InvalidPair;
 use legogroth16::{circom::CircomError, error::Error as LegoGroth16Error};
 use saver::error::SaverError;
 use schnorr_pok::error::SchnorrError;
@@ -19,10 +20,10 @@ pub enum ProofSystemError {
     ProofIncompatibleWithBoundCheckProtocol,
     BBSPlusProtocolInvalidMessageCount(usize, usize),
     BBSProtocolInvalidBlindingIndex(usize),
-    BBSProtocolNonSequentialMessageIndices(usize, usize),
+    BBSProtocolNonSequentialMessageIndices(InvalidPair<usize>),
     BBSProtocolMessageIndicesMustStartFromZero(usize),
     PSProtocolInvalidMessageCount(usize, usize),
-    PSProtocolNonSequentialMessageIndices(usize, usize),
+    PSProtocolNonSequentialMessageIndices(InvalidPair<usize>),
     PSProtocolInvalidBlindingIndex(usize),
     PSProtocolInvalidMessageIndex(usize, usize),
     PSProtocolMessageIndicesMustStartFromZero(usize),

proof_system/src/sub_protocols/bbs_plus.rs

@@ -8,7 +8,7 @@ use bbs_plus::{
     proof::{MessageOrBlinding, PoKOfSignatureG1Protocol},
 };
 use dock_crypto_utils::{
-    iter::take_while_satisfy, misc::check_seq_from,
+    iter::take_while_satisfy, misc::seq_inc_by_n_from,
     randomized_pairing_check::RandomizedPairingChecker, try_iter::CheckLeft,
 };
 use itertools::Itertools;
@@ -76,7 +76,7 @@ impl<'a, E: Pairing> PoKBBSSigG1SubProtocol<'a, E> {
                     .map(|(idx, msg)| (*idx, MessageOrBlinding::RevealMessage(msg))),
                 |(a, _), (b, _)| a < b,
             ),
-            CheckLeft(check_seq_from(0)),
+            CheckLeft(seq_inc_by_n_from(1, 0)),
             &mut non_seq_idx,
         )
         .map(|(_, msg)| msg);

proof_system/src/sub_protocols/ps_signature.rs

@@ -2,7 +2,7 @@ use ark_ec::{pairing::Pairing, AffineRepr};
 use ark_std::{collections::BTreeMap, io::Write, rand::RngCore, vec::Vec};
 
 use dock_crypto_utils::{
-    iter::take_while_satisfy, misc::check_seq_from,
+    iter::take_while_satisfy, misc::seq_inc_by_n_from,
     randomized_pairing_check::RandomizedPairingChecker, try_iter::CheckLeft,
 };
 
@@ -106,7 +106,7 @@ impl<'a, E: Pairing> PSSignaturePoK<'a, E> {
                     .map(|(idx, _)| (*idx, CommitMessage::RevealMessage)),
                 |(a, _), (b, _)| a < b,
             ),
-            CheckLeft(check_seq_from(0)),
+            CheckLeft(seq_inc_by_n_from(1, 0)),
             &mut non_seq_idx,
         )
         .map(|(_, msg)| msg);