Struct serp_example_ocw::Module

pub struct Module<T: Trait>(_);

A public part of the pallet.

Implementations

impl<T: Trait + 'static> Module<T>

pub fn prices() -> Vec<u32>

A vector of recently submitted prices.

This is used to calculate average price, should have bounded size.

pub fn next_unsigned_at() -> T::BlockNumber

Defines the block when next unsigned transaction will be accepted.

To prevent spam of unsigned (and unpayed!) transactions on the network, we only allow one transaction every T::UnsignedInterval blocks. This storage entry defines when new transaction is going to be accepted.

impl<T: Trait> Module<T>

Can also be called using Call.

pub fn submit_price(origin: T::Origin, price: u32) -> DispatchResult

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 excesive 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.

NOTE: Calling this function will bypass origin filters.

pub fn submit_price_unsigned(
    origin: T::Origin,
    _block_number: T::BlockNumber,
    price: u32
) -> DispatchResult

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.

NOTE: Calling this function will bypass origin filters.

pub fn submit_price_unsigned_with_signed_payload(
    origin: T::Origin,
    price_payload: PricePayload<T::Public, T::BlockNumber>,
    _signature: T::Signature
) -> DispatchResult

NOTE: Calling this function will bypass origin filters.

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> IntegrityTest for Module<T>

pub fn integrity_test()

Run integrity test.

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait + Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(block_number: T::BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait + Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

pub fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait + Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

pub fn on_initialize(_n: BlockNumber) -> u64

The block is being initialized. Implement to have something happen.

impl<T: Trait> OnRuntimeUpgrade for Module<T>

pub fn on_runtime_upgrade() -> u64

Perform a module upgrade.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>

impl<T: Trait> ValidateUnsigned for Module<T>

type Call = Call<T>

The call to validate

fn validate_unsigned(
    _source: TransactionSource,
    call: &Self::Call
) -> TransactionValidity

Validate unsigned call to this module.

By default unsigned transactions are disallowed, but implementing the validator here we make sure that some particular calls (the ones produced by offchain worker) are being whitelisted and marked as valid.

pub fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch.