Enum pallet_lottery::pallet::Call

pub enum Call<T: Config> {
    buy_ticket {
        call: Box<<T as Config>::RuntimeCall>,
    },
    set_calls {
        calls: Vec<<T as Config>::RuntimeCall>,
    },
    start_lottery {
        price: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        length: BlockNumberFor<T>,
        delay: BlockNumberFor<T>,
        repeat: bool,
    },
    stop_repeat {},
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

buy_ticket

Fields

call: Box<<T as Config>::RuntimeCall>

Buy a ticket to enter the lottery.

This extrinsic acts as a passthrough function for call. In all situations where call alone would succeed, this extrinsic should succeed.

If call is successful, then we will attempt to purchase a ticket, which may fail silently. To detect success of a ticket purchase, you should listen for the TicketBought event.

This extrinsic must be called by a signed origin.

set_calls

Fields

calls: Vec<<T as Config>::RuntimeCall>

Set calls in storage which can be used to purchase a lottery ticket.

This function only matters if you use the ValidateCall implementation provided by this pallet, which uses storage to determine the valid calls.

This extrinsic must be called by the Manager origin.

start_lottery

Fields

price: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance

length: BlockNumberFor<T>

delay: BlockNumberFor<T>

repeat: bool

Start a lottery using the provided configuration.

This extrinsic must be called by the ManagerOrigin.

Parameters:

• price: The cost of a single ticket.
• length: How long the lottery should run for starting at the current block.
• delay: How long after the lottery end we should wait before picking a winner.
• repeat: If the lottery should repeat when completed.

stop_repeat

If a lottery is repeating, you can use this to stop the repeat. The lottery will continue to run to completion.

This extrinsic must be called by the ManagerOrigin.

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_buy_ticket( call: Box<<T as Config>::RuntimeCall> ) -> Self

Create a call with the variant buy_ticket.

pub fn new_call_variant_set_calls( calls: Vec<<T as Config>::RuntimeCall> ) -> Self

Create a call with the variant set_calls.

pub fn new_call_variant_start_lottery( price: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, length: BlockNumberFor<T>, delay: BlockNumberFor<T>, repeat: bool ) -> Self

Create a call with the variant start_lottery.

pub fn new_call_variant_stop_repeat() -> Self

Create a call with the variant stop_repeat.

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, Box<<T as Config>::RuntimeCall>: TypeInfo + 'static, Vec<<T as Config>::RuntimeCall>: TypeInfo + 'static, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: TypeInfo + 'static, BlockNumberFor<T>: 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>