Struct StateTransition

pub struct StateTransition<Da: DaSpec, Address, Root> {
    pub initial_state_root: Root,
    pub final_state_root: Root,
    pub slot_hash: Da::SlotHash,
    pub rewarded_address: Address,
    pub validity_condition: Da::ValidityCondition,
}

The public output of a SNARK proof in Sovereign, this struct makes a claim that the state of the rollup has transitioned from initial_state_root to final_state_root if and only if the condition validity_condition is satisfied.

The period of time covered by a state transition proof may be a single slot, or a range of slots on the DA layer.

Fields

initial_state_root: Root

The state of the rollup before the transition

final_state_root: Root

The state of the rollup after the transition

slot_hash: Da::SlotHash

The slot hash of the state transition

rewarded_address: Address

Rewarded address: the account that has produced the transition proof.

validity_condition: Da::ValidityCondition

An additional validity condition for the state transition which needs to be checked outside of the zkVM circuit. This typically corresponds to some claim about the DA layer history, such as (X) is a valid block on the DA layer

Trait Implementations

impl<Da: DaSpec, Address, Root> BorshDeserialize for StateTransition<Da, Address, Root>

where Root: BorshDeserialize, Da::SlotHash: BorshDeserialize, Address: BorshDeserialize, Da::ValidityCondition: BorshDeserialize,

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<Da: DaSpec, Address, Root> BorshSerialize for StateTransition<Da, Address, Root>

where Root: BorshSerialize, Da::SlotHash: BorshSerialize, Address: BorshSerialize, Da::ValidityCondition: BorshSerialize,

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

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl<Da: Clone + DaSpec, Address: Clone, Root: Clone> Clone for StateTransition<Da, Address, Root>

where Da::SlotHash: Clone, Da::ValidityCondition: Clone,

fn clone(&self) -> StateTransition<Da, Address, Root>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Da: Debug + DaSpec, Address: Debug, Root: Debug> Debug for StateTransition<Da, Address, Root>

where Da::SlotHash: Debug, Da::ValidityCondition: Debug,

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

Formats the value using the given formatter.

impl<'de, Da: DaSpec, Address, Root> Deserialize<'de> for StateTransition<Da, Address, Root>

where Address: Deserialize<'de>, Root: Deserialize<'de>, Da::SlotHash: Deserialize<'de>, Da::ValidityCondition: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Da: PartialEq + DaSpec, Address: PartialEq, Root: PartialEq> PartialEq for StateTransition<Da, Address, Root>

where Da::SlotHash: PartialEq, Da::ValidityCondition: PartialEq,

fn eq(&self, other: &StateTransition<Da, Address, Root>) -> 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<Da: DaSpec, Address, Root> Serialize for StateTransition<Da, Address, Root>

where Address: Serialize, Root: Serialize, Da::SlotHash: Serialize, Da::ValidityCondition: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Da: Eq + DaSpec, Address: Eq, Root: Eq> Eq for StateTransition<Da, Address, Root>

where Da::SlotHash: Eq, Da::ValidityCondition: Eq,

impl<Da: DaSpec, Address, Root> StructuralPartialEq for StateTransition<Da, Address, Root>