Struct Session

#[non_exhaustive]
pub struct Session {

    pub segments: Vec<Box<dyn SegmentRef>>,
    pub input: Digest,
    pub journal: Option<Journal>,
    pub exit_code: ExitCode,
    pub assumptions: Vec<(Assumption, AssumptionReceipt)>,
    pub mmr_assumptions: Vec<AssumptionReceipt>,
    pub hooks: Vec<Box<dyn SessionEvents>>,
    pub user_cycles: u64,
    pub paging_cycles: u64,
    pub reserved_cycles: u64,
    pub total_cycles: u64,
    pub pre_state: SystemState,
    pub post_state: SystemState,
    /* private fields */
}

Available on crate feature prove and non-target_os="zkvm" only.

The execution trace of a program.

The record of memory transactions of an execution that starts from an initial memory image (which includes the starting PC) and proceeds until either a sys_halt or a sys_pause syscall is encountered. This record is stored as a vector of Segments.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

segments: Vec<Box<dyn SegmentRef>>

The constituent Segments of the Session. The final Segment will have an ExitCode of Halted, Paused, or SessionLimit, and all other Segments (if any) will have ExitCode::SystemSplit.

input: Digest

The input digest.

journal: Option<Journal>

The data publicly committed by the guest program.

exit_code: ExitCode

The ExitCode of the session.

assumptions: Vec<(Assumption, AssumptionReceipt)>

The list of assumptions made by the guest and resolved by the host.

mmr_assumptions: Vec<AssumptionReceipt>

The list of assumptions made by the guest and resolved by the host in an mmr.

hooks: Vec<Box<dyn SessionEvents>>

The hooks to be called during the proving phase.

user_cycles: u64

The number of user cycles without any overhead for continuations or po2 padding.

paging_cycles: u64

The number of cycles needed for paging operations.

reserved_cycles: u64

The number of cycles needed for the proof system which includes padding up to the nearest power of 2.

total_cycles: u64

Total number of cycles that a prover experiences. This includes overhead associated with continuations and padding up to the nearest power of 2.

pre_state: SystemState

The system state of the initial MemoryImage.

post_state: SystemState

The system state of the final MemoryImage at the end of execution.

Implementations

impl Session

pub fn prove(&self) -> Result<ProveInfo>

For each segment, call ProverServer::prove_session and collect the receipts.

impl Session

pub fn add_hook<E: SessionEvents + 'static>(&mut self, hook: E)

Add a hook to be called during the proving phase.

pub fn claim(&self) -> Result<ReceiptClaim>

Calculate for the ReceiptClaim associated with this Session. The ReceiptClaim is the claim that will be proven if this Session is passed to the crate::Prover.

pub fn log(&self)

Log cycle information for this Session.

This logs the total and user cycles for this Session at the INFO level.

pub fn stats(&self) -> SessionStats

Returns stats for the session

This contains cycle and segment information about the session useful for debugging and measuring performance.