Enum SystemEvent 

#[repr(u8)]
pub enum SystemEvent {
    MerkleNodeMerge = 0,
    MerkleNodeToStack = 1,
    MapValueToStack = 2,
    MapValueToStackN = 3,
    HasMapKey = 4,
    Ext2Inv = 5,
    U32Clz = 6,
    U32Ctz = 7,
    U32Clo = 8,
    U32Cto = 9,
    ILog2 = 10,
    MemToMap = 11,
    HdwordToMap = 12,
    HdwordToMapWithDomain = 13,
    HqwordToMap = 14,
    HpermToMap = 15,
}

Defines a set of actions which can be initiated from the VM to inject new data into the advice provider.

These actions can affect all 3 components of the advice provider: Merkle store, advice stack, and advice map.

All actions, except for MerkleNodeMerge, Ext2Inv and UpdateMerkleNode can be invoked directly from Miden assembly via dedicated instructions.

System event IDs are derived from blake3-hashing their names (prefixed with “sys::”).

The enum variant order matches the indices in SYSTEM_EVENT_LOOKUP, allowing efficient const lookup via to_event_id(). The discriminants are implicitly 0, 1, 2, … 15.

Variants

MerkleNodeMerge = 0

Creates a new Merkle tree in the advice provider by combining Merkle trees with the specified roots. The root of the new tree is defined as Hash(LEFT_ROOT, RIGHT_ROOT).

Inputs: Operand stack: [RIGHT_ROOT, LEFT_ROOT, …] Merkle store: {RIGHT_ROOT, LEFT_ROOT}

Outputs: Operand stack: [RIGHT_ROOT, LEFT_ROOT, …] Merkle store: {RIGHT_ROOT, LEFT_ROOT, hash(LEFT_ROOT, RIGHT_ROOT)}

After the operation, both the original trees and the new tree remains in the advice provider (i.e., the input trees are not removed).

MerkleNodeToStack = 1

Pushes a node of the Merkle tree specified by the values on the top of the operand stack onto the advice stack.

Inputs: Operand stack: [depth, index, TREE_ROOT, …] Advice stack: […] Merkle store: {TREE_ROOT<-NODE}

Outputs: Operand stack: [depth, index, TREE_ROOT, …] Advice stack: [NODE, …] Merkle store: {TREE_ROOT<-NODE}

MapValueToStack = 2

Pushes a list of field elements onto the advice stack. The list is looked up in the advice map using the specified word from the operand stack as the key.

Inputs: Operand stack: [KEY, …] Advice stack: […] Advice map: {KEY: values}

Outputs: Operand stack: [KEY, …] Advice stack: [values, …] Advice map: {KEY: values}

MapValueToStackN = 3

Pushes a list of field elements onto the advice stack, and then the number of elements pushed. The list is looked up in the advice map using the specified word from the operand stack as the key.

Inputs: Operand stack: [KEY, …] Advice stack: […] Advice map: {KEY: values}

Outputs: Operand stack: [KEY, …] Advice stack: [num_values, values, …] Advice map: {KEY: values}

HasMapKey = 4

Pushes a flag onto the advice stack whether advice map has an entry with specified key.

If the advice map has the entry with the key equal to the key placed at the top of the operand stack, 1 will be pushed to the advice stack and 0 otherwise.

Inputs: Operand stack: [KEY, …] Advice stack: […]

Outputs: Operand stack: [KEY, …] Advice stack: [has_mapkey, …]

Ext2Inv = 5

Given an element in a quadratic extension field on the top of the stack (i.e., a0, b1), computes its multiplicative inverse and push the result onto the advice stack.

Inputs: Operand stack: [a1, a0, …] Advice stack: […]

Outputs: Operand stack: [a1, a0, …] Advice stack: [b0, b1…]

Where (b0, b1) is the multiplicative inverse of the extension field element (a0, a1) at the top of the stack.

U32Clz = 6

Pushes the number of the leading zeros of the top stack element onto the advice stack.

Inputs: Operand stack: [n, …] Advice stack: […]

Outputs: Operand stack: [n, …] Advice stack: [leading_zeros, …]

U32Ctz = 7

Pushes the number of the trailing zeros of the top stack element onto the advice stack.

Inputs: Operand stack: [n, …] Advice stack: […]

Outputs: Operand stack: [n, …] Advice stack: [trailing_zeros, …]

U32Clo = 8

