Struct PublicValues 

#[repr(C)]
pub struct PublicValues<W1, W2, W3, T> {

    pub prev_committed_value_digest: [W1; 8],
    pub committed_value_digest: [W1; 8],
    pub prev_deferred_proofs_digest: [T; 8],
    pub deferred_proofs_digest: [T; 8],
    pub pc_start: W2,
    pub next_pc: W2,
    pub prev_exit_code: T,
    pub exit_code: T,
    pub is_execution_shard: T,
    pub previous_init_addr: W2,
    pub last_init_addr: W2,
    pub previous_finalize_addr: W2,
    pub last_finalize_addr: W2,
    pub previous_init_page_idx: W2,
    pub last_init_page_idx: W2,
    pub previous_finalize_page_idx: W2,
    pub last_finalize_page_idx: W2,
    pub initial_timestamp: W3,
    pub last_timestamp: W3,
    pub is_timestamp_high_eq: T,
    pub inv_timestamp_high: T,
    pub is_timestamp_low_eq: T,
    pub inv_timestamp_low: T,
    pub global_init_count: T,
    pub global_finalize_count: T,
    pub global_page_prot_init_count: T,
    pub global_page_prot_finalize_count: T,
    pub global_count: T,
    pub global_cumulative_sum: SepticDigest<T>,
    pub prev_commit_syscall: T,
    pub commit_syscall: T,
    pub prev_commit_deferred_syscall: T,
    pub commit_deferred_syscall: T,
    pub initial_timestamp_inv: T,
    pub last_timestamp_inv: T,
    pub is_first_execution_shard: T,
    pub is_untrusted_programs_enabled: T,
    pub proof_nonce: [T; 4],
    pub empty: [T; 4],
}

Stores all of a shard proof’s public values.

Fields

prev_committed_value_digest: [W1; 8]

The committed_value_digest value before this shard.

committed_value_digest: [W1; 8]

The hash of all the bytes that the guest program has written to public values.

prev_deferred_proofs_digest: [T; 8]

The deferred_proof_digest value before this shard.

deferred_proofs_digest: [T; 8]

The hash of all deferred proofs that have been witnessed in the VM. It will be rebuilt in recursive verification as the proofs get verified. The hash itself is a rolling poseidon2 hash of each proof+vkey hash and the previous hash which is initially zero.

pc_start: W2

The shard’s start program counter.

next_pc: W2

The expected start program counter for the next shard.

prev_exit_code: T

The expected exit code of the program before this shard.

exit_code: T

The expected exit code code of the program up to this shard. This value is only valid if halt has been executed.

is_execution_shard: T

Whether or not the current shard is an execution shard.

previous_init_addr: W2

The largest address that is witnessed for initialization in the previous shard.

last_init_addr: W2

The largest address that is witnessed for initialization in the current shard.

previous_finalize_addr: W2

The largest address that is witnessed for finalization in the previous shard.

last_finalize_addr: W2

The largest address that is witnessed for finalization in the current shard.

previous_init_page_idx: W2

The largest page idx that is witnessed for initialization in the previous shard.

last_init_page_idx: W2

The largest page idx that is witnessed for initialization in the current shard.

previous_finalize_page_idx: W2

The largest page idx that is witnessed for finalization in the previous shard.

last_finalize_page_idx: W2

The largest page idx that is witnessed for finalization in the current shard.

initial_timestamp: W3

The initial timestamp of the shard.

last_timestamp: W3

The last timestamp of the shard.

is_timestamp_high_eq: T

If the high bits of timestamp is equal in this shard.

inv_timestamp_high: T

The inverse of the difference of the high bits of timestamp.

is_timestamp_low_eq: T

If the low bits of timestamp is equal in this shard.

inv_timestamp_low: T

The inverse of the difference of the low bits of timestamp.

global_init_count: T

The number of global memory initializations in the shard.

global_finalize_count: T

The number of global memory finalizations in the shard.

global_page_prot_init_count: T

The number of global page prot initializations in the shard.

global_page_prot_finalize_count: T

The number of global page prot finalizations in the shard.

global_count: T

The number of global interactions in the shard.

global_cumulative_sum: SepticDigest<T>

The global cumulative sum of the shard.

prev_commit_syscall: T

The commit_syscall value of the previous shard.

commit_syscall: T

Whether COMMIT syscall has been called up to this shard.

prev_commit_deferred_syscall: T

The commit_deferred_syscall value of the previous shard.

commit_deferred_syscall: T

Whether COMMIT_DEFERRED syscall has been called up to this shard.

initial_timestamp_inv: T

The inverse to show that initial_timestamp != 1 in the shards that aren’t the first one.

last_timestamp_inv: T

The inverse to show that last_timestamp != 1 in all shards.

is_first_execution_shard: T

Whether or not this shard is the first shard of the proof.

is_untrusted_programs_enabled: T

Whether untrusted program support is enabled. This specifically will enable fetching instructions from memory during runtime and checking/setting page permissions.

proof_nonce: [T; 4]

The nonce used for this proof.

empty: [T; 4]

This field is here to ensure that the size of the public values struct is a multiple of 8.

