Struct PointAdditionProof 

pub struct PointAdditionProof<P: SWPoint, C: SWPoint> {
    pub comm_tau: Affine<C>,
    pub tau: ProductProof<Affine<C>>,
    pub tau_sqr: SquareProof<Affine<C>>,
    pub tau_ax_minus_tx: ProductProof<Affine<C>>,
    pub bx_minus_ax: InequalityProof<Affine<C>>,
    pub ay: PokPedersenCommitment<Affine<C>>,
    /* private fields */
}

Proof of point addition when only the commitments to the points being added is known to the verifier. P is the curve where the points live and C is the curve where commitments (to their coordinates) live.

Fields

comm_tau: Affine<C>

Commitment to tau = (by - ay) / (bx - ax)

tau: ProductProof<Affine<C>>

To prove tau is properly created

tau_sqr: SquareProof<Affine<C>>

To prove tau^2 is properly created

tau_ax_minus_tx: ProductProof<Affine<C>>

To prove tau*(ax - tx) is properly created

bx_minus_ax: InequalityProof<Affine<C>>

To prove (bx - ax) is not zero

ay: PokPedersenCommitment<Affine<C>>

To prove opening of commitment to ay

Implementations

impl<P: SWPoint, C: SWPoint> PointAdditionProof<P, C>

pub fn verify( &self, comm_a: &PointCommitment<C>, comm_b: &PointCommitment<C>, comm_t: &PointCommitment<C>, challenge: &C::ScalarField, comm_key: &PedersenCommitmentKey<Affine<C>>, ) -> Result<(), Error>

Check the proof that a + b = t Its assumed that verifier “trusts” that commitment to point a, b and t are comm_a, comm_b and comm_t respectively

pub fn verify_using_randomized_mult_checker( &self, comm_a: PointCommitment<C>, comm_b: PointCommitment<C>, comm_t: PointCommitment<C>, challenge: &C::ScalarField, comm_key: PedersenCommitmentKey<Affine<C>>, rmc: &mut RandomizedMultChecker<Affine<C>>, ) -> Result<(), Error>

Same as Self::verify but delegated the scalar multiplication checks to RandomizedMultChecker

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

Assumes that the public commitments and commitment key have already been included in the challenge

Trait Implementations

impl<P: SWPoint, C: SWPoint> CanonicalDeserialize for PointAdditionProof<P, C>

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<P: SWPoint, C: SWPoint> CanonicalSerialize for PointAdditionProof<P, C>

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<P: Clone + SWPoint, C: Clone + SWPoint> Clone for PointAdditionProof<P, C>

fn clone(&self) -> PointAdditionProof<P, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + SWPoint, C: Debug + SWPoint> Debug for PointAdditionProof<P, C>

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

Formats the value using the given formatter.

impl<P: Eq + SWPoint, C: Eq + SWPoint> Eq for PointAdditionProof<P, C>

impl<P: PartialEq + SWPoint, C: PartialEq + SWPoint> PartialEq for PointAdditionProof<P, C>

fn eq(&self, other: &PointAdditionProof<P, C>) -> 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<P: SWPoint, C: SWPoint> StructuralPartialEq for PointAdditionProof<P, C>

impl<P: SWPoint, C: SWPoint> Valid for PointAdditionProof<P, C>

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

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

where Self: 'a,