Struct sigma_fun::EqAll

pub struct EqAll<S, N> { /* private fields */ }

Combinator for proving any number of statements of the same kind have the same witness.

Implementations

impl<S, N> EqAll<S, N>

pub fn new(sigma: S) -> Self

Create a EqAll<N,S> from a Sigma protocol S.

Trait Implementations

impl<S: Clone, N: Clone> Clone for EqAll<S, N>

fn clone(&self) -> EqAll<S, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, N: Debug> Debug for EqAll<S, N>

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

Formats the value using the given formatter.

impl<S: Default, N: Default> Default for EqAll<S, N>

fn default() -> EqAll<S, N>

Returns the “default value” for a type.

impl<S, N> Display for EqAll<S, N>where
    EqAll<S, N>: Sigma,

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

Formats the value using the given formatter.

impl<S: PartialEq, N: PartialEq> PartialEq<EqAll<S, N>> for EqAll<S, N>

fn eq(&self, other: &EqAll<S, N>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<N: Unsigned, S: Sigma> Sigma for EqAll<S, N>

type Witness = <S as Sigma>::Witness

The witness for the relation.

type Statement = Vec<<S as Sigma>::Statement, Global>

The elements of the statement the prover is proving.

type AnnounceSecret = <S as Sigma>::AnnounceSecret

The type for the secret the prover creates when generating the proof.

type Announcement = Vec<<S as Sigma>::Announcement, Global>

The type for the public announcement the prover sends in the first round of the protocol.

type Response = <S as Sigma>::Response

The type for the response the prover sends in the last round of the protocol.

type ChallengeLength = <S as Sigma>::ChallengeLength

The length as a typenum

fn respond(
    &self,
    witness: &Self::Witness,
    statement: &Self::Statement,
    announce_secret: Self::AnnounceSecret,
    announce: &Self::Announcement,
    challenge: &GenericArray<u8, Self::ChallengeLength>
) -> Self::Response

Generates the prover’s response for the verifier’s challenge.

fn gen_announce_secret<Rng: CryptoRng + RngCore>(
    &self,
    witness: &Self::Witness,
    rng: &mut Rng
) -> Self::AnnounceSecret

Generates the secret data to create the announcement

fn announce(
    &self,
    statement: &Self::Statement,
    announce_secret: &Self::AnnounceSecret
) -> Self::Announcement

Generates the prover’s announcement message.

fn sample_response<Rng: CryptoRng + RngCore>(
    &self,
    rng: &mut Rng
) -> Self::Response

Uniformly samples a response from the response space of the Sigma protocol.

fn implied_announcement(
    &self,
    statements: &Self::Statement,
    challenge: &GenericArray<u8, Self::ChallengeLength>,
    response: &Self::Response
) -> Option<Self::Announcement>

Computes what the announcement must be for the response to be valid.

fn hash_statement<H: Update>(&self, hash: &mut H, statements: &Self::Statement)

Hashes the statement.

fn hash_announcement<H: Update>(
    &self,
    hash: &mut H,
    announcements: &Self::Announcement
)

Hashes the announcement.

fn hash_witness<H: Update>(&self, hash: &mut H, witness: &Self::Witness)

Hashes the witness.

impl<S: Sigma, N: Unsigned> Writable for EqAll<S, N>

fn write_to<W: Write>(&self, w: &mut W) -> Result

Asks the thing to write itself to W.

impl<S, N> StructuralPartialEq for EqAll<S, N>