Enum ProcessState 

pub enum ProcessState<'a> {
    Slow(SlowProcessState<'a>),
    Fast(FastProcessState<'a>),
    Noop(()),
}

Variants

Slow(SlowProcessState<'a>)

Fast(FastProcessState<'a>)

Noop(())

A process state that does nothing. Calling any of its methods results in a panic. It is expected to be used in conjunction with the NoopHost.

Implementations

impl<'a> ProcessState<'a>

pub fn advice_provider(&self) -> &AdviceProvider

Returns a reference to the advice provider.

pub fn advice_provider_mut(&mut self) -> &mut AdviceProvider

Returns a mutable reference to the advice provider.

pub fn clk(&self) -> RowIndex

Returns the current clock cycle of a process.

pub fn ctx(&self) -> ContextId

Returns the current execution context ID.

pub fn get_stack_item(&self, pos: usize) -> Felt

Returns the value located at the specified position on the stack at the current clock cycle.

This method can access elements beyond the top 16 positions by using the overflow table.

pub fn get_stack_word_be(&self, start_idx: usize) -> Word

Returns a word starting at the specified element index on the stack in big-endian (reversed) order.

The word is formed by taking 4 consecutive elements starting from the specified index. For example, start_idx=0 creates a word from stack elements 0-3, start_idx=1 creates a word from elements 1-4, etc.

In big-endian order, stack element N+3 will be at position 0 of the word, N+2 at position 1, N+1 at position 2, and N at position 3. This matches the behavior of mem_loadw_be where mem[a+3] ends up on top of the stack.

This method can access elements beyond the top 16 positions by using the overflow table. Creating a word does not change the state of the stack.

pub fn get_stack_word_le(&self, start_idx: usize) -> Word

Returns a word starting at the specified element index on the stack in little-endian (memory) order.

The word is formed by taking 4 consecutive elements starting from the specified index. For example, start_idx=0 creates a word from stack elements 0-3, start_idx=1 creates a word from elements 1-4, etc.

In little-endian order, stack element N will be at position 0 of the word, N+1 at position 1, N+2 at position 2, and N+3 at position 3. This matches the behavior of mem_loadw_le where mem[a] ends up on top of the stack.

This method can access elements beyond the top 16 positions by using the overflow table. Creating a word does not change the state of the stack.

pub fn get_stack_word(&self, start_idx: usize) -> Word

👎Deprecated since 0.19.0: Use get_stack_word_be() or get_stack_word_le() to make endianness explicit

Returns a word starting at the specified element index on the stack.

This is an alias for Self::get_stack_word_be for backward compatibility. For new code, prefer using the explicit get_stack_word_be() or get_stack_word_le() to make the ordering expectations clear.

See Self::get_stack_word_be for detailed documentation.

pub fn get_stack_state(&self) -> Vec<Felt>

Returns stack state at the current clock cycle. This includes the top 16 items of the stack + overflow entries.

pub fn get_mem_value(&self, ctx: ContextId, addr: u32) -> Option<Felt>

Returns the element located at the specified context/address, or None if the address hasn’t been accessed previously.

pub fn get_mem_word( &self, ctx: ContextId, addr: u32, ) -> Result<Option<Word>, MemoryError>

Returns the batch of elements starting at the specified context/address.

Errors

• If the address is not word aligned.

pub fn get_mem_addr_range( &self, start_idx: usize, end_idx: usize, ) -> Result<Range<u32>, MemoryError>

Reads (start_addr, end_addr) tuple from the specified elements of the operand stack ( without modifying the state of the stack), and verifies that memory range is valid.

pub fn get_mem_state(&self, ctx: ContextId) -> Vec<(MemoryAddress, Felt)>

Returns the entire memory state for the specified execution context at the current clock cycle.

The state is returned as a vector of (address, value) tuples, and includes addresses which have been accessed at least once.

Trait Implementations

impl<'a> Debug for ProcessState<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a mut Process> for ProcessState<'a>

fn from(process: &'a mut Process) -> Self

Converts to this type from the input type.