Trait AccumulationScheme

pub trait AccumulationScheme<C, L>
where
    C: CurveAffine,
    L: Loader<C>,
{
    type Accumulator: Clone + Debug;
    type VerifyingKey: Clone + Debug;
    type Proof: Clone + Debug;

    // Required methods
    fn read_proof<T>(
        vk: &Self::VerifyingKey,
        instances: &[Self::Accumulator],
        transcript: &mut T,
    ) -> Result<Self::Proof, Error>
       where T: TranscriptRead<C, L>;
    fn verify(
        vk: &Self::VerifyingKey,
        instances: &[Self::Accumulator],
        proof: &Self::Proof,
    ) -> Result<Self::Accumulator, Error>;
}

Accumulation scheme verifier.

Required Associated Types

type Accumulator: Clone + Debug

Accumulator to be accumulated.

type VerifyingKey: Clone + Debug

Verifying key.

type Proof: Clone + Debug

Structured proof read from transcript.

Required Methods

fn read_proof<T>( vk: &Self::VerifyingKey, instances: &[Self::Accumulator], transcript: &mut T, ) -> Result<Self::Proof, Error>

where T: TranscriptRead<C, L>,

Read a AccumulationScheme::Proof from transcript.

fn verify( vk: &Self::VerifyingKey, instances: &[Self::Accumulator], proof: &Self::Proof, ) -> Result<Self::Accumulator, Error>

Verify old AccumulationScheme::Accumulators are accumulated properly into a new one with the AccumulationScheme::Proof, and returns the new one as output.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<C, L, MOS> AccumulationScheme<C, L> for IpaAs<C, MOS>

where C: CurveAffine, L: Loader<C>, MOS: Clone + Debug,

type Accumulator = IpaAccumulator<C, L>

type VerifyingKey = IpaSuccinctVerifyingKey<C>

type Proof = IpaAsProof<C, L>

impl<M, L, MOS> AccumulationScheme<<M as Engine>::G1Affine, L> for KzgAs<M, MOS>

where M: MultiMillerLoop, M::G1Affine: CurveAffine<ScalarExt = M::Fr, CurveExt = M::G1>, L: Loader<M::G1Affine>, MOS: Clone + Debug,

type Accumulator = KzgAccumulator<<M as Engine>::G1Affine, L>

type VerifyingKey = KzgAsVerifyingKey

type Proof = KzgAsProof<<M as Engine>::G1Affine, L>