Struct bellperson::groth16::aggregate::GipaProof

pub struct GipaProof<E: Engine> {
    pub nproofs: u32,
    pub comms_ab: Vec<(Output<E>, Output<E>)>,
    pub comms_c: Vec<(Output<E>, Output<E>)>,
    pub z_ab: Vec<(E::Fqk, E::Fqk)>,
    pub z_c: Vec<(E::G1, E::G1)>,
    pub final_a: E::G1Affine,
    pub final_b: E::G2Affine,
    pub final_c: E::G1Affine,
    pub final_vkey: (E::G2Affine, E::G2Affine),
    pub final_wkey: (E::G1Affine, E::G1Affine),
}

It contains all elements derived in the GIPA loop for both TIPP and MIPP at the same time.

Fields

nproofs: u32

comms_ab: Vec<(Output<E>, Output<E>)>

comms_c: Vec<(Output<E>, Output<E>)>

z_ab: Vec<(E::Fqk, E::Fqk)>

z_c: Vec<(E::G1, E::G1)>

final_a: E::G1Affine

final_b: E::G2Affine

final_c: E::G1Affine

final_vkey: (E::G2Affine, E::G2Affine)

final commitment keys $v$ and $w$ - there is only one element at the end for v1 and v2 hence it’s a tuple.

final_wkey: (E::G1Affine, E::G1Affine)

Implementations

impl<E: Engine> GipaProof<E>

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

Writes the proof into the provided buffer.

Trait Implementations

impl<E: Debug + Engine> Debug for GipaProof<E> where
    E::Fqk: Debug,
    E::Fqk: Debug,
    E::G1: Debug,
    E::G1: Debug,
    E::G1Affine: Debug,
    E::G2Affine: Debug,
    E::G1Affine: Debug,
    E::G2Affine: Debug,
    E::G2Affine: Debug,
    E::G1Affine: Debug,
    E::G1Affine: Debug, 

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

Formats the value using the given formatter.

impl<'de, E: Engine> Deserialize<'de> for GipaProof<E> where
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::Fqk: Deserialize<'de>,
    E::G1: Deserialize<'de>,
    E::G1: Deserialize<'de>,
    E::G2Affine: Deserialize<'de>,
    E::G2Affine: Deserialize<'de>,
    E::G1Affine: Deserialize<'de>,
    E::G1Affine: Deserialize<'de>,
    E::G1Affine: Deserialize<'de>,
    E::G2Affine: Deserialize<'de>,
    E::G1Affine: 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<GipaProof<E>> for GipaProof<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 GipaProof<E> where
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::Fqk: Serialize,
    E::G1: Serialize,
    E::G1: Serialize,
    E::G2Affine: Serialize,
    E::G2Affine: Serialize,
    E::G1Affine: Serialize,
    E::G1Affine: Serialize,
    E::G1Affine: Serialize,
    E::G2Affine: Serialize,
    E::G1Affine: Serialize, 

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

Serialize this value into the given Serde serializer.