Struct sov_modules_api::StateTransition

pub struct StateTransition<Da, Address>where
    Da: DaSpec,{
    pub initial_state_root: [u8; 32],
    pub final_state_root: [u8; 32],
    pub slot_hash: <Da as DaSpec>::SlotHash,
    pub rewarded_address: Address,
    pub validity_condition: <Da as DaSpec>::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: [u8; 32]

The state of the rollup before the transition

final_state_root: [u8; 32]

The state of the rollup after the transition

slot_hash: <Da as DaSpec>::SlotHash

The slot hash of the state transition

rewarded_address: Address

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

validity_condition: <Da as DaSpec>::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, Address> BorshDeserialize for StateTransition<Da, Address>where Da: DaSpec, [u8; 32]: BorshDeserialize, <Da as DaSpec>::SlotHash: BorshDeserialize, Address: BorshDeserialize, <Da as DaSpec>::ValidityCondition: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R ) -> Result<StateTransition<Da, Address>, 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<Da, Address> BorshSerialize for StateTransition<Da, Address>where Da: DaSpec, [u8; 32]: BorshSerialize, <Da as DaSpec>::SlotHash: BorshSerialize, Address: BorshSerialize, <Da as DaSpec>::ValidityCondition: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl<Da, Address> Clone for StateTransition<Da, Address>where Da: Clone + DaSpec, Address: Clone, <Da as DaSpec>::SlotHash: Clone, <Da as DaSpec>::ValidityCondition: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Da, Address> Debug for StateTransition<Da, Address>where Da: Debug + DaSpec, Address: Debug, <Da as DaSpec>::SlotHash: Debug, <Da as DaSpec>::ValidityCondition: Debug,

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

Formats the value using the given formatter.

impl<'de, Da, Address> Deserialize<'de> for StateTransition<Da, Address>where Da: DaSpec, Address: Deserialize<'de>, <Da as DaSpec>::SlotHash: Deserialize<'de>, <Da as DaSpec>::ValidityCondition: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D ) -> Result<StateTransition<Da, Address>, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Da, Address> PartialEq<StateTransition<Da, Address>> for StateTransition<Da, Address>where Da: PartialEq<Da> + DaSpec, Address: PartialEq<Address>, <Da as DaSpec>::SlotHash: PartialEq<<Da as DaSpec>::SlotHash>, <Da as DaSpec>::ValidityCondition: PartialEq<<Da as DaSpec>::ValidityCondition>,

fn eq(&self, other: &StateTransition<Da, Address>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Da, Address> Serialize for StateTransition<Da, Address>where Da: DaSpec, Address: Serialize, <Da as DaSpec>::SlotHash: Serialize, <Da as DaSpec>::ValidityCondition: Serialize,

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<Da, Address> Eq for StateTransition<Da, Address>where Da: Eq + DaSpec, Address: Eq, <Da as DaSpec>::SlotHash: Eq, <Da as DaSpec>::ValidityCondition: Eq,

impl<Da, Address> StructuralEq for StateTransition<Da, Address>where Da: DaSpec,

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