Struct Secret 

pub struct Secret<S: Suite> {
    pub scalar: ScalarField<S>,
    pub public: Public<S>,
}

Secret key for VRF operations.

Contains the private scalar and cached public key. Implements automatic zeroization on drop.

Fields

scalar: ScalarField<S>

public: Public<S>

Implementations

impl<S: Suite> Secret<S>

pub fn from_scalar(scalar: ScalarField<S>) -> Self

Construct a Secret from the given scalar.

pub fn from_seed(seed: &[u8]) -> Self

Derives a Secret scalar deterministically from a seed.

The seed is hashed using Suite::Hasher, and the output is reduced modulo the curve’s order to produce a valid scalar in the range [1, n - 1]. No clamping or multiplication by the cofactor is performed, regardless of the curve.

The caller is responsible for ensuring that the resulting scalar is used safely with respect to the target curve’s cofactor and subgroup properties.

pub fn from_rand(rng: &mut impl RngCore) -> Self

Construct an ephemeral Secret using the provided randomness source.

pub fn public(&self) -> Public<S>

Get the associated public key.

pub fn output(&self, input: Input<S>) -> Output<S>

Get the VRF output point relative to input.

Trait Implementations

impl<S: Suite> CanonicalDeserialize for Secret<S>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl<S: Suite> CanonicalSerialize for Secret<S>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<S: Clone + Suite> Clone for Secret<S>

fn clone(&self) -> Secret<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Suite> Debug for Secret<S>

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

Formats the value using the given formatter.

impl<S: Suite> Drop for Secret<S>

fn drop(&mut self)

Executes the destructor for this type.

impl<S: PartialEq + Suite> PartialEq for Secret<S>

fn eq(&self, other: &Secret<S>) -> 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<S: IetfSuite> Prover<S> for Secret<S>

fn prove( &self, input: Input<S>, output: Output<S>, ad: impl AsRef<[u8]>, ) -> Proof<S>

Implements the IETF VRF proving algorithm.

This follows the procedure specified in RFC-9381 section 5.1, with extensions to support binding additional data to the proof:

1. Generate a deterministic nonce k based on the secret key and input
2. Compute nonce commitments k_b and k_h
3. Compute the challenge c using all public values, nonce commitments and the additional data
4. Compute the response s = k + c * secret

impl<S: PedersenSuite> Prover<S> for Secret<S>

fn prove( &self, input: Input<S>, output: Output<S>, ad: impl AsRef<[u8]>, ) -> (Proof<S>, ScalarField<S>)

Generate a proof for the given input/output and additional data.

impl<S: RingSuite> Prover<S> for Secret<S>

fn prove( &self, input: Input<S>, output: Output<S>, ad: impl AsRef<[u8]>, ring_prover: &RingProver<S>, ) -> Proof<S>

Generate a proof for the given input/output and additional data.

impl<S: Suite> Valid for Secret<S>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl<S: Suite> StructuralPartialEq for Secret<S>