Struct Eidos 

pub struct Eidos;

Eidos hash construction.

Byte strings and field-element strings use distinct typed, registered domains. Both constructions bind the exact input length into the initial chaining value. The fixed two-to-one Merkle compression exposed by Self::merge is the sole reserved zero-tag construction and is deliberately distinct from ordinary Felt-sequence hashing. The CryptographicHasher<u64, _> implementations are bit-level adapters for the generic Felt-sequence construction. Canonical Goldilocks encodings produce exactly the same digest as their Felt counterparts. Other u64 values are split into their two limbs without reduction; this deterministic extension is not a separate registered message domain.

Digests occupy a 252-bit packed subspace and therefore provide at most 126 bits of generic collision resistance. Digest coordinates are below 2^63; use crate::rand::EidosRandomCoin when uniform field samples are required. See the module documentation for the output contract.

Implementations

impl Eidos

pub fn compress(cv: Word, block: [Felt; 8]) -> Word

Compress one complete block under a caller-supplied chaining value.

This is the raw compression layer underlying the Eidos hash construction. It does not add domain separation, length binding, padding, or any other message framing. The input CV may contain arbitrary canonical field elements; only the output CV is restricted to Eidos’s 252-bit packed subspace.

pub fn compress_packed( cv: [[Felt; 16]; 4], block: [[Felt; 16]; 8], ) -> [[Felt; 16]; 4]

Compress one complete block in each packed lane.

Each lane is independent. Like Self::compress, this adds no message framing.

pub fn compress_xof(cv: Word, block: [Felt; 8]) -> [Felt; 16]

Return all sixteen raw XOF output lanes for one complete block.

Each u32 lane is embedded as one field element. This is raw XOF material for a caller-supplied CV, not an Eidos digest, and no message framing is added.

pub fn transcript_init_cv<D>(domain: D) -> Word

where D: EidosDomain<Encoding = Transcript>,

Construct the framed initial CV used by a Fiat-Shamir challenger.

The registered transcript tag occupies the domain lane and all three parameter lanes are zero. The transcript’s subsequent absorb and squeeze schedule is defined by its domain.

pub fn init_chaining_word<D>(domain: D, param0: u32) -> Word

where D: EidosDomain,

Construct an initial chaining word with param0 in the first parameter lane.

The remaining two parameter lanes are zero. Standard Felt- and byte-sequence domains use param0 for the complete logical input length; custom domains define it in their registry schema.

pub fn init_chaining_word_with_params<D>(_: D, params: [u32; 3]) -> Word

where D: EidosDomain,

Construct an initial chaining value from a registered domain tag and three parameters.

The domain defines the construction and the meaning of its parameters. Every supplied value occupies one complete low u32 lane; the corresponding high lane is a fixed IV word.

pub fn init_chaining_word_with_tag(tag: DomainTag, params: [u32; 3]) -> Word

Construct an initial chaining value from a structurally valid runtime tag and three parameters.

This is the dynamic counterpart of Self::init_chaining_word_with_params for registries such as deferred precompiles, where the concrete domain is selected at runtime. Constructing a super::DomainTag establishes only its structural and namespace rules; the caller remains responsible for checking membership in the relevant owner registry and enforcing that domain’s parameter and payload schema.

pub fn init_packed_chaining_word<D>(_: D, param0: u32) -> [[Felt; 16]; 4]

where D: EidosDomain,

Construct the same one-parameter initial chaining word in every packed lane.

The interpretation of param0 is defined by the registered domain.

pub fn hash(bytes: &[u8]) -> Word

Hash a byte string with the registered generic byte-string domain.

Panics

Panics if the byte length does not fit in u32.

pub fn hash_in_domain<D>(bytes: &[u8], _: D) -> Word

where D: EidosDomain<Encoding = ByteString>,

Hash a byte string under a typed byte-string domain.

A Felt-sequence or custom-schedule domain cannot be passed to this function.

Panics

Panics if the byte length does not fit in u32.

pub fn hash_elements<E>(elements: &[E]) -> Word

where E: BasedVectorSpace<Felt>,

Hash a field-element sequence under the registered generic Felt-sequence domain.

Panics

