Enum pallet_example_offchain_worker::pallet::Call

pub enum Call<T: Config> {
    submit_price {
        price: u32,
    },
    submit_price_unsigned {
        block_number: BlockNumberFor<T>,
        price: u32,
    },
    submit_price_unsigned_with_signed_payload {
        price_payload: PricePayload<T::Public, BlockNumberFor<T>>,
        signature: T::Signature,
    },
    // some variants omitted
}

A public part of the pallet.

Variants

submit_price

Submit new price to the list.

This method is a public function of the module and can be called from within a transaction. It appends given price to current list of prices. In our example the offchain worker will create, sign & submit a transaction that calls this function passing the price.

The transaction needs to be signed (see ensure_signed) check, so that the caller pays a fee to execute it. This makes sure that it’s not easy (or rather cheap) to attack the chain by submitting excessive transactions, but note that it doesn’t ensure the price oracle is actually working and receives (and provides) meaningful data. This example is not focused on correctness of the oracle itself, but rather its purpose is to showcase offchain worker capabilities.

Fields

price: u32

submit_price_unsigned

Submit new price to the list via unsigned transaction.

Works exactly like the submit_price function, but since we allow sending the transaction without a signature, and hence without paying any fees, we need a way to make sure that only some transactions are accepted. This function can be called only once every T::UnsignedInterval blocks. Transactions that call that function are de-duplicated on the pool level via validate_unsigned implementation and also are rendered invalid if the function has already been called in current “session”.

It’s important to specify weight for unsigned calls as well, because even though they don’t charge fees, we still don’t want a single block to contain unlimited number of such transactions.

This example is not focused on correctness of the oracle itself, but rather its purpose is to showcase offchain worker capabilities.

Fields

block_number: BlockNumberFor<T>

price: u32

submit_price_unsigned_with_signed_payload

Fields

price_payload: PricePayload<T::Public, BlockNumberFor<T>>

signature: T::Signature

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_submit_price(price: u32) -> Self

Create a call with the variant submit_price.

pub fn new_call_variant_submit_price_unsigned( block_number: BlockNumberFor<T>, price: u32, ) -> Self

Create a call with the variant submit_price_unsigned.

pub fn new_call_variant_submit_price_unsigned_with_signed_payload( price_payload: PricePayload<T::Public, BlockNumberFor<T>>, signature: T::Signature, ) -> Self

Create a call with the variant submit_price_unsigned_with_signed_payload.

Trait Implementations

impl<T: Config> CheckIfFeeless for Call<T>

type Origin = <T as Config>::RuntimeOrigin

The Origin type of the runtime.

fn is_feeless(&self, origin: &Self::Origin) -> bool

Checks if the dispatchable satisfies the feeless condition as defined by #[pallet::feeless_if]

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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<T: Config> Encode for Call<T>

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<T: Config> GetCallIndex for Call<T>

fn get_call_index(&self) -> u8

Return the index of this Call.

fn get_call_indices() -> &'static [u8]

Return all call indices in the same order as [GetCallName].

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

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

Return the function name of the Call.

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

Return all function names in the same order as [GetCallIndex].

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

fn get_dispatch_info(&self) -> DispatchInfo

Return a DispatchInfo, containing relevant information of this dispatch.

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

fn eq(&self, other: &Self) -> 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<T> TypeInfo for Call<T>

where PhantomData<(T,)>: TypeInfo + 'static, BlockNumberFor<T>: TypeInfo + 'static, PricePayload<T::Public, BlockNumberFor<T>>: TypeInfo + 'static, T::Signature: TypeInfo + 'static, T: Config + 'static,

type Identity = Call<T>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

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

type RuntimeOrigin = <T as Config>::RuntimeOrigin

The origin type of the runtime, (i.e. frame_system::Config::RuntimeOrigin).

fn dispatch_bypass_filter( self, origin: Self::RuntimeOrigin, ) -> DispatchResultWithPostInfo

Dispatch this call but do not check the filter in origin.

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

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