Implementations

impl PublicValues<u32, u64, u64, u32>

pub fn to_vec<F: AbstractField>(&self) -> Vec<F>

Convert the public values into a vector of field elements. This function will pad the vector to the maximum number of public values.

pub fn range(&self) -> ShardRange

Get the range of the shard.

TODO: deprecate this once recursion is fully streaming.

pub fn reset(&self) -> Self

Resets the public values to zero.

pub fn initialize( &self, pc_start_abs: u64, enable_untrusted_programs: bool, ) -> Self

Get the public values corresponding to initial state of the program for a non-execution shard.

pub fn update_state(&mut self, state: &PublicValues<u32, u64, u64, u32>)

Update the public values to the state.

pub fn update_initialized_state( &mut self, pc_start_abs: u64, enable_untrusted_programs: bool, )

Update the public values to the state, as a non-execution shard in the initial state of the program’s execution.

pub fn update_finalized_state( &mut self, timestamp: u64, pc: u64, exit_code: u32, is_untrusted_programs_enabled: u32, committed_value_digest: [u32; 8], deferred_proofs_digest: [u32; 8], nonce: [u32; 4], )

Update the public values to the state, as a non-execution shard in the final state of the program’s execution.

pub fn update_finalized_state_from_public_values( &mut self, public_values: &PublicValues<u32, u64, u64, u32>, )

Similar to [update_finalized_state], but takes all the values from an existing public values struct for convenience.

impl<F: PrimeField32> PublicValues<[F; 4], [F; 3], [F; 4], F>

pub fn commit_digest_bytes(&self) -> Vec<u8>

Returns the commit digest as a vector of little-endian bytes.

pub fn initial_timestamp(&self) -> u64

Returns the initial timestamp.

pub fn last_timestamp(&self) -> u64

Returns the last timestamp.

pub fn previous_init_addr(&self) -> u64

Returns the previous initialization address.

pub fn last_init_addr(&self) -> u64

Returns the last initialization address.

pub fn previous_finalize_addr(&self) -> u64

Returns the previous finalize address.

pub fn last_finalize_addr(&self) -> u64

Returns the last finalize address.

pub fn previous_init_page_idx(&self) -> u64

Returns the previous initialization page index.

pub fn last_init_page_idx(&self) -> u64

Returns the last initialization page index.

pub fn previous_finalize_page_idx(&self) -> u64

Returns the previous finalize page index.

pub fn last_finalize_page_idx(&self) -> u64

Returns the last finalize page index.

pub fn range(&self) -> ShardRange

Returns the range of the shard.

Trait Implementations

impl<T: Clone> Borrow<PublicValues<[T; 4], [T; 3], [T; 4], T>> for [T]

fn borrow(&self) -> &PublicValues<[T; 4], [T; 3], [T; 4], T>

Immutably borrows from an owned value.

impl<T: Clone> BorrowMut<PublicValues<[T; 4], [T; 3], [T; 4], T>> for [T]

fn borrow_mut(&mut self) -> &mut PublicValues<[T; 4], [T; 3], [T; 4], T>

Mutably borrows from an owned value.

impl<W1: Clone, W2: Clone, W3: Clone, T: Clone> Clone for PublicValues<W1, W2, W3, T>

fn clone(&self) -> PublicValues<W1, W2, W3, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W1: Debug, W2: Debug, W3: Debug, T: Debug> Debug for PublicValues<W1, W2, W3, T>

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

Formats the value using the given formatter.

impl<W1: DeepSizeOf, W2: DeepSizeOf, W3: DeepSizeOf, T: DeepSizeOf> DeepSizeOf for PublicValues<W1, W2, W3, T>

fn deep_size_of_children(&self, context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

impl<W1: Default, W2: Default, W3: Default, T: Default> Default for PublicValues<W1, W2, W3, T>

fn default() -> PublicValues<W1, W2, W3, T>

Returns the “default value” for a type.

impl<'de, W1, W2, W3, T> Deserialize<'de> for PublicValues<W1, W2, W3, T>

where W1: Deserialize<'de>, W2: Deserialize<'de>, W3: Deserialize<'de>, T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: AbstractField> From<PublicValues<u32, u64, u64, u32>> for PublicValues<[F; 4], [F; 3], [F; 4], F>

fn from(value: PublicValues<u32, u64, u64, u32>) -> Self

Converts to this type from the input type.

impl<W1: PartialEq, W2: PartialEq, W3: PartialEq, T: PartialEq> PartialEq for PublicValues<W1, W2, W3, T>

fn eq(&self, other: &PublicValues<W1, W2, W3, T>) -> 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<W1, W2, W3, T> Serialize for PublicValues<W1, W2, W3, T>

where W1: Serialize, W2: Serialize, W3: Serialize, T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<W1: Copy, W2: Copy, W3: Copy, T: Copy> Copy for PublicValues<W1, W2, W3, T>

impl<W1: Eq, W2: Eq, W3: Eq, T: Eq> Eq for PublicValues<W1, W2, W3, T>

impl<W1, W2, W3, T> StructuralPartialEq for PublicValues<W1, W2, W3, T>