Panics if the flattened Felt length overflows usize or does not fit in u32.

pub fn hash_elements_in_domain<E, D>(elements: &[E], _: D) -> Word

where E: BasedVectorSpace<Felt>, D: EidosDomain<Encoding = FeltSequence>,

Hash a field-element sequence under a typed Felt-sequence domain.

A byte-string or custom-schedule domain cannot be passed to this function.

Panics

Panics if the flattened Felt length overflows usize or does not fit in u32.

use miden_crypto::{Felt, hash::eidos::{Eidos, domains::GENERIC_BYTE_STRING}};

let values = [Felt::ZERO];
let _ = Eidos::hash_elements_in_domain(&values, GENERIC_BYTE_STRING);

Raw field elements are not domain declarations either:

use miden_crypto::{Felt, hash::eidos::Eidos};

let values = [Felt::ZERO];
let byte_tag = Felt::new_unchecked(0x0000_0301);
let _ = Eidos::hash_elements_in_domain(&values, byte_tag);

pub fn merge(values: &[Word; 2]) -> Word

Compress two digest words as one reserved Merkle inner node.

This fixed, one-block construction uses the reserved all-zero framing tuple and is intentionally not equivalent to Self::hash_elements over the same eight Felts.

pub fn merkle_node_init_chaining_word() -> Word

Return the initial chaining word reserved for Merkle inner-node compression.

Its four injected framing lanes are all zero. It is exposed for implementations which schedule Self::merge through a separate compression engine; ordinary callers should use Self::merge directly.

pub fn merge_packed(values: &[[[Felt; 16]; 4]; 2]) -> [[Felt; 16]; 4]

Compress two packed digest words as reserved Merkle inner nodes in every packed lane.

This is the packed equivalent of Self::merge.

pub fn hash_double_word(values: &[Word; 2]) -> Word

Hash two words as one generic eight-Felt sequence.

pub fn hash_double_word_packed(values: &[[[Felt; 16]; 4]; 2]) -> [[Felt; 16]; 4]

Hash packed pairs of words as generic eight-Felt sequences.

pub fn hash_double_word_in_domain<D>(values: &[Word; 2], _: D) -> Word

where D: EidosDomain<Encoding = FeltSequence>,

Hash two words as one eight-Felt sequence under a typed Felt-sequence domain.

pub fn hash_words(values: &[Word]) -> Word

Hash a sequence of words under the generic Felt-sequence domain.

Panics

Panics if the flattened Felt length does not fit in u32.

Trait Implementations

impl Clone for Eidos

fn clone(&self) -> Eidos

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Eidos

impl CryptographicHasher<Felt, [Felt; 4]> for Eidos

fn hash_iter<I>(&self, input: I) -> [Felt; 4]

where I: IntoIterator<Item = Felt>,

Hash an iterator of input items.

fn hash_slice(&self, input: &[Felt]) -> [Felt; 4]

Hash a single slice of items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl CryptographicHasher<[Felt; 16], [[Felt; 16]; 4]> for Eidos

fn hash_iter<I>(&self, input: I) -> [[Felt; 16]; 4]

where I: IntoIterator<Item = [Felt; 16]>,

Hash an iterator of input items.

fn hash_slice(&self, input: &[[Felt; 16]]) -> [[Felt; 16]; 4]

Hash a single slice of items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl CryptographicHasher<[u64; 16], [[u64; 16]; 4]> for Eidos

fn hash_iter<I>(&self, input: I) -> [[u64; 16]; 4]

where I: IntoIterator<Item = [u64; 16]>,

Hash an iterator of input items.

fn hash_slice(&self, input: &[[u64; 16]]) -> [[u64; 16]; 4]

Hash a single slice of items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl CryptographicHasher<u64, [u64; 4]> for Eidos

fn hash_iter<I>(&self, input: I) -> [u64; 4]

where I: IntoIterator<Item = u64>,

Hash an iterator of input items.

fn hash_slice(&self, input: &[u64]) -> [u64; 4]

Hash a single slice of items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl Debug for Eidos

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

Formats the value using the given formatter.

impl Eq for Eidos

impl PartialEq for Eidos

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Eidos