Enum westend_runtime::EPMCall[−][src]

pub enum EPMCall<T> where
    T: Config,  {
    submit_unsigned {
        raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>,
        witness: SolutionOrSnapshotSize,
    },
    set_minimum_untrusted_score {
        maybe_next_score: Option<[u128; 3]>,
    },
    set_emergency_election_result {
        supports: Vec<(<T as Config>::AccountId, Support<<T as Config>::AccountId>), Global>,
    },
    submit {
        raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>,
        num_signed_submissions: u32,
    },
    // some variants omitted
}

Expand description

Contains one variant per dispatchable that can be called by an extrinsic.

Variants

submit_unsigned

Submit a solution for the unsigned phase.

The dispatch origin fo this call must be none.

This submission is checked on the fly. Moreover, this unsigned solution is only validated when submitted to the pool from the local node. Effectively, this means that only active validators can submit this transaction when authoring a block (similar to an inherent).

To prevent any incorrect solution (and thus wasted time/weight), this transaction will panic if the solution submitted by the validator is invalid in any way, effectively putting their authoring reward at risk.

No deposit or reward is associated with this submission.

Fields of submit_unsigned

raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>witness: SolutionOrSnapshotSize

set_minimum_untrusted_score

Set a new value for MinimumUntrustedScore.

Dispatch origin must be aligned with T::ForceOrigin.

This check can be turned off by setting the value to None.

Fields of set_minimum_untrusted_score

maybe_next_score: Option<[u128; 3]>

set_emergency_election_result

Set a solution in the queue, to be handed out to the client of this pallet in the next call to ElectionProvider::elect.

This can only be set by T::ForceOrigin, and only when the phase is Emergency.

The solution is not checked for any feasibility and is assumed to be trustworthy, as any feasibility check itself can in principle cause the election process to fail (due to memory/weight constrains).

Fields of set_emergency_election_result

supports: Vec<(<T as Config>::AccountId, Support<<T as Config>::AccountId>), Global>

submit

Submit a solution for the signed phase.

The dispatch origin fo this call must be signed.

The solution is potentially queued, based on the claimed score and processed at the end of the signed phase.

A deposit is reserved and recorded for the solution. Based on the outcome, the solution might be rewarded, slashed, or get all or a part of the deposit back.

Queue size must be provided as witness data.

Fields of submit

raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>num_signed_submissions: u32

Enum westend_runtime::EPMCall[−][src]

Variants

Fields of submit_unsigned

Fields of set_minimum_untrusted_score

Fields of set_emergency_election_result

Fields of submit

Implementations

impl<T> Call<T> where T: Config,

pub fn new_call_variant_submit_unsigned( raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>, witness: SolutionOrSnapshotSize) -> Call<T>

pub fn new_call_variant_set_minimum_untrusted_score( maybe_next_score: Option<[u128; 3]>) -> Call<T>

pub fn new_call_variant_set_emergency_election_result( supports: Vec<(<T as Config>::AccountId, Support<<T as Config>::AccountId>), Global>) -> Call<T>

pub fn new_call_variant_submit( raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>, num_signed_submissions: u32) -> Call<T>

Trait Implementations

impl<T> Clone for Call<T> where T: Config,

pub fn clone(&self) -> Call<T>

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

impl<T> Debug for Call<T> where T: Config,

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

impl<T> Decode for Call<T> where T: Config,

pub fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy) -> Result<Call<T>, Error> where __CodecInputEdqy: Input,

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

fn encoded_fixed_size() -> Option<usize>

impl<T> Encode for Call<T> where T: Config,

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

fn size_hint(&self) -> usize

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

fn using_encoded<R, F>(&self, f: F) -> R where F: FnOnce(&[u8]) -> R,

fn encoded_size(&self) -> usize

impl<T> GetCallName for Call<T> where T: Config,

pub fn get_call_name(&self) -> &'static str

pub fn get_call_names() -> &'static [&'static str]

impl<T> GetDispatchInfo for Call<T> where T: Config,

pub fn get_dispatch_info(&self) -> DispatchInfo

impl<T> PartialEq<Call<T>> for Call<T> where T: Config,

pub fn eq(&self, other: &Call<T>) -> bool

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

type Identity = Call<T>

pub fn type_info() -> Type<MetaForm>

impl<T> UnfilteredDispatchable for Call<T> where T: Config,

type Origin = <T as Config>::Origin

pub fn dispatch_bypass_filter( self, origin: <Call<T> as UnfilteredDispatchable>::Origin) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

impl<T> EncodeLike<Call<T>> for Call<T> where T: Config,

