Enum ExitCode

#[non_exhaustive]
pub enum ExitCode {
    Halted(u32),
    Paused(u32),
    SystemSplit,
    SessionLimit,
}

Exit condition indicated by the zkVM at the end of the guest execution.

Exit codes have a “system” part and a “user” part. Semantically, the system part is set to indicate the type of exit (e.g. halt, pause, or system split) and is directly controlled by the zkVM. The user part is an exit code, similar to exit codes used in Linux, chosen by the guest program to indicate additional information (e.g. 0 to indicate success or 1 to indicate an error).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Halted(u32)

This indicates normal termination of a program with an interior exit code returned from the guest program. A halted program cannot be resumed.

Paused(u32)

This indicates the execution ended in a paused state with an interior exit code set by the guest program. A paused program can be resumed such that execution picks up where it left of, with the same memory state.

SystemSplit

This indicates the execution ended on a host-initiated system split.

System split is mechanism by which the host can temporarily stop execution of the guest. Execution ended in a system split has no output and no conclusions can be drawn about whether the program will eventually halt. System split is used in continuations to split execution into individually provable segments.

SessionLimit

This indicates that the guest exited upon reaching the session limit set by the host.

NOTE: The current version of the RISC Zero zkVM will never exit with an exit code of SessionLimit. This is because the system cannot currently prove that the session limit as been reached.

Implementations

impl ExitCode

pub fn into_pair(self) -> (u32, u32)

Convert this ExitCode into a pair representation, where the first number is the “system” part, and the second is the “user” part. E.g. Halted(255) -> (0, 255)

pub fn from_pair( sys_exit: u32, user_exit: u32, ) -> Result<ExitCode, InvalidExitCodeError>

Convert this ExitCode from its pair representation, where the first number is the “system” part, and the second is the “user” part. E.g. (0, 255) -> Halted(255)

pub fn expects_output(&self) -> bool

Whether the verifier should expect a non-empty output field. Exit codes Halted and Paused produce can produce a non-empty outputs, whereas system initiated exits like SystemSplit do not.

pub fn is_ok(&self) -> bool

True if the exit code is Halted(0), indicating the program guest exited with an ok status.

Trait Implementations

impl BorshDeserialize for ExitCode

fn deserialize_reader<__R>(reader: &mut __R) -> Result<ExitCode, Error>

where __R: Read,

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for ExitCode

fn serialize<__W>(&self, writer: &mut __W) -> Result<(), Error>

where __W: Write,

impl Clone for ExitCode

fn clone(&self) -> ExitCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExitCode

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExitCode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EnumExt for ExitCode

fn deserialize_variant<__R>( reader: &mut __R, variant_tag: u8, ) -> Result<ExitCode, Error>

where __R: Read,

Deserialises given variant of an enum from the reader.

impl PartialEq for ExitCode

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

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 Copy for ExitCode

impl Eq for ExitCode

impl StructuralPartialEq for ExitCode