Struct RandomCoin 

pub struct RandomCoin { /* private fields */ }

A simplified version of the SPONGE_PRG reseedable pseudo-random number generator algorithm described in https://eprint.iacr.org/2011/499.pdf.

The simplification is related to the following facts:

1. A call to the reseed method implies one and only one call to the permutation function. This is possible because in our case we never reseed with more than 4 field elements.
2. As a result of the previous point, we don’t make use of an input buffer to accumulate seed material.

Implementations

impl RandomCoin

pub fn new(seed: Word) -> RandomCoin

Returns a new RandomCoin initialized with the specified seed.

pub fn from_parts(state: [Felt; 12], current: usize) -> RandomCoin

Returns a RandomCoin instantiated from the provided components.

Panics

Panics if current is outside of the rate range.

pub fn into_parts(self) -> ([Felt; 12], usize)

Returns components of this random coin.

pub fn fill_bytes(&mut self, dest: &mut [u8])

Fills dest with random data.

pub fn draw_basefield(&mut self) -> Felt

Draws a random base field element from the random coin.

This method applies the Poseidon2 permutation when the rate portion of the state is exhausted, then returns the next element from the rate portion.

pub fn draw(&mut self) -> Felt

Draws a random field element.

This is an alias for Self::draw_basefield.

pub fn draw_ext_field<E>(&mut self) -> E

where E: ExtensionField<Felt>,

Draws a random extension field element.

The extension field element is constructed by drawing E::DIMENSION base field elements and interpreting them as basis coefficients.

pub fn reseed(&mut self, data: Word)

Reseeds the random coin with additional entropy.

The provided data is added to the first half of the rate portion of the state, then the Poseidon2 permutation is applied. The buffer pointer is reset to the start of the rate portion.

Trait Implementations

impl Clone for RandomCoin

fn clone(&self) -> RandomCoin

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RandomCoin

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

Formats the value using the given formatter.

impl Deserializable for RandomCoin

fn read_from<R>(source: &mut R) -> Result<RandomCoin, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl FeltRng for RandomCoin

fn draw_element(&mut self) -> Felt

Draw, uniformly at random, a base field element.

fn draw_word(&mut self) -> Word

Draw, uniformly at random, a Word.

impl PartialEq for RandomCoin

fn eq(&self, other: &RandomCoin) -> 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 RngCore for RandomCoin

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

fn fill_bytes(&mut self, dest: &mut [u8])

Fill dest with random data.

impl Serializable for RandomCoin

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Copy for RandomCoin

impl Eq for RandomCoin

impl StructuralPartialEq for RandomCoin