Struct snarkvm_wasm::PedersenCRH

pub struct PedersenCRH<G, S> where
    G: Group,
    S: PedersenSize,  {
    pub parameters: PedersenCRHParameters<G, S>,
}

Fields

parameters: PedersenCRHParameters<G, S>

Trait Implementations

impl<G, S> CRH for PedersenCRH<G, S> where
    G: Group,
    S: PedersenSize, 

type Output = G

type Parameters = PedersenCRHParameters<G, S>

pub const INPUT_SIZE_BITS: usize

pub fn setup<R>(rng: &mut R) -> PedersenCRH<G, S> where
    R: Rng, 

pub fn hash(
    &self,
    input: &[u8]
) -> Result<<PedersenCRH<G, S> as CRH>::Output, CRHError>

pub fn parameters(&self) -> &<PedersenCRH<G, S> as CRH>::Parameters

impl<F, G, GG, S> CRHGadget<PedersenCRH<G, S>, F> for PedersenCRHGadget<G, F, GG> where
    G: Group,
    S: PedersenSize,
    F: Field,
    GG: GroupGadget<G, F>, 

type OutputGadget = GG

type ParametersGadget = PedersenCRHParametersGadget<G, S, F, GG>

pub fn check_evaluation_gadget<CS>(
    cs: CS,
    parameters: &<PedersenCRHGadget<G, F, GG> as CRHGadget<PedersenCRH<G, S>, F>>::ParametersGadget,
    input: Vec<UInt8, Global>
) -> Result<<PedersenCRHGadget<G, F, GG> as CRHGadget<PedersenCRH<G, S>, F>>::OutputGadget, SynthesisError> where
    CS: ConstraintSystem<F>, 

impl<G, S> Clone for PedersenCRH<G, S> where
    G: Clone + Group,
    S: Clone + PedersenSize, 

pub fn clone(&self) -> PedersenCRH<G, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G, S> Debug for PedersenCRH<G, S> where
    G: Debug + Group,
    S: Debug + PedersenSize, 

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

Formats the value using the given formatter.

impl<G, S> From<PedersenCRHParameters<G, S>> for PedersenCRH<G, S> where
    G: Group,
    S: PedersenSize, 

pub fn from(parameters: PedersenCRHParameters<G, S>) -> PedersenCRH<G, S>

Performs the conversion.

impl<F, G, GG, S> MaskedCRHGadget<PedersenCRH<G, S>, F> for PedersenCRHGadget<G, F, GG> where
    G: Group,
    S: PedersenSize,
    F: PrimeField,
    GG: GroupGadget<G, F>, 

pub fn check_evaluation_gadget_masked<CS>(
    cs: CS,
    parameters: &<PedersenCRHGadget<G, F, GG> as CRHGadget<PedersenCRH<G, S>, F>>::ParametersGadget,
    input: Vec<UInt8, Global>,
    mask_parameters: &<PedersenCRHGadget<G, F, GG> as CRHGadget<PedersenCRH<G, S>, F>>::ParametersGadget,
    mask: Vec<UInt8, Global>
) -> Result<<PedersenCRHGadget<G, F, GG> as CRHGadget<PedersenCRH<G, S>, F>>::OutputGadget, SynthesisError> where
    CS: ConstraintSystem<F>, 

Evaluates a masked Pedersen hash on the given input using the given mask. The algorithm is based on the description in https://eprint.iacr.org/2020/190.pdf, which relies on the homomorphic properties of Pedersen hashes. First, the mask is extended to ensure constant hardness - for each bit, 0 => 01, 1 => 10. Then, denoting input bits as m_i, mask bits as p_i and bases as h_i, computes sum of (g_i * 1[p_i = 0] + g_i^{-1} * 1[p_i = 1])^{m_i \xor p_i} for all i. Finally, the hash of the mask itself, being sum of h_i^{p_i} for all i, is added to the computed sum. This algorithm ensures that each bit in the hash is affected by the mask and that the final hash remains the same as if no mask was used.

fn extend_mask<CS>(
    CS,
    mask: &[UInt8]
) -> Result<Vec<UInt8, Global>, SynthesisError> where
    CS: ConstraintSystem<F>, 

Extends the mask such that 0 => 01, 1 => 10.

impl<G, S> Ord for PedersenCRH<G, S> where
    G: Ord + Group,
    S: Ord + PedersenSize, 

pub fn cmp(&self, other: &PedersenCRH<G, S>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<G, S> PartialEq<PedersenCRH<G, S>> for PedersenCRH<G, S> where
    G: PartialEq<G> + Group,
    S: PartialEq<S> + PedersenSize, 

pub fn eq(&self, other: &PedersenCRH<G, S>) -> bool

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

pub fn ne(&self, other: &PedersenCRH<G, S>) -> bool

This method tests for !=.

impl<G, S> PartialOrd<PedersenCRH<G, S>> for PedersenCRH<G, S> where
    G: PartialOrd<G> + Group,
    S: PartialOrd<S> + PedersenSize, 

pub fn partial_cmp(&self, other: &PedersenCRH<G, S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<F, G, S> ToConstraintField<F> for PedersenCRH<G, S> where
    G: Group + ToConstraintField<F>,
    S: PedersenSize,
    F: Field, 

pub fn to_field_elements(&self) -> Result<Vec<F, Global>, ConstraintFieldError>

impl<G, S> Eq for PedersenCRH<G, S> where
    G: Eq + Group,
    S: Eq + PedersenSize, 

impl<G, S> StructuralEq for PedersenCRH<G, S> where
    G: Group,
    S: PedersenSize, 

impl<G, S> StructuralPartialEq for PedersenCRH<G, S> where
    G: Group,
    S: PedersenSize,