Struct Randomness 

#[repr(transparent)]
pub struct Randomness<C>
where
    C: Curve,
{
    pub randomness: Rc<Secret<<C as Curve>::Scalar>>,
}

Randomness used in the commitment. Secret by default.

Fields

randomness: Rc<Secret<<C as Curve>::Scalar>>

Implementations

impl<C> Randomness<C>

where C: Curve,

pub fn new(x: <C as Curve>::Scalar) -> Randomness<C>

pub fn as_value(&self) -> Value<C>

pub fn from_value(x: &Value<C>) -> Randomness<C>

pub fn from_u64(x: u64) -> Randomness<C>

pub fn zero() -> Randomness<C>

Zero randomness.

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

where T: Rng,

Generate a scalar as randomness.

pub fn generate_non_zero<T>(csprng: &mut T) -> Randomness<C>

where T: Rng,

Generate a non-zero scalar as randomness.

Trait Implementations

impl<C> AsRef<<C as Curve>::Scalar> for Randomness<C>

where C: Curve,

fn as_ref(&self) -> &<C as Curve>::Scalar

Converts this type into a shared reference of the (usually inferred) input type.

impl<C> Clone for Randomness<C>

where C: Curve,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Randomness<C>

where C: Debug + Curve, <C as Curve>::Scalar: Debug,

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

Formats the value using the given formatter.

impl<C> Deref for Randomness<C>

where C: Curve,

This trait allows automatic conversion of &Randomness<C> to &C::Scalar.

type Target = <C as Curve>::Scalar

The resulting type after dereferencing.

fn deref(&self) -> &<C as Curve>::Scalar

Dereferences the value.

impl<C> Deserial for Randomness<C>

where C: Curve,

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

where GenericReaderType: ReadBytesExt,

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

where C: Curve,

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

where GenericSerializerType: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> PartialEq for Randomness<C>

where C: PartialEq + Curve, <C as Curve>::Scalar: PartialEq,

fn eq(&self, other: &Randomness<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 Randomness<C>

where C: Curve,

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

where GenericBufferType: Buffer,

impl<C> Serialize for Randomness<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> Eq for Randomness<C>

where C: Eq + Curve, <C as Curve>::Scalar: Eq,

impl<C> StructuralPartialEq for Randomness<C>

where C: Curve,