Struct ExecuteRequest 

pub struct ExecuteRequest {
    pub pvd: PersistedValidationData,
    pub pov: PoV,
    pub execution_timeout: Duration,
    pub artifact_checksum: ArtifactChecksum,
    pub relay_parent: Hash,
    pub scheduling_parent: Hash,
    pub descriptor_version: CandidateDescriptorVersion,
}

A request to execute a PVF in the worker process.

This is the IPC message sent from the validation host to the execute worker. It contains only the minimal data needed by the worker to perform validation:

• PVD and PoV to construct ValidationParams for the PVF
• Timeout for execution limits
• Artifact checksum for corruption detection
• Parent hashes for V3+ extension to ValidationParams
• Descriptor version to determine which ValidationParams format to use

Note: This does NOT include the full candidate receipt or other host-side data that the worker doesn’t need.

Fields

pvd: PersistedValidationData

Persisted validation data

pov: PoV

Proof-of-validity

execution_timeout: Duration

Execution timeout

artifact_checksum: ArtifactChecksum

Checksum of the artifact to execute

relay_parent: Hash

The relay parent block hash (for V3+ ValidationParams extension)

scheduling_parent: Hash

The scheduling parent block hash (for V3+ ValidationParams extension)

descriptor_version: CandidateDescriptorVersion

The candidate descriptor version (determines ValidationParams format)

Trait Implementations

impl Decode for ExecuteRequest

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Encode for ExecuteRequest

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl EncodeLike for ExecuteRequest