Struct Response 

pub struct Response<G: AffineRepr> {
    pub z_prime_0: G::ScalarField,
    pub z_prime_1: G::ScalarField,
    pub A: Vec<G>,
    pub B: Vec<G>,
}

Fields

z_prime_0: G::ScalarField

z_prime_1: G::ScalarField

A: Vec<G>

B: Vec<G>

Implementations

impl<G> Response<G>

where G: AffineRepr,

pub fn is_valid_recursive<D: Digest, L: LinearForm<G::ScalarField>>( &self, g: &[G], h: &G, k: &G, P: &G, y: &G::ScalarField, linear_form: &L, A_hat: &G, t: &G::ScalarField, c_0: &G::ScalarField, c_1: &G::ScalarField, ) -> Result<(), CompSigmaError>

Validate the proof of knowledge in the recursive manner where the size of the various vectors is reduced to half in each iteration. This execution is similar to the prover’s. A naive and thus slower implementation than is_valid

pub fn is_valid<D: Digest, L: LinearForm<G::ScalarField>>( &self, g: &[G], h: &G, k: &G, P: &G, y: &G::ScalarField, linear_form: &L, A_hat: &G, t: &G::ScalarField, c_0: &G::ScalarField, c_1: &G::ScalarField, ) -> Result<(), CompSigmaError>

Validate the proof of knowledge in the non-recursive manner. This will delay scalar multiplications till the end similar to whats described in the Bulletproofs paper, thus is faster than the recursive version above. The key idea is that the verifier knows both A and B at the start and thus he knows all the immediate challenges c also at the start. Thus the verifier can create the final g’ and Q in a single multi-scalar multiplication

pub fn recursively_validate_compressed<D: Digest, L: LinearForm<G::ScalarField>>( &self, Q: G::Group, g_hat: Vec<G>, L_tilde: L, k: &G, ) -> Result<(), CompSigmaError>

pub fn validate_compressed<D: Digest, L: LinearForm<G::ScalarField>>( &self, Q: G::Group, g_hat: Vec<G>, L_tilde: L, k: &G, ) -> Result<(), CompSigmaError>

Trait Implementations

impl<G: AffineRepr> CanonicalDeserialize for Response<G>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl<G: AffineRepr> CanonicalSerialize for Response<G>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<G: Clone + AffineRepr> Clone for Response<G>

where G::ScalarField: Clone,

fn clone(&self) -> Response<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: Debug + AffineRepr> Debug for Response<G>

where G::ScalarField: Debug,

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

Formats the value using the given formatter.

impl<G: PartialEq + AffineRepr> PartialEq for Response<G>

where G::ScalarField: PartialEq,

fn eq(&self, other: &Response<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<G: AffineRepr> Valid for Response<G>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl<G: Eq + AffineRepr> Eq for Response<G>

where G::ScalarField: Eq,

impl<G: AffineRepr> StructuralPartialEq for Response<G>