Struct StateTransitionData 

pub struct StateTransitionData<StateRoot, Witness, DA: DaSpec> {
    pub pre_state_root: StateRoot,
    pub da_block_header: DA::BlockHeader,
    pub inclusion_proof: DA::InclusionMultiProof,
    pub completeness_proof: DA::CompletenessProof,
    pub blobs: Vec<<DA as DaSpec>::BlobTransaction>,
    pub state_transition_witness: Witness,
}

Data required to verify a state transition.

Fields

pre_state_root: StateRoot

The state root before the state transition

da_block_header: DA::BlockHeader

The header of the da block that is being processed

inclusion_proof: DA::InclusionMultiProof

The proof of inclusion for all blobs

completeness_proof: DA::CompletenessProof

The proof that the provided set of blobs is complete

blobs: Vec<<DA as DaSpec>::BlobTransaction>

The blobs that are being processed

state_transition_witness: Witness

The witness for the state transition

Trait Implementations

impl<StateRoot, Witness, DA: DaSpec> BorshDeserialize for StateTransitionData<StateRoot, Witness, DA>

where StateRoot: BorshDeserialize, DA::BlockHeader: BorshDeserialize, DA::InclusionMultiProof: BorshDeserialize, DA::CompletenessProof: BorshDeserialize, Vec<<DA as DaSpec>::BlobTransaction>: BorshDeserialize, Witness: 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<StateRoot, Witness, DA: DaSpec> BorshSerialize for StateTransitionData<StateRoot, Witness, DA>

where StateRoot: BorshSerialize, DA::BlockHeader: BorshSerialize, DA::InclusionMultiProof: BorshSerialize, DA::CompletenessProof: BorshSerialize, Vec<<DA as DaSpec>::BlobTransaction>: BorshSerialize, Witness: 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<'de, StateRoot, Witness, DA: DaSpec> Deserialize<'de> for StateTransitionData<StateRoot, Witness, DA>

where StateRoot: Serialize + DeserializeOwned, Witness: Serialize + DeserializeOwned,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<StateRoot, Witness, DA: DaSpec> Serialize for StateTransitionData<StateRoot, Witness, DA>

where StateRoot: Serialize + DeserializeOwned, Witness: Serialize + DeserializeOwned,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.