Struct RpoRandomCoin 

pub struct RpoRandomCoin { /* 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 RpoRandomCoin

pub fn new(seed: Word) -> Self

Returns a new RpoRandomCoin initialize with the specified seed.

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

Returns an RpoRandomCoin instantiated from the provided components.

Panics

Panics if current is smaller than 4 or greater than or equal to 12.

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 Rpo256 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: ExtensionField<Felt>>(&mut self) -> E

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 Rpo256 permutation is applied. The buffer pointer is reset to the start of the rate portion.

pub fn check_leading_zeros(&self, value: u64) -> u32

Checks how many leading zeros a value would produce when hashed with the current state.

This method creates a temporary copy of the state, adds the provided value to the first rate element, applies the Rpo256 permutation, and returns the number of trailing zeros in the resulting first rate element. This is useful for proof-of-work style computations.

pub fn draw_integers( &mut self, num_values: usize, domain_size: usize, nonce: u64, ) -> Vec<usize>

Draws a specified number of unique random integers from a domain of a given size.

Arguments

• num_values - The number of unique integers to draw (must be less than domain_size)
• domain_size - The size of the domain (must be a power of two)
• nonce - A nonce value that is absorbed into the state before drawing

Returns

A vector of num_values unique integers in the range [0, domain_size)

Panics

Panics if domain_size is not a power of two or if num_values >= domain_size.

Trait Implementations

impl Clone for RpoRandomCoin

fn clone(&self) -> RpoRandomCoin

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RpoRandomCoin

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

Formats the value using the given formatter.

impl Deserializable for RpoRandomCoin

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

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 RpoRandomCoin

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 RpoRandomCoin

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

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 RpoRandomCoin

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

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 RpoRandomCoin

impl Eq for RpoRandomCoin

impl StructuralPartialEq for RpoRandomCoin