Struct PedersenCommitter 

pub struct PedersenCommitter<C: PrimeOrderCurve> {
    pub generators: Vec<C>,
    pub blinding_generator: C,
    pub int_abs_val_bitwidth: usize,
    generator_doublings: Vec<Vec<C>>,
}

For committing to vectors of integers and scalars using the Pedersen commitment scheme.

Fields

generators: Vec<C>

vector of “g” generators, i.e. the generators that are exponentiated by the message elements themselves (length > 0) The first N generators are used to commit to a vector of N values. The last generator is used for scalar commitments.

blinding_generator: C

the “h” generator which is exponentiated by the blinding factor

int_abs_val_bitwidth: usize

The bitwidth of the absolute values of the integers that can be committed to using integral vector commit methods (has no bearing on scalar_commit and vector_commit).

generator_doublings: Vec<Vec<C>>

Implementations

impl<C: PrimeOrderCurve> PedersenCommitter<C>

const DEFAULT_INT_ABS_VAL_BITWIDTH: usize = 8

pub fn new( num_generators: usize, public_string: &str, int_abs_val_bitwidth: Option<usize>, ) -> Self

Creates a new PedersenCommitter with random generators. See also PedersenCommitter. Generators are sampled using the public string and the Shake256 hash function. Post: self.generators.len() == num_generators

pub fn scalar_commit_generator(&self) -> C

Return the generator used for scalar commitments.

fn sample_generators(num_generators: usize, public_string: &str) -> Vec<C>

Sample generators using the public string and the Shake256 hash function. Pre: public_string.len() >= 32 Post: result.len() == num_generators TODO: make seekable (block cipher)

pub fn new_with_generators( generators: Vec<C>, blinding_generator: C, int_abs_val_bitwidth: Option<usize>, ) -> Self

Create a new PedersenCommitter with the provided generators. See PedersenCommitter. DEFAULT_INT_ABS_VAL_BITWIDTH is used for int_abs_val_bitwidth if None is provided.

pub fn unsigned_integer_vector_commit<T: Unsigned + Zero + ToBytes>( &self, message: &[T], blinding: &C::Scalar, ) -> C

An optimized version of Pedersen vector commit when the message is comprised of values that fit within 128 bits.

pub fn u8_vector_commit(&self, message: &[u8], blinding: &C::Scalar) -> C

Commits to the vector of u8s using the specified blinding factor. Uses the precomputed generator powers and the binary decomposition. Convient wrapper of integer_vector_commit. Pre: self.int_abs_val_bitwidth >= 8. Post: same result as vector_commit, assuming uints are smaller than scalar field order.

pub fn i8_vector_commit(&self, message: &[i8], blinding: &C::Scalar) -> C

Commits to the vector of i8s using the specified blinding factor. Uses the precomputed generator powers and the binary decomposition. Convient wrapper of integer_vector_commit. Pre: self.int_abs_val_bitwidth >= 8. Post: same result as vector_commit, assuming ints are smaller than scalar field order.

pub fn integer_vector_commit<T: PrimInt>( &self, message: &[T], message_is_negative_bits: &[bool], blinding: &C::Scalar, ) -> C

Commits to the vector of integers using the specified blinding factor. Integers are provided as a vector of UNSIGNED ints and a vector of bits indicating whether the integer is negative. Pre: values in message are non-negative. Pre: values have unsigned binary expressions using at most (self.highest_generator_power + 1) bits. Pre: message.len() <= self.message_generators.len()

pub fn vector_commit(&self, message: &[C::Scalar], blinding: &C::Scalar) -> C

Commit to the provided vector using the specified blinding factor. The first message.len() generators are used to commit to the message. Note that self.int_abs_val_bitwidth is not relevant here. Pre: message.len() <= self.message_generators.len()

pub fn committed_vector( &self, message: &[C::Scalar], blinding: &C::Scalar, ) -> CommittedVector<C>

Convenience wrapper of [self.vector_commit] that returns the commitment wrapped in a CommittedVector.

pub fn scalar_commit(&self, message: &C::Scalar, blinding: &C::Scalar) -> C

Commit to the provided scalar using the specified blinding factor. Note that self.int_abs_val_bitwidth is not relevant here. Pre: self.message_generators.len() >= 1

pub fn committed_scalar( &self, message: &C::Scalar, blinding: &C::Scalar, ) -> CommittedScalar<C>

Convenience wrapper of [self.scalar_commit] that returns the commitment wrapped in a CommittedScalar.

Trait Implementations

impl<C: Clone + PrimeOrderCurve> Clone for PedersenCommitter<C>

fn clone(&self) -> PedersenCommitter<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + PrimeOrderCurve> Debug for PedersenCommitter<C>

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

Formats the value using the given formatter.

impl<'de, C> Deserialize<'de> for PedersenCommitter<C>

where C: PrimeOrderCurve,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> Serialize for PedersenCommitter<C>

where C: PrimeOrderCurve,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.