Enum pallet_asset_management::pallet::Call

pub enum Call<T: Config> {
    execute_call_dispatch {
        account_id: AccountIdOf<T>,
        proposal: Box<<T as Config>::Call>,
    },
    request_asset_management {
        account_id: AccountIdOf<T>,
    },
    launch_representative_session {
        asset_type: PossibleCollections,
        asset_id: T::NftItemId,
        representative: T::AccountId,
        proposal: VoteProposals,
    },
    owners_vote {
        referendum_index: ReferendumIndex,
        vote: bool,
    },
    representative_approval {
        rep_account: T::AccountId,
        collection: T::NftCollectionId,
        item: T::NftItemId,
    },
    demote_representative {
        rep_account: T::AccountId,
        collection: T::NftCollectionId,
        item: T::NftItemId,
    },
    launch_tenant_session {
        asset_type: PossibleCollections,
        asset_id: T::NftItemId,
        tenant: T::AccountId,
        proposal: VoteProposals,
        judgement: Judgement<IdentBalanceOf<T>>,
    },
    link_tenant_to_asset {
        tenant: T::AccountId,
        collection: T::NftCollectionId,
        item: T::NftItemId,
    },
    request_guaranty_payment {
        from: T::AccountId,
        collection: T::NftCollectionId,
        item: T::NftItemId,
        judgement: Judgement<IdentBalanceOf<T>>,
    },
    unlink_tenant_to_asset {
        tenant: T::AccountId,
        collection: T::NftCollectionId,
        item: T::NftItemId,
    },
    // some variants omitted
}

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

Variants

execute_call_dispatch

Fields

account_id: AccountIdOf<T>

proposal: Box<<T as Config>::Call>

Build the call to be executed when the proposal pass the democracy vote The origin must but root

• account_id : the virtual account of the asset of the proposal
• proposal : call encapsulating the inital proposal

request_asset_management

Fields

account_id: AccountIdOf<T>

Using the function below, an active Representative can request an additional asset to manage. The origin must be an active Representative.

• account_id: an account with the representative role

launch_representative_session

Fields

asset_type: PossibleCollections

asset_id: T::NftItemId

representative: T::AccountId

proposal: VoteProposals

Using the function below, an owner triggers a vote session with a proposal for an asset The origin must be an owner of the asset

• asset_type: type of the asset
• asset_id: id of the asset
• representative: an account with the representative role to be designed
• proposal contains the extrinsics to be executed depending on the vote result

owners_vote

Fields

referendum_index: ReferendumIndex

vote: bool

The function below allows the owner to vote. The balance locked and used for vote conviction corresponds to the number of ownership tokens possessed by the voter. The origin must be an owner of the asset

• referendum_index: index of the referendum the voter is taking part in
• vote: aye or nay

representative_approval

Fields

rep_account: T::AccountId

collection: T::NftCollectionId

item: T::NftItemId

The function below allows the approval of a Representative role request The origin must be the virtual account connected to the asset

• rep_account: account Of the candidate to the representative account
• collection: collection number of the asset.
• item: item number of the asset.

demote_representative

Fields

rep_account: T::AccountId

collection: T::NftCollectionId

item: T::NftItemId

The function below allows the demotion of a previously elected Representative The origin must be the virtual account connected to the asset

• rep_account: account Of the candidate to the representative account
• collection: collection_id of the asset.
• item: item_id of the asset.

launch_tenant_session

Fields

asset_type: PossibleCollections

asset_id: T::NftItemId

tenant: T::AccountId

proposal: VoteProposals

judgement: Judgement<IdentBalanceOf<T>>

Using the function below, a representative triggers a vote session with a proposal for a tenant to be linked with an asset The origin must be a representative

• asset_type: type of the asset
• asset_id: id of the asset
• tenant: an account with the tenant role

link_tenant_to_asset

Fields

tenant: T::AccountId

collection: T::NftCollectionId

item: T::NftItemId

The function below links an accepted tenant with an existing asset The origin must be the virtual account connected to the asset

• tenant: an account with the tenant role
• collection: collection_id of the asset
• item: item_id of the asset

request_guaranty_payment

Fields

from: T::AccountId

collection: T::NftCollectionId

item: T::NftItemId

judgement: Judgement<IdentBalanceOf<T>>

The function below sends a guaranty deposiy payment request to a tenant. This extrinsic is executed After a positive tenant_session. The origin must be the virtual account connected to the asset

• tenant: an account with the tenant role linked to the asset
• collection: collection_id of the asset
• item: item_id of the asset
• _judgement is provided by the representative while creating a tenant session

unlink_tenant_to_asset

Fields

tenant: T::AccountId

collection: T::NftCollectionId

item: T::NftItemId

The function below unlinks a tenant with an asset The origin must be the virtual account connected to the asset

• tenant: an account with the tenant role linked to the asset
• collection: collection_id of the asset
• item: item_id of the asset

Implementations

impl<T: Config> Call<T>

pub fn new_call_variant_execute_call_dispatch(
    account_id: AccountIdOf<T>,
    proposal: Box<<T as Config>::Call>
) -> Self

Create a call with the variant execute_call_dispatch.

pub fn new_call_variant_request_asset_management(
    account_id: AccountIdOf<T>
) -> Self

Create a call with the variant request_asset_management.

pub fn new_call_variant_launch_representative_session(
    asset_type: PossibleCollections,
    asset_id: T::NftItemId,
    representative: T::AccountId,
    proposal: VoteProposals
) -> Self

Create a call with the variant launch_representative_session.

pub fn new_call_variant_owners_vote(
    referendum_index: ReferendumIndex,
    vote: bool
) -> Self

Create a call with the variant owners_vote.

pub fn new_call_variant_representative_approval(
    rep_account: T::AccountId,
    collection: T::NftCollectionId,
    item: T::NftItemId
) -> Self

Create a call with the variant representative_approval.

pub fn new_call_variant_demote_representative(
    rep_account: T::AccountId,
    collection: T::NftCollectionId,
    item: T::NftItemId
) -> Self

Create a call with the variant demote_representative.

pub fn new_call_variant_launch_tenant_session(
    asset_type: PossibleCollections,
    asset_id: T::NftItemId,
    tenant: T::AccountId,
    proposal: VoteProposals,
    judgement: Judgement<IdentBalanceOf<T>>
) -> Self

Create a call with the variant launch_tenant_session.

pub fn new_call_variant_link_tenant_to_asset(
    tenant: T::AccountId,
    collection: T::NftCollectionId,
    item: T::NftItemId
) -> Self

Create a call with the variant link_tenant_to_asset.

pub fn new_call_variant_request_guaranty_payment(
    from: T::AccountId,
    collection: T::NftCollectionId,
    item: T::NftItemId,
    judgement: Judgement<IdentBalanceOf<T>>
) -> Self

Create a call with the variant request_guaranty_payment.

pub fn new_call_variant_unlink_tenant_to_asset(
    tenant: T::AccountId,
    collection: T::NftCollectionId,
    item: T::NftItemId
) -> Self

Create a call with the variant unlink_tenant_to_asset.

Trait Implementations

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 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 encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    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> 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.

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<Call<T>> 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,
    AccountIdOf<T>: TypeInfo + 'static,
    Box<<T as Config>::Call>: TypeInfo + 'static,
    T::NftItemId: TypeInfo + 'static,
    T::AccountId: TypeInfo + 'static,
    T::NftCollectionId: TypeInfo + 'static,
    Judgement<IdentBalanceOf<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 Origin = <T as Config>::Origin

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

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

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

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

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