Struct Tip5

pub struct Tip5 {
    pub state: [BFieldElement; 16],
}

Fields

state: [BFieldElement; 16]

Implementations

impl Tip5

pub const fn new(domain: Domain) -> Tip5

pub fn permutation(&mut self)

pub fn trace(&mut self) -> [[BFieldElement; 16]; 6]

Functionally equivalent to permutation. Returns the trace of applying the permutation; that is, the initial state of the sponge as well as its state after each round.

pub fn hash_10(input: &[BFieldElement; 10]) -> [BFieldElement; 5]

Hash 10 BFieldElements.

There is no input-padding because the input length is fixed.

When you want to hash together two Digests, use Self::hash_pair instead. In some rare cases you do want to hash a fixed-length string of individual BFieldElements, which is why this function is exposed.

See also: Self::hash_pair, Self::hash, Self::hash_varlen.

pub fn hash_pair(left: Digest, right: Digest) -> Digest

Hash two Digests together.

This function is syntax sugar for calling Self::hash_10 on the concatenation of the digests’ values.

See also: Self::hash_10, Self::hash, Self::hash_varlen.

pub fn hash<T>(value: &T) -> Digest

where T: BFieldCodec,

Hash an object based on its BFieldCodec-encoding.

Thin wrapper around hash_varlen.

See also: Self::hash_10, Self::hash_pair, Self::hash_varlen.

pub fn hash_varlen(input: &[BFieldElement]) -> Digest

Hash a variable-length sequence of BFieldElement.

This function pads the input as its length is variable.

Note that Self::hash_varlen and Self::hash_10 are different functions, even when the input to the former, after padding, agrees with the input to the latter. The difference comes from the initial value of the capacity-part of the state, which in the case of variable-length hashing is all-ones but in the case of fixed-length hashing is all-zeroes.

Prefer Self::hash whenever an object is being hashed whose type implements BFieldCodec. However, such an object is not always available, which is why this function is exposed.

See also: Self::hash_10, Self::hash_pair, Self::hash.

pub fn sample_indices( &mut self, upper_bound: u32, num_indices: usize, ) -> Vec<u32>

Produce num_indices random integer values in the range [0, upper_bound). The upper_bound must be a power of 2.

This method uses von Neumann rejection sampling. Specifically, if the top 32 bits of a BFieldElement are all ones, then the bottom 32 bits are not uniformly distributed, and so they are dropped. This method invokes squeeze until enough uniform u32s have been sampled.

pub fn sample_scalars(&mut self, num_elements: usize) -> Vec<XFieldElement>

Produce num_elements random XFieldElement values.

If num_elements is not divisible by RATE, spill the remaining elements of the last squeeze.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for Tip5

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Tip5, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Tip5, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl BFieldCodec for Tip5

type Error = Tip5BFieldDecodingError

fn decode( sequence: &[BFieldElement], ) -> Result<Box<Tip5>, <Tip5 as BFieldCodec>::Error>

fn encode(&self) -> Vec<BFieldElement>

fn static_length() -> Option<usize>

Returns the length in number of BFieldElements if it is known at compile-time. Otherwise, None.

impl Clone for Tip5

fn clone(&self) -> Tip5

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tip5

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

Formats the value using the given formatter.

impl Default for Tip5

fn default() -> Tip5

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Tip5

fn deserialize<__D>( __deserializer: __D, ) -> Result<Tip5, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl GetSize for Tip5

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_heap_size_with_tracker<TRACKER>( &self, tracker: TRACKER, ) -> (usize, TRACKER)

where TRACKER: GetSizeTracker,

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.

impl Hasher for Tip5

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write(&mut self, bytes: &[u8])

Writes some data into this Hasher.

fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

fn write_length_prefix(&mut self, len: usize)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a length prefix into this hasher, as part of being prefix-free.

fn write_str(&mut self, s: &str)

🔬This is a nightly-only experimental API. (hasher_prefixfree_extras)

Writes a single str into this hasher.

impl PartialEq for Tip5

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

Tests for self and other values to be equal, and is used by ==.

const 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 Serialize for Tip5

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sponge for Tip5

const RATE: usize = 10usize

fn init() -> Tip5

fn absorb(&mut self, input: [BFieldElement; 10])

fn squeeze(&mut self) -> [BFieldElement; 10]

fn pad_and_absorb_all(&mut self, input: &[BFieldElement])

impl Eq for Tip5

impl StructuralPartialEq for Tip5