Enum Call

pub enum Call<T: Config> {
    create_pot {
        pot: T::PotId,
        sponsorship_type: T::SponsorshipType,
        fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    remove_pot {
        pot: T::PotId,
    },
    register_users {
        pot: T::PotId,
        users: Vec<T::AccountId>,
        common_fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        common_reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    remove_users {
        pot: T::PotId,
        users: Vec<T::AccountId>,
    },
    sponsor_for {
        pot: T::PotId,
        calls: Vec<Box<<T as Config>::RuntimeCall>>,
    },
    update_pot_limits {
        pot: T::PotId,
        new_fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        new_reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
    },
    update_users_limits {
        pot: T::PotId,
        new_fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        new_reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance,
        users: Vec<T::AccountId>,
    },
    update_sponsorship_type {
        pot: T::PotId,
        sponsorship_type: T::SponsorshipType,
    },
    // some variants omitted
}

Contains a variant per dispatchable extrinsic that this pallet has.

Variants

create_pot

Create a new sponsorship pot and set its limits. The pot id shouldn’t be in use.

Emits PotCreated(pot) event when successful.

Fields

pot: T::PotId

sponsorship_type: T::SponsorshipType

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

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

remove_pot

Allows the sponsor to remove the pot they have created themselves. The pot must not have any users. Users must have been removed prior to this call.

Emits PotRemoved(pot) when successful

Fields

pot: T::PotId

register_users

Register users for a pot and set the same limit for the list of them. Only pot sponsor can do this.

Emits UsersRegistered(pot, Vec<T::AccountId>) with a list of registered when successful.

Fields

pot: T::PotId

users: Vec<T::AccountId>

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

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

remove_users

Remove users from a pot. Only pot sponsor can do this. None of the specified users must have any reserved balance in their proxy accounts. User must be registered to be removable. Users receive the free balance in their proxy account back into their own accounts when they are removed.

Emits UsersRemoved(pot, Vec<T::AccountId>) with a list of those removed when successful.

Fields

pot: T::PotId

users: Vec<T::AccountId>

sponsor_for

Sponsor me for the given call from the specified pot. The caller must be registered for the pot. The calls must be consistent with the pot’s sponsorship type.

Calls: one or more extrinsics which will be executed paid by the sponsorship. If any call fails all will be rolled back Returns Error if the pot doesn’t exist or the user is not registered for the pot or if their call is not matching the sponsorship type in which case the error would be frame_system::Error::CallFiltered. Also returns error if the call itself should fail for any reason related to either the call or the available fund for the user. In this case the actual error will be depending on the call itself.
Regardless of the sponsorship type, users are not allowed to dispatch calls that would leak fund from their proxy account. If they try to do so they will get Error::BalanceLeak. For example they cannot transfer fund to another account even if the sponsorship type allows Balances calls.

Emits Sponsored {paid, repaid} when successful. The paid is the amount initially transferred to the proxy account of the user by the sponsor. The repaid is the amount repaid to the sponsor after the call has been successfully executed. Please note repaid can be bigger than paid if for any reason the user is able to partially or fully pay back their previous debt to the sponsor too. Also the paid might be less than what the limit for the user allows if the user can support themselves partially or fully based on their free balance in their proxy account . Finally, the paid is limited by the remaining reserve quota for the pot too.

Note: The addition of T::DbWeight::get().reads_writes(2, 2) to the weight is to account for the reads and writes of the pot_details and user_details storage items which are needed during pre and post dispatching this call.

Fields

pot: T::PotId

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

update_pot_limits

Update the pot details. Only the sponsor can do this. If the sponsor is lowering their support, it can work only if the corresponding fee or reserve balance has enough available margin. In other words, the sponsor cannot lower the limit for the fee below what users have already taken from the pot. Similarly, the sponsor cannot lower the reserve below what the users have already borrowed.

Fields

pot: T::PotId

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

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

update_users_limits

Update limits for a number of users in a single call. Only the sponsor can do this. If the sponsor is lowering their support, it can work only if the corresponding fee or reserve balance of all those users have enough available margin.

Fields

pot: T::PotId

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

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

users: Vec<T::AccountId>

update_sponsorship_type

Update the pot’s sponsorship type. Only the sponsor can do this. Emits PotSponsorshipTypeUpdated event when successful.

Fields

pot: T::PotId

sponsorship_type: T::SponsorshipType

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_create_pot( pot: T::PotId, sponsorship_type: T::SponsorshipType, fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, ) -> Self

Create a call with the variant create_pot.

pub fn new_call_variant_remove_pot(pot: T::PotId) -> Self

Create a call with the variant remove_pot.

pub fn new_call_variant_register_users( pot: T::PotId, users: Vec<T::AccountId>, common_fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, common_reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, ) -> Self

Create a call with the variant register_users.

pub fn new_call_variant_remove_users( pot: T::PotId, users: Vec<T::AccountId>, ) -> Self

Create a call with the variant remove_users.

pub fn new_call_variant_sponsor_for( pot: T::PotId, calls: Vec<Box<<T as Config>::RuntimeCall>>, ) -> Self

Create a call with the variant sponsor_for.

pub fn new_call_variant_update_pot_limits( pot: T::PotId, new_fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, new_reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, ) -> Self

Create a call with the variant update_pot_limits.

pub fn new_call_variant_update_users_limits( pot: T::PotId, new_fee_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, new_reserve_quota: <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance, users: Vec<T::AccountId>, ) -> Self

Create a call with the variant update_users_limits.

pub fn new_call_variant_update_sponsorship_type( pot: T::PotId, sponsorship_type: T::SponsorshipType, ) -> Self

Create a call with the variant update_sponsorship_type.

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

Tests for self and other values to be equal, and is used by ==.

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

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