Pushes the number of the leading ones of the top stack element onto the advice stack.

Inputs: Operand stack: [n, …] Advice stack: […]

Outputs: Operand stack: [n, …] Advice stack: [leading_ones, …]

U32Cto = 9

Pushes the number of the trailing ones of the top stack element onto the advice stack.

Inputs: Operand stack: [n, …] Advice stack: […]

Outputs: Operand stack: [n, …] Advice stack: [trailing_ones, …]

ILog2 = 10

Pushes the base 2 logarithm of the top stack element, rounded down. Inputs: Operand stack: [n, …] Advice stack: […]

Outputs: Operand stack: [n, …] Advice stack: [ilog2(n), …]

MemToMap = 11

Reads words from memory at the specified range and inserts them into the advice map under the key KEY located at the top of the stack.

Inputs: Operand stack: [KEY, start_addr, end_addr, …] Advice map: {…}

Outputs: Operand stack: [KEY, start_addr, end_addr, …] Advice map: {KEY: values}

Where values are the elements located in memory[start_addr..end_addr].

HdwordToMap = 12

Reads two word from the operand stack and inserts them into the advice map under the key defined by the hash of these words.

Inputs: Operand stack: [B, A, …] Advice map: {…}

Outputs: Operand stack: [B, A, …] Advice map: {KEY: [a0, a1, a2, a3, b0, b1, b2, b3]}

Where KEY is computed as hash(A || B, domain=0)

HdwordToMapWithDomain = 13

Reads two words from the operand stack and inserts them into the advice map under the key defined by the hash of these words (using d as the domain).

Inputs: Operand stack: [B, A, d, …] Advice map: {…}

Outputs: Operand stack: [B, A, d, …] Advice map: {KEY: [a0, a1, a2, a3, b0, b1, b2, b3]}

Where KEY is computed as hash(A || B, d).

HqwordToMap = 14

Reads four words from the operand stack and inserts them into the advice map under the key defined by the hash of these words.

Inputs: Operand stack: [D, C, B, A, …] Advice map: {…}

Outputs: Operand stack: [D, C, B, A, …] Advice map: {KEY: [A’, B’, C’, D’])}

Where:

• KEY is the hash computed as hash(hash(hash(A || B) || C) || D) with domain=0.
• A’ (and other words with ') is the A word with the reversed element order: A = [a3, a2, a1, a0], A’ = [a0, a1, a2, a3].

HpermToMap = 15

Reads three words from the operand stack and inserts the top two words into the advice map under the key defined by applying an RPO permutation to all three words.

Inputs: Operand stack: [B, A, C, …] Advice map: {…}

Outputs: Operand stack: [B, A, C, …] Advice map: {KEY: [a0, a1, a2, a3, b0, b1, b2, b3]}

Where KEY is computed by extracting the digest elements from hperm([C, A, B]). For example, if C is [0, d, 0, 0], KEY will be set as hash(A || B, d).

Implementations

impl SystemEvent

pub const fn from_event_id(event_id: EventId) -> Option<SystemEvent>

Attempts to convert an EventId into a SystemEvent by looking it up in the const table.

Returns Some(SystemEvent) if the ID matches a known system event, None otherwise. This uses a const lookup table with hardcoded EventIds, avoiding runtime hash computation.

pub const fn from_name(name: &str) -> Option<SystemEvent>

Attempts to convert a name into a SystemEvent by looking it up in the const table.

Returns Some(SystemEvent) if the name matches a known system event, None otherwise. This uses const string comparison against the lookup table.

pub const fn event_name(&self) -> EventName

Returns the human-readable name of this system event as an EventName.

System event names are prefixed with sys:: to distinguish them from user-defined events.

pub const fn event_id(&self) -> EventId

Returns the EventId for this system event.

The ID is looked up from the const LOOKUP table using the enum’s discriminant as the index. The discriminants are explicitly set to match the array indices.

pub const fn all() -> [SystemEvent; 16]

Returns an array of all system event variants.

impl SystemEvent

pub const COUNT: usize = 16usize

The total number of system events.

Trait Implementations

impl Clone for SystemEvent

fn clone(&self) -> SystemEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SystemEvent

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

Formats the value using the given formatter.

impl Display for SystemEvent

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

Formats the value using the given formatter.

impl PartialEq for SystemEvent

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

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Copy for SystemEvent

impl Eq for SystemEvent

impl StructuralPartialEq for SystemEvent