Struct bellperson::groth16::aggregate::AggregateProof

pub struct AggregateProof<E: Engine> {
    pub com_ab: Output<E>,
    pub com_c: Output<E>,
    pub ip_ab: E::Fqk,
    pub agg_c: E::G1,
    pub tmipp: TippMippProof<E>,
}

AggregateProof contains all elements to verify n aggregated Groth16 proofs using inner pairing product arguments. This proof can be created by any party in possession of valid Groth16 proofs.

Fields

com_ab: Output<E>

commitment to A and B using the pair commitment scheme needed to verify TIPP relation.

com_c: Output<E>

commit to C separate since we use it only in MIPP

ip_ab: E::Fqk

$A^r * B = Z$ is the left value on the aggregated Groth16 equation

agg_c: E::G1

$C^r$ is used on the right side of the aggregated Groth16 equation

tmipp: TippMippProof<E>

Implementations

impl<E: Engine> AggregateProof<E>

pub fn parsing_check(&self) -> Result<(), SynthesisError>

Performs some high level checks on the length of vectors and others to make sure all items in the proofs are consistent with each other.

pub fn write(&self, out: impl Write) -> Result<()>

Writes the agggregated proof into the provided buffer.

pub fn serialized_len(&self) -> usize

Returns the number of bytes this proof is serialized to.

pub fn read(source: impl Read) -> Result<Self>

Trait Implementations

impl<E: Debug + Engine> Debug for AggregateProof<E> where
    E::Fqk: Debug,
    E::G1: Debug, 

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

Formats the value using the given formatter.

impl<'de, E: Engine> Deserialize<'de> for AggregateProof<E> where
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    TippMippProof<E>: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::G1: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<E: Engine> PartialEq<AggregateProof<E>> for AggregateProof<E>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<E: Engine> Serialize for AggregateProof<E> where
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    TippMippProof<E>: Serialize,
    E::Fqk: Serialize,
    E::G1: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.