Struct CommitmentKey 

pub struct CommitmentKey<C>
where
    C: Curve,
{
    pub g: C,
    pub h: C,
}

A commitment key is a pair of group elements that are used as a base to raise the value and randomness, respectively.

Fields

g: C

Base to raise the value to when committing.

h: C

Base to raise the randomness to when committing.

Implementations

impl<C> CommitmentKey<C>

where C: Curve,

pub fn new(g: C, h: C) -> CommitmentKey<C>

pub fn commit<T, V>( &self, s: &V, csprng: &mut T, ) -> (Commitment<C>, Randomness<C>)

where V: AsRef<<C as Curve>::Scalar>, T: Rng,

Commit to the given value using a freshly generated randomness, and return the randomness that was generated.

pub fn hide_worker( &self, value: &<C as Curve>::Scalar, randomness: &<C as Curve>::Scalar, ) -> Commitment<C>

The low-level worker function that actually does the commitment. The interface is not very type-safe, hence the availability of other functions.

pub fn hide<V>(&self, s: &V, r: &Randomness<C>) -> Commitment<C>

where V: AsRef<<C as Curve>::Scalar>,

Hide the value inside a commitment using the given randomness.

pub fn open(&self, s: &Value<C>, r: &Randomness<C>, c: &Commitment<C>) -> bool

Prove that the commitment self contains the given value and randomness.

pub fn generate<T>(csprng: &mut T) -> CommitmentKey<C>

where T: Rng,

Trait Implementations

impl<C> Clone for CommitmentKey<C>

where C: Clone + Curve,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for CommitmentKey<C>

where C: Debug + Curve,

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

Formats the value using the given formatter.

impl<C> Deserial for CommitmentKey<C>

where C: Curve,

fn deserial<GenericReaderType>( source: &mut GenericReaderType, ) -> Result<CommitmentKey<C>, Error>

where GenericReaderType: ReadBytesExt,

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

where C: Curve,

fn deserialize<GenericSerializerType>( deserializer: GenericSerializerType, ) -> Result<CommitmentKey<C>, <GenericSerializerType as Deserializer<'de>>::Error>

where GenericSerializerType: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> PartialEq for CommitmentKey<C>

where C: PartialEq + Curve,

fn eq(&self, other: &CommitmentKey<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C> Serial for CommitmentKey<C>

where C: Curve,

fn serial<GenericBufferType>(&self, out: &mut GenericBufferType)

where GenericBufferType: Buffer,

impl<C> Serialize for CommitmentKey<C>

where C: Curve,

fn serialize<GenericSerializerType>( &self, serializer: GenericSerializerType, ) -> Result<<GenericSerializerType as Serializer>::Ok, <GenericSerializerType as Serializer>::Error>

where GenericSerializerType: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Copy for CommitmentKey<C>

where C: Copy + Curve,

impl<C> Eq for CommitmentKey<C>

where C: Eq + Curve,

impl<C> StructuralPartialEq for CommitmentKey<C>

where C: Curve,