Struct InequalityProtocol

pub struct InequalityProtocol<'a, G: AffineRepr> {
    pub id: usize,
    pub inequal_to: G::ScalarField,
    pub comm_key: &'a PedersenCommitmentKey<G>,
    pub comm: Option<G>,
    pub inequality_protocol: Option<DiscreteLogInequalityProtocol<G>>,
    pub sp: Option<SchnorrProtocol<'a, G>>,
}

Fields

id: usize

inequal_to: G::ScalarField

The public value with which the inequalty is being proven

comm_key: &'a PedersenCommitmentKey<G>

comm: Option<G>

inequality_protocol: Option<DiscreteLogInequalityProtocol<G>>

sp: Option<SchnorrProtocol<'a, G>>

Implementations

impl<'a, G: AffineRepr> InequalityProtocol<'a, G>

pub fn new( id: usize, inequal_to: G::ScalarField, comm_key: &'a PedersenCommitmentKey<G>, ) -> Self

pub fn init<R: RngCore>( &mut self, rng: &mut R, comm_key_as_slice: &'a [G], message: G::ScalarField, blinding: Option<G::ScalarField>, ) -> Result<(), ProofSystemError>

pub fn challenge_contribution<W: Write>( &self, writer: W, ) -> Result<(), ProofSystemError>

pub fn gen_proof_contribution<E: Pairing<G1Affine = G>>( &mut self, challenge: &G::ScalarField, ) -> Result<StatementProof<E>, ProofSystemError>

pub fn verify_proof_contribution( &self, challenge: &G::ScalarField, proof: &InequalityProof<G>, comm_key_as_slice: &[G], resp_for_message: G::ScalarField, ) -> Result<(), ProofSystemError>

pub fn compute_challenge_contribution<W: Write>( comm_key_as_slice: &[G], proof: &InequalityProof<G>, inequal_to: &G::ScalarField, comm_key: &PedersenCommitmentKey<G>, writer: W, ) -> Result<(), ProofSystemError>

Trait Implementations

impl<'a, G: Clone + AffineRepr> Clone for InequalityProtocol<'a, G>

where G::ScalarField: Clone,

fn clone(&self) -> InequalityProtocol<'a, G>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, G: Debug + AffineRepr> Debug for InequalityProtocol<'a, G>

where G::ScalarField: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, G: PartialEq + AffineRepr> PartialEq for InequalityProtocol<'a, G>

where G::ScalarField: PartialEq,

fn eq(&self, other: &InequalityProtocol<'a, G>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, G: AffineRepr> StructuralPartialEq for InequalityProtocol<'a, G>