Enum polkadot_node_subsystem_types::messages::CandidateValidationMessage

source ·

pub enum CandidateValidationMessage {
    ValidateFromChainState {
        candidate_receipt: CandidateReceipt,
        pov: Arc<PoV>,
        executor_params: ExecutorParams,
        exec_kind: PvfExecKind,
        response_sender: Sender<Result<ValidationResult, ValidationFailed>>,
    },
    ValidateFromExhaustive {
        validation_data: PersistedValidationData,
        validation_code: ValidationCode,
        candidate_receipt: CandidateReceipt,
        pov: Arc<PoV>,
        executor_params: ExecutorParams,
        exec_kind: PvfExecKind,
        response_sender: Sender<Result<ValidationResult, ValidationFailed>>,
    },
    PreCheck {
        relay_parent: Hash,
        validation_code_hash: ValidationCodeHash,
        response_sender: Sender<PreCheckOutcome>,
    },
}

Expand description

Messages received by the Validation subsystem.

§Validation Requests

Validation requests made to the subsystem should return an error only on internal error. Otherwise, they should return either Ok(ValidationResult::Valid(_)) or Ok(ValidationResult::Invalid).

Variants§

§

ValidateFromChainState

Validate a candidate with provided parameters using relay-chain state.

This will implicitly attempt to gather the PersistedValidationData and ValidationCode from the runtime API of the chain, based on the relay_parent of the CandidateReceipt.

This will also perform checking of validation outputs against the acceptance criteria.

If there is no state available which can provide this data or the core for the para is not free at the relay-parent, an error is returned.

Fields

§candidate_receipt: CandidateReceipt

The candidate receipt

§pov: Arc<PoV>

The proof-of-validity

§executor_params: ExecutorParams

Session’s executor parameters

§exec_kind: PvfExecKind

Execution kind, used for timeouts and retries (backing/approvals)

§response_sender: Sender<Result<ValidationResult, ValidationFailed>>

The sending side of the response channel

§

ValidateFromExhaustive

Validate a candidate with provided, exhaustive parameters for validation.

Explicitly provide the PersistedValidationData and ValidationCode so this can do full validation without needing to access the state of the relay-chain.

This request doesn’t involve acceptance criteria checking, therefore only useful for the cases where the validity of the candidate is established. This is the case for the typical use-case: secondary checkers would use this request relying on the full prior checks performed by the relay-chain.

Fields

§validation_data: PersistedValidationData

Persisted validation data

§validation_code: ValidationCode

Validation code

§candidate_receipt: CandidateReceipt

The candidate receipt

§pov: Arc<PoV>

The proof-of-validity

§executor_params: ExecutorParams

Session’s executor parameters

§exec_kind: PvfExecKind

Execution kind, used for timeouts and retries (backing/approvals)

§response_sender: Sender<Result<ValidationResult, ValidationFailed>>

The sending side of the response channel

§

PreCheck

Try to compile the given validation code and send back the outcome.

The validation code is specified by the hash and will be queried from the runtime API at the given relay-parent.

Fields

§relay_parent: Hash

Relay-parent

§validation_code_hash: ValidationCodeHash

Validation code hash

§response_sender: Sender<PreCheckOutcome>

The sending side of the response channel

Enum polkadot_node_subsystem_types::messages::CandidateValidationMessageCopy item path

§Validation Requests

Variants§

ValidateFromChainState

Fields

ValidateFromExhaustive

Fields

PreCheck

Fields

Trait Implementations§

impl Debug for CandidateValidationMessage

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

Auto Trait Implementations§

impl Freeze for CandidateValidationMessage

impl !RefUnwindSafe for CandidateValidationMessage

impl Send for CandidateValidationMessage

impl Sync for CandidateValidationMessage

impl Unpin for CandidateValidationMessage

impl !UnwindSafe for CandidateValidationMessage

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self>where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T>where Self: TryInto<T>,

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T, Outer> IsWrappedBy<Outer> for Twhere Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

fn from_ref(outer: &Outer) -> &T

fn from_mut(outer: &mut Outer) -> &mut T

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pointable for T

const ALIGN: usize = _

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<T> SaturatedConversion for T

fn saturated_from<T>(t: T) -> Selfwhere Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> Twhere Self: UniqueSaturatedInto<T>,

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,

Enum polkadot_node_subsystem_types::messages::CandidateValidationMessage

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self>
where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T>
where Self: TryInto<T>,

fn conv<T>(self) -> T
where Self: Into<T>,

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, Outer> IsWrappedBy<Outer> for T
where Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

fn saturated_from<T>(t: T) -> Self
where Self: UniqueSaturatedFrom<T>,

fn saturated_into<T>(self) -> T
where Self: UniqueSaturatedInto<T>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<S, T> UncheckedInto<T> for S
where T: UncheckedFrom<S>,

impl<T, S> UniqueSaturatedInto<T> for S
where T: Bounded, S: TryInto<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<T> MaybeDebug for T
where T: Debug,