Struct Assumption

pub struct Assumption {
    pub claim: Digest,
    pub control_root: Digest,
}

An assumption made in the course of proving program execution.

Assumptions are generated when the guest makes a recursive verification call. Each assumption commits the statement, such that only a receipt proving that statement can be used to resolve and remove the assumption.

Fields

claim: Digest

Commitment to the assumption claim. It may be the digest of a ReceiptClaim, or it could be the digest of the claim for a different circuit such as an accelerator.

control_root: Digest

Commitment to the set of recursion programs that can be used to resolve this assumption.

Binding the set of recursion programs also binds the circuits, and creates an assumption resolved by independent set of circuits (e.g. keccak or Groth16 verify). Proofs of these external claims are verified by a “lift” program implemented for the recursion VM which brings the claim into the recursion system. This lift program is committed to in the control root.

A special value of all zeroes indicates “self-composition”, where the control root used to verify this claim is also used to verify the assumption.

Trait Implementations

impl BorshDeserialize for Assumption

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

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 Assumption

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

impl Clone for Assumption

fn clone(&self) -> Assumption

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Assumption

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Assumption

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Digestible for Assumption

fn digest<S: Sha256>(&self) -> Digest

Hash the Assumption to get a digest of the struct.

impl From<Assumption> for AssumptionReceipt

fn from(assumption: Assumption) -> Self

Create an unresolved assumption from an Assumption.

impl Hash for Assumption

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Assumption

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Assumption

impl StructuralPartialEq for Assumption