Enum winter_verifier::HashFunction

pub enum HashFunction {
    Blake3_192,
    Blake3_256,
    Sha3_256,
}

Defines a set of available hash function for STARK protocol.

Choice of a hash function has a direct impact on proof generation time, proof size, and proof soundness. In general, sounds of the proof is bounded by the collision resistance of the hash function used by the protocol.

Variants

Blake3_192

BLAKE3 hash function with 192 bit output.

When this function is used in the STARK protocol, proof security cannot exceed 96 bits.

Blake3_256

BLAKE3 hash function with 256 bit output.

When this function is used in the STARK protocol, proof security cannot exceed 128 bits.

Sha3_256

SHA3 hash function with 256 bit output.

When this function is used in the STARK protocol, proof security cannot exceed 128 bits.

Implementations

impl HashFunction

pub fn collision_resistance(&self) -> u32

Returns collision resistance of this hash function in bits.

Trait Implementations

impl Clone for HashFunction

fn clone(&self) -> HashFunction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HashFunction

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

Formats the value using the given formatter.

impl Deserializable for HashFunction

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

Reads a hash function enum from the specified source.

fn read_batch_from<R>(
    source: &mut R,
    num_elements: usize
) -> Result<Vec<Self, Global>, DeserializationError>where
    R: ByteReader,

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

impl PartialEq<HashFunction> for HashFunction

fn eq(&self, other: &HashFunction) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serializable for HashFunction

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

Serializes self and writes the resulting bytes into the target.

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

Serializes self into a vector of bytes.

fn write_batch_into<W>(source: &[Self], target: &mut W)where
    W: ByteWriter,

Serializes all elements of the source and writes these bytes into the target.

fn get_size_hint(&self) -> usize

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

impl Copy for HashFunction

impl Eq for HashFunction

impl StructuralEq for HashFunction

impl StructuralPartialEq for HashFunction