impl<T> Eq for Call<T> where T: Config,

Auto Trait Implementations

impl<T> RefUnwindSafe for Call<T> where T: RefUnwindSafe, <T as Config>::AccountId: RefUnwindSafe, <T as Config>::Solution: RefUnwindSafe,

impl<T> Send for Call<T> where T: Send, <T as Config>::Solution: Send,

impl<T> Sync for Call<T> where T: Sync, <T as Config>::Solution: Sync,

impl<T> Unpin for Call<T> where T: Unpin, <T as Config>::AccountId: Unpin,

impl<T> UnwindSafe for Call<T> where T: UnwindSafe, <T as Config>::AccountId: UnwindSafe, <T as Config>::Solution: UnwindSafe,

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

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

pub fn borrow(&self) -> &T

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

pub 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) -> T where Self: Into<T>,

impl<T> Conv for T

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

impl<T> DecodeAll for T where T: Decode,

pub fn decode_all(input: &[u8]) -> Result<T, Error>

impl<T> DecodeLimit for T where T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>( limit: u32, input: &mut I) -> Result<T, Error> where I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>

impl<T> Downcast for T where T: Any,

pub fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

pub fn as_any(&self) -> &(dyn Any + 'static)

pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

impl<T> DowncastSync for T where T: Any + Send + Sync,

pub fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send + 'static>

impl<T> DynClone for T where T: Clone,

pub fn __clone_box(&self, Private) -> *mut ()

impl<T> EncodeAs<T> for T where T: Encode,

pub fn encode_as(&self) -> Vec<u8, Global>

impl<T> Call<T> where
T: Config,

pub fn new_call_variant_submit_unsigned(
raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>,
witness: SolutionOrSnapshotSize
) -> Call<T>

pub fn new_call_variant_set_minimum_untrusted_score(
maybe_next_score: Option<[u128 ; 3]>
) -> Call<T>

pub fn new_call_variant_set_emergency_election_result(
supports: Vec<(<T as Config>::AccountId, Support<<T as Config>::AccountId>), Global>
) -> Call<T>

pub fn new_call_variant_submit(
raw_solution: Box<RawSolution<<T as Config>::Solution>, Global>,
num_signed_submissions: u32
) -> Call<T>

impl<T> Clone for Call<T> where
T: Config,

impl<T> Debug for Call<T> where
T: Config,

impl<T> Decode for Call<T> where
T: Config,

pub fn decode<CodecInputEdqy>(
codec_input_edqy: &mut CodecInputEdqy
) -> Result<Call<T>, Error> where
CodecInputEdqy: Input,

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

impl<T> Encode for Call<T> where
T: Config,

pub fn encode_to<CodecOutputEdqy>(
&self,
codec_dest_edqy: &mut CodecOutputEdqy
) where
CodecOutputEdqy: Output + ?Sized,

fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8 ]) -> R,

impl<T> GetCallName for Call<T> where
T: Config,

pub fn get_call_names() -> &'static [&'static str ]

impl<T> GetDispatchInfo for Call<T> where
T: Config,

impl<T> PartialEq<Call<T>> for Call<T> where
T: Config,

impl<T> UnfilteredDispatchable for Call<T> where
T: Config,

pub fn dispatch_bypass_filter(
self,
origin: <Call<T> as UnfilteredDispatchable>::Origin
) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

impl<T> EncodeLike<Call<T>> for Call<T> where
T: Config,

impl<T> Eq for Call<T> where
T: Config,

impl<T> RefUnwindSafe for Call<T> where
T: RefUnwindSafe,
<T as Config>::AccountId: RefUnwindSafe,
<T as Config>::Solution: RefUnwindSafe,

impl<T> Send for Call<T> where
T: Send,
<T as Config>::Solution: Send,

impl<T> Sync for Call<T> where
T: Sync,
<T as Config>::Solution: Sync,

impl<T> Unpin for Call<T> where
T: Unpin,
<T as Config>::AccountId: Unpin,

impl<T> UnwindSafe for Call<T> where
T: UnwindSafe,
<T as Config>::AccountId: UnwindSafe,
<T as Config>::Solution: UnwindSafe,

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 conv<T>(self) -> T where
Self: Into<T>,

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<T> EncodeAs<T> for T where
T: Encode,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

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,

impl<T> FullLeaf for T where
T: Encode + Decode + Clone + PartialEq<T> + Debug,

pub fn using_encoded<R, F>(&self, f: F, _compact: bool) -> R where
F: FnOnce(&[u8 ]) -> R,

impl<T> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

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

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

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> Pipe for T where
T: ?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 pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,

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

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

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

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

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